---
title: Halüsinasyon
source: 'https://academia.sh/tr/kurslar/yz-muhendisligine-giris/halusinasyon'
course: 'Yapay Zekâ Mühendisliğine Giriş'
language: tr
updated: '2026-08-17T18:06:36+00:00'
license: 'CC BY-SA 4.0'
---

# Halüsinasyon

Yirmi yedi olguluk kurgu belge dağarcığında yirmi dört soru sorulunca kaynaksız yanıtın isabeti 0,2917, uydurma oranı 0,6667 çıkıyor ve iki koşumda 16/24 istekte yanıt değişiyor. Üç azaltma yan yana ölçülüyor: kaynağa bağlama isabeti +0,3750 artırıp uydurmayı 0,3333'e indiriyor, iddia doğrulama uydurmayı 0,0857'ye indiriyor ama bedeli iki çağrı ve 55,5 belirteç, bilmiyorum seçeneği ise isabeti tabanın 0,0417 altına düşürüyor ve 10/24 isteği yanıtsız bırakıyor. Kaynağa bağlamadan sonra kalan dayanaksız iddianın tamamı belgede karşılığı olmayan sorulardan geliyor ve doğrulama düzeneği iki koşumda 0/24 fark veriyor.

Önceki dersin yanlışları görünürdü: model bir toplamı yanlış yazdığında sonuç tek satırda
denetlenebiliyordu. Bu dersin yanlışı görünmüyor. Model, elinde hiçbir dayanak yokken de akıcı ve
kurallı bir yanıt üretir; yanlış yanıtın biçimi doğru yanıtınkiyle aynıdır, aynı kesinlikte
yazılır ve yanıtın kendisine bakarak ayrılamaz. Buna **halüsinasyon** denir.

Ölçüsü isabet değildir, çünkü isabet yalnız son değeri sorar ve bir yanıt tek bir değerden
ibaret değildir: sorulanın yanına konulan gerekçeler, sayılar ve yan bilgiler de yanıtın
parçasıdır ve kullanıcı onları da okur. Ölçü bu yüzden **uydurma oranıdır**: yanıtta geçen kaç
iddia bir belgeye dayanıyor. Bu ders üç azaltma düzeneğini aynı veride yan yana koyar, her birinin
bedelini belirteç ve çağrı olarak yazar ve müfredatın ikinci iddiasını ilk kez gösterir — üçünden
biri sayıyı **düşürür**, ve bu tabloda saklanmaz.

- **DL52. Kurgu belge dağarcığı** tarife açıklamaları, sayaç bakım yordamları ve arıza
  kodlarından oluşur. Her olgu bir `(konu, alan, değer)` üçlüsüdür ve **kurgudur**.
- **DL53. Yirmi dört soru sorulur.** Soruların bir kısmının karşılığı dağarcıkta vardır, bir
  kısmının yoktur; bu ayrım ölçünün merkezindedir.
- **DL54. Benzeticinin iki ayrı bilgi kaynağı vardır:** istemin içine konan **belge**, ve
  **önceden edinilmiş kurgu bilgi**. İkincisi dağarcıkla kısmen çelişir.
- **DL55. Her yanıt iki iddia taşır:** sorulan alan ve yanına eklenen ikinci bir alan. Bir iddia,
  dağarcıkta birebir aynı üçlü varsa **dayanaklıdır**.
- **DL56. İki sayı yan yana yazılır.** İsabet, sorulan alanın değerinin belgeyle uyuşan istek
  oranıdır; yanıtsız kalan istek isabetli sayılmaz. Uydurma oranı, üretilen bütün iddialar içinde
  dayanaksız olanların payıdır.
- **DL57. Belirsizlik iki koşumla ölçülür.** Belgeden okunan değer kopyalanır, bellekten gelen
  değer **örneklemeye açıktır**; tohum 20260219 ile ikinci koşum alınır.

## Kaynaksız Yanıtta Uydurma Oranı

```python
# ORTAK -- KURGUDUR. Benzetici gercek bir uc nokta cagirmaz; belge dagarcigi, sorular
# ve modelin onceden edindigi bilgi standart kitaplikla, tohum 20260218 ile uretilir.
TOHUM, M32 = 20260218, 0xFFFFFFFF


def uretec(t):
    x = ((t ^ (t >> 16)) * 2246822507) & M32
    x = ((x ^ (x >> 13)) * 3266489909) & M32
    s = [(x ^ (x >> 16)) & M32]

    def sonraki():
        s[0] = (s[0] * 1664525 + 1013904223) & M32
        return s[0] / 4294967296
    return sonraki


def belirtecle(metin):
    """Kurgu belirtecleyici: harf obekleri dorder, rakam obekleri ikiser bolunur."""
    cikti, tampon = [], ""
    for ch in metin + " ":
        if ch.isalnum():
            tampon += ch
            continue
        if tampon:
            n = 2 if tampon.isdigit() else 4
            cikti += [tampon[i:i + n] for i in range(0, len(tampon), n)]
            tampon = ""
        if ch.strip():
            cikti.append(ch)
    return cikti


KONU = ["tarife ev", "tarife isyeri", "tarife bahce", "sayac bakim", "sayac degisim",
        "ariza e12", "ariza e31", "ariza e44", "kesinti planli", "kesinti acil",
        "abonelik devir", "abonelik iptal"]
ALAN = ["esik", "sure", "adim", "belge"]
BELGE, BELLEK, GUVEN, ORN = {}, {}, {}, {}
r = uretec(TOHUM + 97)
for k in KONU:                                  # kurgu belge dagarcigi
    for a in ALAN:
        p, v = r(), 2 + int(r() * 40)
        if p < 0.55:
            BELGE[(k, a)] = v
r = uretec(TOHUM + 8080)
for k in KONU:                                  # modelin onceden edindigi kurgu bilgi
    for a in ALAN:
        p, v = r(), 2 + int(r() * 40)
        d = BELGE.get((k, a))
        BELLEK[(k, a)] = d if d is not None and p < 0.58 else v
SORU = [(KONU[i % 12], ALAN[(3 * i + 1) % 4]) for i in range(24)]
r = uretec(TOHUM + 4242)
for i, (k, a) in enumerate(SORU):               # kurgu guven: dogruyla kismen ortusur
    GUVEN[i] = (0.30 + 0.60 * r() if BELLEK[(k, a)] == BELGE.get((k, a))
                else 0.10 + 0.60 * r())
ESIK = 0.55


def sapma(i, j, tohum):
    """Ornekleme cizelgesi: belgeden okunmayan her deger icin tek cekilis."""
    if tohum not in ORN:
        r2 = uretec(tohum + 5551)
        ORN[tohum] = [r2() for _ in range(48)]
    return ORN[tohum][2 * i + j]


def sor(i, duzenek, tohum):
    """Yanit bir iddia listesidir; her iddia (konu, alan, deger) uclusudur."""
    k, a = SORU[i]
    yan = ALAN[(ALAN.index(a) + 2) % 4]
    if duzenek == "bilmiyorum" and GUVEN[i] < ESIK:
        return []
    kaynak = BELGE if duzenek in ("baglama", "dogrulama") else {}
    iddia = []
    for j, x in enumerate((a, yan)):
        if (k, x) in kaynak:                    # istemdeki belgeden okunur
            iddia.append((k, x, kaynak[(k, x)]))
            continue
        v = BELLEK[(k, x)]                      # bellekten gelen deger orneklemeye acik
        iddia.append((k, x, 2 + (v + 7) % 40 if sapma(i, j, tohum) < 0.25 else v))
    if duzenek == "dogrulama":                  # ikinci cagri: her iddia belgede aranir
        r2 = uretec(TOHUM + 611 * i)
        iddia = [c for c in iddia if BELGE.get((c[0], c[1])) == c[2] or r2() < 0.10]
    return iddia


def olc(duzenek, tohum=TOHUM):
    iddia_say = dayanaksiz = isabet = yanitsiz = 0
    for i, (k, a) in enumerate(SORU):
        y = sor(i, duzenek, tohum)
        iddia_say += len(y)
        yanitsiz += not y
        dayanaksiz += sum(BELGE.get((c[0], c[1])) != c[2] for c in y)
        isabet += BELGE.get((k, a)) is not None and any(
            c[1] == a and c[2] == BELGE[(k, a)] for c in y)
    return isabet / 24, dayanaksiz / iddia_say if iddia_say else 0.0, iddia_say, yanitsiz


KAPSANAN = sum((k, a) in BELGE for k, a in SORU)
SB = sum(len(belirtecle(f"{k} icin {a} degeri nedir")) for k, a in SORU) / 24
BB = sum(len(belirtecle(f"{k} {a} degeri {v}")) for (k, a), v in BELGE.items()) / len(KONU)
i1, u1, n1, _ = olc("ciplak")
i2, u2, n2, _ = olc("ciplak", TOHUM + 1)
print(f"kurgu belge dagarcigi {len(BELGE)} olgu, {len(SORU)} soru,"
      f" belgede karsiligi olan {KAPSANAN}/24")
print(f"ciplak cagri, tohum 20260218: isabet {i1:.4f}, uydurma {u1:.4f}, {n1} iddia")
print(f"ciplak cagri, tohum 20260219: isabet {i2:.4f}, uydurma {u2:.4f}, {n2} iddia")
degisen = sum(sor(i, "ciplak", TOHUM) != sor(i, "ciplak", TOHUM + 1) for i in range(24))
print(f"iki kosumda yaniti degisen istek {degisen}/24")
print(f"bedel: istek basina {SB:.1f} belirtec, 1 cagri, gecikme sinifi tek cagri")
```

```
kurgu belge dagarcigi 27 olgu, 24 soru, belgede karsiligi olan 16/24
ciplak cagri, tohum 20260218: isabet 0.2917, uydurma 0.6667, 48 iddia
ciplak cagri, tohum 20260219: isabet 0.3333, uydurma 0.6667, 48 iddia
iki kosumda yaniti degisen istek 16/24
bedel: istek basina 9.8 belirtec, 1 cagri, gecikme sinifi tek cagri
```

Çıplak çağrı yirmi dört isteğin hepsine yanıt veriyor ve **48 iddia** üretiyor. Bunların
**0,6667**'si hiçbir belgeye dayanmıyor. İsabet **0,2917**. Dikkat edilecek şey iki sayının
birbirinden bağımsız hareket edebilmesidir: ikinci koşumda isabet **0,3333**'e çıkarken uydurma
oranı **0,6667**'de kalıyor. İsabet tek bir alanı, uydurma oranı yanıtın tamamını ölçer.

Modelin yanıt vermeyi reddettiği tek bir istek yok. Yirmi dört sorunun **8**'inin dağarcıkta hiç
karşılığı olmamasına rağmen sekizinin de yanıtı var. Bu, halüsinasyonun kaynağını doğrudan
gösteriyor: benzetici, sorulan şeyi belgede aramıyor; **önceden edindiği kurgu bilgiden** en olası
devamı üretiyor, ve o bilgi hem eksik hem de dağarcıkla kısmen çelişik. Metnin akıcılığı,
dayanağın varlığından bağımsızdır.

Terimin kendisi burada bir uyarı gerektirir. Halüsinasyon bir **arıza adı değildir**: model
bozulduğu için değil, tam da tasarlandığı işi yaptığı için uyduruyor. Yaptığı iş bir metnin
olası devamını üretmektir, ve olasılık dayanakla aynı şey değildir. Tabloda bunun karşılığı
şudur: uydurma oranını düşüren hiçbir düzenek modelin içine dokunmuyor, hepsi yanıtın
**çevresine** bir dayanak kaynağı ya da bir denetim adımı koyuyor. Bu ayrım tutulmazsa uydurma
"bir gün düzelecek bir kusur" sanılır ve düzeneğin bedeli bütçeye hiç yazılmaz.

## Üç Azaltma Düzeneği

```python
print("duzenek       isabet  uydurma  iddia  yanitsiz  belirtec  cagri  gecikme")
for d, bel, cg, gc in (("ciplak", SB, 1, "tek cagri"), ("baglama", SB + BB, 1, "tek cagri"),
                       ("bilmiyorum", SB + 9, 1, "tek cagri"),
                       ("dogrulama", 2 * (SB + BB), 2, "zincir   ")):
    i, u, n, ys = olc(d)
    print(f"{d:<12}  {i:.4f}  {u:.4f}    {n:>2}    {ys:>2}/24     {bel:>5.1f}     {cg}"
          f"    {gc}")
t1, t2 = olc("baglama")[0], olc("bilmiyorum")[0]
print(f"taban ciplak cagri {i1:.4f}; baglama {t1 - i1:+.4f}, bilmiyorum {t2 - i1:+.4f},"
      f" dogrulama {olc('dogrulama')[0] - i1:+.4f}")
```

```
duzenek       isabet  uydurma  iddia  yanitsiz  belirtec  cagri  gecikme
ciplak        0.2917  0.6667    48     0/24       9.8     1    tek cagri
baglama       0.6667  0.3333    48     0/24      27.8     1    tek cagri
bilmiyorum    0.2500  0.5714    28    10/24      18.8     1    tek cagri
dogrulama     0.6667  0.0857    35     2/24      55.5     2    zincir   
taban ciplak cagri 0.2917; baglama +0.3750, bilmiyorum -0.0417, dogrulama +0.3750
```

**Kaynağa bağlama** ilgili belgeyi istemin içine koyuyor. İsabet **+0,3750** artıyor, uydurma
oranı yarıya iniyor. Bedel dürüsttür ve belirteçle ölçülür: istek başına 9,8 belirteç yerine
**27,8** belirteç, yani üç katına yakın. Çağrı sayısı değişmiyor.

**İddia doğrulama** yanıtı ikinci bir çağrıda tek tek dağarcığa soruyor ve karşılığı bulunamayan
iddiayı düşürüyor. Uydurma oranı **0,0857**'ye iniyor, bu tablodaki en düşük sayı. Bedeli de en
yüksek: **55,5** belirteç, **iki çağrı** ve **zincir** gecikme sınıfı, çünkü ikinci çağrı
birincinin çıktısını beklemek zorundadır. İsabeti bağlamayla aynı kalıyor, yani ek bedel yalnız
uydurmayı satın alıyor.

**Bilmiyorum seçeneği** üçüncüsüdür ve tabloda sayıyı **düşüren satırdır**. İsabet
**0,2500**'e iniyor: taban olan çıplak çağrının **0,0417 altında**. Sebep yanıtsız sütununda
yazılı — düzenek on isteği yanıtsız bırakıyor ve bunların bir kısmı doğru yanıtlanacak
isteklerdi. Uydurma oranı **0,5714**'e, yani ancak biraz iniyor, çünkü kurgu güven ölçüsü
dayanağın varlığıyla yalnız kısmen örtüşüyor. Düzenek isabetten kesin bir şey götürüyor,
uydurmadan belirsiz bir şey getiriyor. Sayısı yazılmasaydı üç azaltma da "iyileştirme" diye
listelenirdi.

Bu, düzeneğin kötü olduğu anlamına gelmez; **ölçütün seçilmediği** anlamına gelir. Yanlış bir
tarife eşiği söylemenin bedeli, hiçbir şey söylememenin bedelinden ağırsa bilmiyorum seçeneği
kazanır ve isabetteki 0,0417'lik kayıp ucuz bir sigortadır. Tersi durumda aynı düzenek on isteği
karşılıksız bırakan bir gerileme olur. Tabloya bakan mühendisin işi, bu iki bedeli aynı birime
çevirmektir; tablonun işi ise kararın hangi sayıya dayandığını görünür kılmaktır. Eşiğin kendisi
de bir ayardır: 0,55 yerine daha düşük bir değer yanıtsız isteği azaltır ve uydurmayı büyütür.
Yanıtsız sütunu bu yüzden tabloda durur — o sütun yazılmasa isabet düşüşünün nereden geldiği
görünmezdi ve düzenek "işe yaramadı" diye kapatılırdı.

## Uydurma Nereden Geliyor

```python
print("duzenek       isabet A  isabet B  degisen istek  dayanaksiz iddia kaynagi")
for d in ("ciplak", "baglama", "bilmiyorum", "dogrulama"):
    a, b = olc(d)[0], olc(d, TOHUM + 1)[0]
    fark = sum(sor(i, d, TOHUM) != sor(i, d, TOHUM + 1) for i in range(24))
    kapsanan = kapsanmayan = 0
    for i in range(24):
        for c in sor(i, d, TOHUM):
            if BELGE.get((c[0], c[1])) != c[2]:
                kapsanan += (c[0], c[1]) in BELGE
                kapsanmayan += (c[0], c[1]) not in BELGE
    print(f"{d:<12}  {a:.4f}    {b:.4f}      {fark:>2}/24        belgeli {kapsanan:>2},"
          f" belgesiz {kapsanmayan:>2}")
```

```
duzenek       isabet A  isabet B  degisen istek  dayanaksiz iddia kaynagi
ciplak        0.2917    0.3333      16/24        belgeli 16, belgesiz 16
baglama       0.6667    0.6667       8/24        belgeli  0, belgesiz 16
bilmiyorum    0.2500    0.3333       9/24        belgeli  7, belgesiz  9
dogrulama     0.6667    0.6667       0/24        belgeli  0, belgesiz  3
```

Son sütun uydurmayı ikiye ayırıyor. Çıplak çağrının 32 dayanaksız iddiasının **16**'sı dağarcıkta
karşılığı **olan** sorulardadır: belge elimizdeydi, model ona bakmadı. Diğer **16**'sı karşılığı
**olmayan** sorulardadır. Kaynağa bağlama birinci yarıyı **sıfırlıyor** ve ikinci yarıya hiç
dokunmuyor. Bu, kaynağa bağlamanın ne yapıp ne yapamayacağının tam tarifidir: dağarcıkta duran
bilginin uydurulmasını bitirir, dağarcıkta durmayan bilginin uydurulmasını bitirmez. Kalan on altı
iddia için tek çözüm dağarcığı büyütmek ya da yanıtsız bırakmaktır.

Ortadaki sütun belirsizliği ölçüyor. Çıplak çağrı iki koşumda **16/24** istekte başka yanıt
veriyor. Kaynağa bağlama bunu **8/24**'e indiriyor, çünkü belgeden okunan değer kopyalanır ve
örneklemeye açık değildir. İddia doğrulama **0/24** veriyor: iki koşumda birebir aynı yanıt.
Belirsizliği daraltan şey modelin ayarı değil, yanıtın **dayanağa bağlanmış olmasıdır**. Kaynağa
bağlamanın ikinci ve az konuşulan kazancı budur.

Buradan bir tasarım kuralı çıkıyor ve bu müfredatın ilerisine uzanıyor. Uydurmayı azaltmanın
ucuz yolu modeli zorlamak değil, **yanıtın dayanağını isteme koymaktır**; pahalı yolu ise yanıtı
ürettikten sonra denetlemektir. İkisinin bedeli aynı birimle, belirteçle ve çağrıyla yazıldığında
seçim tartışmaya kalmaz. Ancak her ikisi de bir soruyu yanıtsız bırakır: dağarcıkta yüzlerce belge
varsa isteme hangileri konulacak. Bu derste doğru belge her seferinde elle verildi, çünkü konu
sayısı on ikiydi. Belge sayısı büyüdüğünde doğru belgeyi bulmanın kendisi ölçülmesi gereken bir
düzenek olur ve kendi isabeti, kendi belirteç bedeli doğar. Bu müfredatın ilerideki bir kursu tam
olarak o düzeneği kurar; bu ders yalnız niçin gerektiğini sayıyla gösterdi.

## Özet

- Kaynaksız yanıtta 24 istek 48 iddia üretiyor, uydurma oranı 0,6667, isabet 0,2917; model
  dağarcıkta karşılığı olmayan 8 sorunun sekizine de yanıt veriyor.
- Kaynağa bağlama isabeti +0,3750 artırıp uydurmayı 0,3333'e indiriyor, bedeli istek başına 9,8
  belirteçten 27,8 belirtece çıkmaktır.
- İddia doğrulama uydurmayı 0,0857 ile en aşağı çekiyor, bedeli 55,5 belirteç, iki çağrı ve
  zincir gecikme sınıfıdır; isabete bağlamanın üstüne bir şey eklemiyor.
- Bilmiyorum seçeneği isabeti 0,2500'e, yani tabanın 0,0417 altına düşürüyor ve 10/24 isteği
  yanıtsız bırakıyor; eklenen her düzenek iyileştirmez.
- Kaynağa bağlama, belgesi olan iddialarda uydurmayı 16'dan 0'a indiriyor ama belgesiz olanlarda
  16'yı 16 bırakıyor; ayrıca koşumdan koşuma değişen isteği 16/24'ten 8/24'e çekiyor.

## Sonraki Adım

Bu derste ölçülen her düzenek modelin **çevresine** kuruldu: istemin içine belge konuldu, ikinci
bir çağrı eklendi, bir eşik tanımlandı. Hepsi modele erişimin verili olduğunu varsayıyordu. Oysa
o erişimin kendisi bir karardır ve sayıları değiştirir. Bir modele yalnız uzaktaki bir uç nokta
üzerinden ulaşmakla, ağırlıkları elde tutup kendi donanımında çalıştırmak arasında hangi ayarın
kimde kaldığı, aynı işin kaç belirtece mal olduğu ve verinin nereye gittiği farklıdır. Sonraki
ders bu iki erişim biçimini üç ölçütte sayıyla karşılaştırır ve seçimin hangi ölçütte
değiştiğini yazar.
