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

# Çıkarım

Bir yanıtın adım adım üretilmesinin bedeli ve seçim kuralının sayısı: 200 kurgu talepte en olası seçim yanıt başına 6,43 belirteç ve 211,1 karşılaştırma tutuyor, isabeti 1,0000. En büyük çıktı uzunluğu 4'e çekildiğinde bütün yanıtlar sınıra takılıyor ve isabet 0,0000'a, 6'da 0,5450'ye, 7'de 0,8100'e iniyor. Aynı istemde örnekleme dağılım sıcaklığı 0,2'den 2,0'a çıktıkça isabeti 0,9900'den 0,5600'e düşürüyor, iki koşum arasında değişen yanıt oranı 0,5550'den 0,8600'e yükseliyor; en olası seçimde bu oran 0,0000. Giriş 30 belirteç sabitken çıktı 512 belirtece uzadığında karşılaştırmanın 0,8953'ünü çıktının kendisi tutuyor.

Bir önceki ders modelin nereden ne öğrendiğini ayırdı, ama her yerde tek bir tahmin üretti: en
olası belirteç, tek adımda. Gerçek bir yanıt tek belirteç değildir. Model bir belirteç üretir,
onu kendi girdisinin sonuna ekler, bir sonrakini üretir ve durdurma koşulu gelene kadar bunu
sürdürür. **Çıkarım** dediğimiz şey bu döngüdür; bedeli de, belirsizliği de burada doğar.

İki soru ölçülür. Birincisi bedel: bir yanıt uzadıkça ne kadar iş yapılıyor. İkincisi seçim
kuralı: her adımda dağılımın en büyüğü mü alınıyor, yoksa dağılımdan **örnekleniyor** mu — ve bu
karar aynı istemde iki koşumda ne veriyor. Bu ders müfredatın üçüncü iddiasını doğrudan sayar:
model belirsiz bir bileşendir ve belirsizliğin miktarı bir ayardır.

- **DL26.** Talepler ve yanıt örnekleri **kurgudur**: ders içinde üretilir, tohum 20260218. Örnek
  kümesi 600 yanıt, sınama kümesi 200 taleptir.
- **DL27.** Model bir **benzeticidir**: her adımda koşul ve son iki belirteç için bir dağılım
  kurar, bir belirteç seçer ve seçtiğini geçmişe ekler.
- **DL28.** **Durdurma koşulu** noktadır. **En büyük çıktı uzunluğu** ayrı bir sınırdır ve
  aşıldığında yanıt yarıda kesilir.
- **DL29.** Yanıt örneklerinin 0,15'i alanla ilgisiz genel bir kalıptır. Model bu yüzden her
  koşulda tek bir doğru yola sahip değildir.
- **DL30.** **İsabet** yalnız tamamlanmış yanıtlar için sayılır: yanıt noktayla bitmeli, doğru
  nesneyi ve doğru eylemi taşımalıdır. Yarıda kesilen yanıt yanlış sayılır.
- **DL31.** **Bedel** iki birimle yazılır: üretilen belirteç sayısı ve karşılaştırma sayısı. Her
  adım giriş uzunluğu artı o ana kadar üretilen belirteç kadar karşılaştırma tutar.
- **DL32.** Giriş uzunluğu bütün ölçümlerde 30 belirteçtir; değişen tek şey çıktıdır.
- **DL33.** **Dağılım sıcaklığı** olasılıkları üsse taşır: sıfır en olası seçimdir, büyüdükçe
  dağılım düzleşir.
- **DL34.** Belirsizlik ölçüsü **aynı istemin iki koşumudur**: ikinci koşum tohum değiştirilerek
  alınır ve iki koşumda farklı çıkan yanıtların oranı basılır.

## Bir Yanıtın Üretilmesi

Benzetici bir yanıtı bir defada yazmaz. Başlangıç imiyle işe başlar, her adımda bir dağılım kurar,
bir belirteç seçer ve seçtiğini geçmişin sonuna ekler.

```python
# BENZETICI — model ders icinde standart kitaplikla yazilmis bir benzeticidir;
# gercek bir uc nokta cagrilmaz. Talepler ve yanit ornekleri KURGUDUR, tohum 20260218.
TOHUM, M32, ORNEK, SINAMA = 20260218, 0xFFFFFFFF, 600, 200


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


NESNE = ["fatura", "tarife", "sayac", "vana"]
DURUM = ["yuksek", "eksik", "bozuk"]
EYLEM = {"yuksek": "itiraz kaydi acildi", "eksik": "bilgi gonderildi",
         "bozuk": "saha ekibi yonlendirildi"}
KALIP = ["{n} icin {e} .", "{n} kaydi incelendi ve {e} .",
         "{n} durumu icin {e} ."]
GENEL = ["kayit incelendi ve sonuc gonderildi .", "talep alindi ve kayit acildi ."]


def ornek_uret(tohum, sayi):
    v = []
    for i in range(sayi):
        r = uretec(tohum + i)
        n, d = NESNE[int(r() * 4)], DURUM[int(r() * 3)]
        if r() < 0.15:
            y = GENEL[int(r() * 2)]
        else:
            y = KALIP[int(r() * 3)].format(n=n, e=EYLEM[d])
        v.append({"kosul": (n, d), "yanit": ["<bas>"] + y.split()})
    return v


EGT = ornek_uret(TOHUM, ORNEK)
SIN = ornek_uret(TOHUM + 500000, SINAMA)

TABLO = {}
for x in EGT:
    y = x["yanit"]
    for i in range(1, len(y)):
        for a in ((x["kosul"], tuple(y[max(0, i - 2):i])), (x["kosul"], (y[i - 1],))):
            TABLO.setdefault(a, {})
            TABLO[a][y[i]] = TABLO[a].get(y[i], 0) + 1


def dagilim(kosul, gecmis):
    d = TABLO.get((kosul, tuple(gecmis[-2:]))) or TABLO.get(
        (kosul, (gecmis[-1],))) or {".": 1}
    t = sum(d.values())
    return sorted((b, s / t) for b, s in d.items())


def uret(kosul, giris, sicaklik=0.0, tohum=TOHUM, en_buyuk=12):
    """Adim adim uretim: her adimda dagilim kurulur, bir belirtec secilir ve
    gecmise eklenir. Durdurma kosulu nokta, ust sinir en_buyuk belirtectir."""
    r, gecmis, karsi = uretec(tohum + giris), ["<bas>"], 0
    while len(gecmis) - 1 < en_buyuk:
        d = dagilim(kosul, gecmis)
        karsi += giris + len(gecmis) - 1
        if sicaklik <= 0:
            sec = max(d, key=lambda bp: (bp[1], bp[0]))[0]
        else:
            a = [(b, p ** (1 / sicaklik)) for b, p in d]
            u, s = r() * sum(p for _, p in a), 0.0
            sec = a[-1][0]
            for b, p in a:
                s += p
                if u < s:
                    sec = b
                    break
        gecmis.append(sec)
        if sec == ".":
            return gecmis[1:], karsi, "kosul"
    return gecmis[1:], karsi, "sinir"


x = SIN[0]
print(f"kurgu ornek {ORNEK} yanit, sinama {SINAMA} talep")
print(f"talep kosulu {x['kosul']}, dogru eylem: {EYLEM[x['kosul'][1]]}")
for ad, sic, th in (("en olasi secim", 0.0, TOHUM), ("en olasi secim", 0.0, TOHUM + 1),
                    ("ornekleme 1,0", 1.0, TOHUM), ("ornekleme 1,0", 1.0, TOHUM + 1)):
    y, k, dur = uret(x["kosul"], 30, sic, th, 12)
    print(f"{ad:<16} tohum {th}  {len(y):>2} belirtec  {dur:<5}  {' '.join(y)}")
```

```
kurgu ornek 600 yanit, sinama 200 talep
talep kosulu ('sayac', 'yuksek'), dogru eylem: itiraz kaydi acildi
en olasi secim   tohum 20260218   8 belirtec  kosul  sayac kaydi incelendi ve itiraz kaydi acildi .
en olasi secim   tohum 20260219   8 belirtec  kosul  sayac kaydi incelendi ve itiraz kaydi acildi .
ornekleme 1,0    tohum 20260218   8 belirtec  kosul  sayac kaydi incelendi ve itiraz kaydi acildi .
ornekleme 1,0    tohum 20260219   7 belirtec  kosul  sayac durumu icin itiraz kaydi acildi .
```

Dört satır iki şey söylüyor. En olası seçim iki tohumda **birebir aynı** yanıtı veriyor: tohum
hiçbir yere girmez, çünkü hiçbir adımda kura çekilmez. Örnekleme ise ikinci tohumda 8 belirteç
yerine 7 belirteçlik başka bir cümle veriyor. İkisi de doğru; **değişmek ile yanılmak aynı şey
değildir** ve bu ayrım dersin geri kalanının ölçtüğü şeydir.

Döngünün bir başka sonucu gecikmede görünür. Yanıtın ilk belirteci tek bir adım sonra hazırdır,
sonuncusu ise ancak m adım sonra. Bu yüzden bir dil modeli çağrısının gecikmesi tek bir sayı
değildir: ilk belirtece kadar geçen süre ile yanıtın tamamlanmasına kadar geçen süre ayrı ayrı
davranır ve ikincisi çıktı uzunluğuyla birlikte büyür. Bu müfredat süreyi ham birimle yazmaz ama
ayrımı korur; sekiz belirteçlik bir yanıt ile seksen belirteçlik bir yanıt aynı gecikme sınıfında
değildir.

Adım adım seçimin bir de yapısal sınırı var: her adım kendi başına en iyisini seçer, ileriye
bakmaz. Yukarıdaki yanıtta ikinci belirteç `kaydi` seçildiği anda cümle uzun kalıba bağlanmıştır;
o adımda `icin` seçilse cümle iki belirteç kısa bitecekti. **En olası seçim adım başına en
olasıdır, cümle başına değil.** Bu, çıktı uzunluğunun da tam olarak denetlenemediği anlamına
gelir ve bir sonraki bölümün ölçtüğü sınır sorunu buradan doğar.

## Adım Adım Üretimin Bedeli

Her adım kendinden öncekilerin hepsini yeniden okur. Bir yanıt m belirteç uzunluğundaysa ve giriş n
belirteçse, toplam karşılaştırma m·n artı m(m+1)/2 olur: birinci terim girişin tekrar tekrar
okunması, ikincisi çıktının kendi kuyruğudur.

```python
GIRIS = 30


def dogru(y, kosul):
    """Yanit ancak tamamlanmissa ve dogru nesne ile dogru eylemi tasiyorsa sayilir."""
    return y[-1] == "." and kosul[0] in y and EYLEM[kosul[1]].split()[0] in y


def kosum(sicaklik, tohum, en_buyuk):
    bel = kar = isa = sinir = 0
    yanitlar = []
    for i, x in enumerate(SIN):
        y, k, dur = uret(x["kosul"], GIRIS, sicaklik, tohum + i, en_buyuk)
        bel += len(y)
        kar += k
        isa += dogru(y, x["kosul"])
        sinir += dur == "sinir"
        yanitlar.append(tuple(y))
    n = len(SIN)
    return bel / n, kar / n, isa / n, sinir / n, yanitlar


print(f"{'en buyuk cikti':>15} {'belirtec':>9} {'karsilastirma':>14}"
      f" {'sinira takilan':>15} {'isabet':>7}")
for eb in (4, 6, 7, 8, 12):
    b, k, i, s, _ = kosum(0.0, TOHUM, eb)
    print(f"{eb:>15} {b:>9.2f} {k:>14.1f} {s:>15.4f} {i:>7.4f}")

print(f"\n{'cikti m':>8} {'karsilastirma':>14} {'ciktinin payi':>14}")
for m in (8, 32, 128, 512):
    k = m * GIRIS + m * (m + 1) // 2
    print(f"{m:>8} {k:>14} {m * (m + 1) // 2 / k:>14.4f}")
```

```
 en buyuk cikti  belirtec  karsilastirma  sinira takilan  isabet
              4      4.00          126.0          1.0000  0.0000
              6      5.79          187.7          0.4550  0.5450
              7      6.25          204.0          0.1900  0.8100
              8      6.43          211.1          0.0000  1.0000
             12      6.43          211.1          0.0000  1.0000

 cikti m  karsilastirma  ciktinin payi
       8            276         0.1304
      32           1488         0.3548
     128          12096         0.6825
     512         146688         0.8953
```

Üçlü buradan okunur. **Çıplak çağrı** en dar ayardır: en büyük çıktı 4 belirteç, yanıt başına 126
karşılaştırma, isabet **0,0000**. Ucuzdur ve hiçbir işe yaramaz, çünkü yanıtların tamamı sınıra
takılıp yarıda kesilmiştir. **Düzenek** sınırı yanıtın gerçek uzunluğuna açmaktır: 8 belirteçte
sınıra takılan kalmaz, isabet 1,0000 olur. **Bedel** 4,00'dan 6,43 belirtece, 126,0'dan 211,1
karşılaştırmaya çıkmaktır — yaklaşık 1,68 kat.

Ara satırlar sınırın nasıl bir başarısızlık ürettiğini gösteriyor. Altı belirteçte yanıtların
0,4550'si kesiliyor ve isabet 0,5450'de kalıyor; yedide oran 0,1900 ve isabet 0,8100. **Bu
başarısızlık sessizdir:** kesik yanıt hata döndürmez, düzgün bir cümlenin başlangıcı gibi görünür.
Sınıra takılma oranı, ölçülmesi gereken ayrı bir sayıdır.

Sekizden on ikiye çıkmak hiçbir şey değiştirmiyor: 6,43 ve 211,1 aynı kalıyor. En büyük çıktı
uzunluğu bir **tavan**dır, bir hedef değil; durdurma koşulu daha önce geldiğinde tavanın büyüklüğü
bedel doğurmaz. Bu, sınırın nasıl seçileceğini de söyler: tavanı dar tutmak tasarruf getirmez,
yalnız kesilme riski yaratır. Tasarruf edilecek yer istemin ve beklenen yanıtın uzunluğudur,
tavan değil.

İkinci tablo bedelin uzun çıktılarda nereye kaydığını veriyor. Giriş 30 belirteçte sabitken çıktı
8 belirteçse karşılaştırmanın yalnız 0,1304'ünü çıktı tutuyor; 512 belirteçte bu pay 0,8953'e
çıkıyor. **Uzun yanıtın bedeli istemin uzunluğuna değil, kendi uzunluğuna bağlıdır.**

## Seçim Kuralı ve Sıcaklık

Her adımda dağılımın en büyüğü alınabilir ya da dağılımdan örneklenebilir. Sıcaklık ikisi
arasındaki sürekli ayardır: küçük sıcaklık dağılımı sivriltir, büyük sıcaklık düzleştirir.
Sıfır sıcaklık örneklemenin sınır durumudur ve kura tümüyle ortadan kalkar. Aşağıdaki süpürme
aynı 200 talebi yedi ayarda ikişer koşumla çağırır; değişen tek şey seçim kuralıdır, model de
istem de her satırda aynıdır.

```python
print(f"{'sicaklik':>9} {'isabet 1':>9} {'isabet 2':>9} {'degisen':>8}"
      f" {'belirtec':>9} {'karsilastirma':>14}")
for sic in (0.0, 0.2, 0.5, 0.8, 1.0, 1.5, 2.0):
    b, k, i1, _, y1 = kosum(sic, TOHUM, 16)
    _, _, i2, _, y2 = kosum(sic, TOHUM + 1000, 16)
    d = sum(a != b2 for a, b2 in zip(y1, y2)) / len(y1)
    ad = "0,0" if sic == 0 else f"{sic:.1f}".replace(".", ",")
    print(f"{ad:>9} {i1:>9.4f} {i2:>9.4f} {d:>8.4f} {b:>9.2f} {k:>14.1f}")
```

```
 sicaklik  isabet 1  isabet 2  degisen  belirtec  karsilastirma
      0,0    1.0000    1.0000   0.0000      6.43          211.1
      0,2    0.9900    0.9900   0.5550      6.47          212.5
      0,5    0.9500    0.9400   0.6650      6.53          214.3
      0,8    0.8800    0.8750   0.7200      6.50          213.5
      1,0    0.7900    0.8200   0.7650      6.47          212.2
      1,5    0.6250    0.6700   0.8550      6.47          212.1
      2,0    0.5600    0.5600   0.8600      6.46          211.5
```

En olası seçim satırı bu müfredatın en sade belirsizlik ölçüsüdür: iki koşumda değişen yanıt oranı
**0,0000**. Model burada belirsiz değildir; belirsizlik seçim kuralından gelir, modelin kendisinden
değil.

İkinci satır asıl uyarıyı taşıyor. Sıcaklık 0,2'de isabet 0,9900 ile neredeyse bozulmamıştır, ama
iki koşumda yanıtların **0,5550'si değişir**. Aynı talebe iki ayrı zamanda iki ayrı cümle döner ve
ikisi de doğrudur. Bir ürün için bu sayı bağımsız bir tasarım verisidir: yanıtın metni bir yere
kaydediliyorsa, karşılaştırılıyorsa ya da bir sınamada beklenen çıktıyla eşleştiriliyorsa 0,5550
her koşumda kırılan bir sınamadır.

Sıcaklık büyüdükçe iki sütun ayrışır. İki koşumda değişme 0,8600'e doğru doyar, isabet ise
0,9900'den 0,5600'e düşer. **Düzeneğin bedeli burada isabetle ödenir ve karşılığında alınan şey
yalnız çeşitliliktir.** Belirteç ve karşılaştırma sütunları neredeyse sabittir: sıcaklığın bedeli
belirteç değil, doğruluktur.

Üç sıcaklığın üç ayrı işe yaradığı da tablodan okunur. Bir sınıflandırma ya da kod atama görevinde
0,0 doğru ayardır: tekrarlanabilir ve en yüksek isabetli. Bir yanıt metninde 0,2 ile 0,5 arası
isabeti çok az düşürüp metni tekdüzelikten çıkarır. 1,0'ın üstü ise ancak çeşitliliğin kendisi
ürünün amacıysa savunulabilir ve bu tabloda 0,2100'lük bir isabet kaybına mal olur.

Tablonun sessiz kalan bir sütunu daha var: yanlış yanıtın bedeli. Sıcaklık 1,0'da yanıtların
0,2100'ü yanlıştır ve bu yanlışlar rastgele dağıldığı için aynı istem tekrar çağrılarak
düzeltilebilir. Ama tekrar çağırmak bedava değildir — her yeniden deneme yeni bir 211,1
karşılaştırma ve 6,47 belirteçtir. Beş talepten birinin ikinci kez çağrıldığı bir düzenekte
ortalama bedel 1,21 çağrıya çıkar, ve bunun karşılığında elde edilen isabet 0,0 sıcaklığın zaten
1,0000 olan sayısının altındadır. **Belirsizliği önce açıp sonra yeniden denemeyle kapatmak, aynı
sayıya daha pahalı ulaşmanın yoludur.** Bu, müfredatın ikinci iddiasının bu dersteki biçimidir:
eklenen düzeneğin bedeli kesin, kazancı belirsizdir.

## Özet

- Çıkarım tek bir işlem değil, bir döngüdür: her adım bir dağılım kurar, bir belirteç seçer ve
  seçtiğini girdinin sonuna ekler. Talepler ve yanıt örnekleri kurgudur, tohum 20260218.
- Bedel iki birimle yazılır. En olası seçimde yanıt başına 6,43 belirteç ve 211,1 karşılaştırma;
  giriş 30 belirteçte sabitken çıktı 512 belirtece uzadığında karşılaştırmanın 0,8953'ünü çıktının
  kendisi tutar.
- En büyük çıktı uzunluğu sessiz bir başarısızlık kaynağıdır: 4 belirteçte bütün yanıtlar kesilir
  ve isabet 0,0000 olur, 6'da 0,5450, 7'de 0,8100, 8'de 1,0000.
- En olası seçim iki koşumda birebir aynı yanıtı verir (değişen oranı 0,0000). Belirsizlik
  modelden değil, seçim kuralından gelir.
- Sıcaklık 0,2'de isabet 0,9900 kalırken iki koşumda değişen yanıt oranı 0,5550'dir; 2,0'da isabet
  0,5600, değişen oranı 0,8600'dür. Belirteç bedeli bu süpürme boyunca neredeyse sabittir.

## Sonraki Adım

Yanıtın nasıl üretildiği ve seçim kuralının ne ödettiği sayıldı. Ama bütün bu ölçümlerde giriş 30
belirteçte sabit tutuldu. Gerçek bir düzenekte giriş sabit değildir: talep akışı uzar, belgeler
eklenir, önceki yanıtlar geri konur. Modelin bir de **penceresi** vardır ve o pencere sabittir.
Sonraki ders pencere aşıldığında ne olduğunu ölçer: baştan atmak, ortadan atmak ve özetlemek aynı
görevde kaç belirteç kazandırıyor ve isabeti ne kadar düşürüyor.
