Dönüştürücü Sezgisi

Bir önceki ders metni belirteçlere böldü ve her belirtecin bir bedeli olduğunu saydı. Elde bir dizi var, ama modelin bu diziyle ne yaptığı sorulmadı. Bir destek akışında konu ilk cümlede söylenir ve son cümlede yalnız “bu konu” diye anılır: aradaki elli belirteç boyunca bağ kopmadan taşınmalıdır.

Dönüştürücü mimarinin, dikkatin ve gömme katmanının yapısı derin öğrenme kursunun mimariler konusunda kurulmuş ve ölçülmüştü; mimari burada tekrarlanmaz. Bu ders tek bir soruyu kullanıcı tarafından ele alır: dikkat uzak bağlamı niçin kullanabiliyor, ve bunun bedeli nedir. Cevap tek bir yapısal ayrıntıda saklıdır — dikkatte bir konumun ağırlığı uzaklığına bağlı değildir — ve bedeli tek bir sayıda: karşılaştırma sayısı.

• DL9. Talep akışları kurgudur: ders içinde üretilir, tohum 20260218. Küme 240 akıştır; her akış bir konu cümlesi, iki ile dokuz arası dolgu cümlesi ve bir kapanış sorusudur.
• DL10. Belirteçleyici bir önceki dersinkiyle aynı yordamdır: parça sözlüğü ve soldan en uzun eşleşme.
• DL11. Görev tektir: akışın konu nesnesini bulmak. Doğru cevap ilk cümlede geçen nesnedir.
• DL12. Akışların bir bölümünde sona yakın ikinci bir nesne geçer. Bu ikinci nesne konu değildir; yakınlığa bakan her yordamı yanıltır.
• DL13. Uyum puanı benzeticide elle verilmiştir: nesne kökü 1,00, durum kökü 0,25, geri kalan 0,02. Gerçek bir modelde bu puan öğrenilir. Ölçülen şey puanın nereden geldiği değil, kaç konumun karşılaştırıldığıdır.
• DL14. Okuyucular yalnız kapsamda ayrılır: sabit pencere son k konuma bakar, sönümlemeli okuyucu her konuma bakar ama ağırlığı uzaklıkla çarpar, dikkat her konuma uzaklıktan bağımsız bakar.
• DL15. Ölçüt her satırda aynıdır: konu nesnesi isabeti (büyük iyi) ve karşılaştırma sayısı (küçük iyi).
• DL16. Karşılaştırma sayısı koşumdan bağımsızdır; sayılan bir büyüklüktür, ölçülen değil.

Bağ Uzaklığı

Akışlar tek bir değişkeni denetimli biçimde oynatır: konu nesnesinin dizinin sonuna uzaklığı.

# BENZETICI — model ders icinde standart kitaplikla yazilmis bir benzeticidir;
# gercek bir uc nokta cagrilmaz. Talep akislari KURGUDUR, tohum 20260218.
TOHUM, M32, AKIS = 20260218, 0xFFFFFFFF, 240

KOK = """sayac muhur vana hat fatura tarife endeks odeme abone adres ariza kod okuma
servis ekip ziyaret kayit talep destek bakim gun ay yil saat numara bilgi islem sistem
hata sonuc deger gecikme itiraz basvuru cevap bekle gonder geri ac kapa oku yaz bul bak
gel ver yap don iste calis bozuk kirik eksik normal yuksek dusuk yeni eski acik kapali
lutfen merhaba tesekkur iyi rica eder tekrar hala durum konu hafta ayni iki her sorun
ile icin ve bir bu ne var yok ama kadar sonra once ben biz siz""".split()
EK = """lari leri lar ler nin nun den dan de da te ta iniz unuz imiz umuz in un im um
si su li lu di du ti tu miz niz yor mis dir tir cek cak ki ya ye yi yu ma me ni nu
la le i u e a""".split()
PARCA = set(KOK) | set(EK) | set("abcdefghijklmnopqrstuvwxyz0123456789")


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):
    b, g = [], ""
    for c in metin.lower() + " ":
        if c.isalnum():
            g += c
            continue
        i = 0
        while i < len(g):
            for j in range(min(len(g), i + 9), i, -1):
                if g[i:j] in PARCA:
                    b.append(g[i:j])
                    i = j
                    break
            else:
                b.append(g[i])
                i += 1
        g = ""
        if c in ".,?":
            b.append(c)
    return b


NESNE = {"fatura": ("faturamizin", ["yuksek", "eksik"]),
         "tarife": ("tarifemizin", ["yuksek", "eski"]),
         "endeks": ("endeksimizin", ["yuksek", "dusuk"]),
         "sayac": ("sayacimizin", ["bozuk", "eski"]),
         "muhur": ("muhurumuzun", ["kirik", "eksik"]),
         "vana": ("vananin", ["kapali", "bozuk"]),
         "hat": ("hattimizin", ["kapali", "eski"]),
         "odeme": ("odememizin", ["eksik", "gecikmeli"])}
DOLGU = ["Bu konuda tekrar yazdim ama cevap yok.",
         "Hala bekledim ve bir sonuc yok.",
         "Bu ay da bir talep actim.",
         "Servis ekip geldi ama bir islem yapmadi.",
         "Kayit numarasi ile bir sonuc yok.",
         "Sistemden basvuru yaptim ama cevap gelmedi.",
         "Iki gun once tekrar yazdim.",
         "Her hafta ayni durum icin bilgi istedim."]
NESNE_AD = list(NESNE)

VERI = []
for i in range(AKIS):
    r = uretec(TOHUM + i)
    n = NESNE_AD[int(r() * 8)]
    uzun_ad, durumlar = NESNE[n]
    satir = [f"Merhaba, {uzun_ad} durumu {durumlar[int(r() * 2)]}."]
    j = int(r() * 8)
    for _ in range(2 + int(r() * 8)):
        satir.append(DOLGU[j % 8])
        j += 3
    dagitici = None
    if r() < 0.35:
        dagitici = NESNE_AD[(NESNE_AD.index(n) + 1 + int(r() * 7)) % 8]
        satir.append(f"{dagitici.capitalize()} icin de bir kayit var.")
    satir.append("Bu konu ne durumda?")
    dizi = belirtecle(" ".join(satir))
    VERI.append({"dizi": dizi, "nesne": n, "dagitici": dagitici,
                 "uzaklik": len(dizi) - 1 - dizi.index(n)})

uz = [x["uzaklik"] for x in VERI]
print(f"{AKIS} kurgu talep akisi; {sum(x['dagitici'] is not None for x in VERI)}"
      f" akista ikinci bir nesne geciyor")
print(f"akis uzunlugu {min(len(x['dizi']) for x in VERI)}"
      f"-{max(len(x['dizi']) for x in VERI)} belirtec, ortalama"
      f" {sum(len(x['dizi']) for x in VERI) / AKIS:.1f}")
print(f"konu nesnesinin sondan uzakligi {min(uz)}-{max(uz)}, ortalama {sum(uz) / AKIS:.1f}")
print("\n" + " ".join(VERI[3]["dizi"]))

240 kurgu talep akisi; 83 akista ikinci bir nesne geciyor
akis uzunlugu 31-111 belirtec, ortalama 69.7
konu nesnesinin sondan uzakligi 28-108, ortalama 66.7

merhaba , endeks imiz in durum u dusuk . iki gun once tekrar yaz di m . hala bekle di m ve bir sonuc yok . kayit numara si ile bir sonuc yok . bu konu ne durum da ?

Kapanış sorusu her akışta aynıdır ve tek başına hiçbir bilgi taşımaz: cevap ortalama 66,7 belirteç geride durur. Sekiz akıştan yaklaşık üçünde sona yakın ikinci bir nesne geçer ve yakınlığa bakan her yordam için bir tuzaktır.

Bu kurgu bir alıştırma değil, sıradan bir üretim durumudur. Bir destek akışını doğru ekibe yönlendirmek için konu nesnesi gerekir ve akıştaki en yeni cümle onu neredeyse hiç taşımaz. Aklın ilk yolu en ucuz olandır: son birkaç cümleye bak, gerisini at. Aşağıdaki tablo o yolun sayısını verir ve dikkatin hangi sorunu çözdüğü ancak o sayıya karşı okunduğunda görülür.

Uzaklığa Bakan ve Bakmayan Okuyucu

Üç okuyucu aynı uyum puanını kullanır, yalnız hangi konumları karşılaştırdıklarında ayrılır. Sabit pencere son k konuma bakar; sönümlemeli okuyucu her konuma bakar ama ağırlığı her belirteçte 0,94 ile çarpar; dikkat her konuma uzaklıktan bağımsız bakar.

NESNE_KUME = set(NESNE_AD)
DURUM_KUME = {d for _, ds in NESNE.values() for d in ds} | {"gecikme"}


def uyum(t):
    """Sorgunun konumla uyumu. Gercek bir modelde ogrenilir; burada elle verilir."""
    return 1.0 if t in NESNE_KUME else (0.25 if t in DURUM_KUME else 0.02)


def oku(dizi, pencere=None, sonum=1.0):
    n = len(dizi)
    bas = 0 if pencere is None else max(0, n - pencere)
    en_iyi, en_p = None, -1.0
    for i in range(bas, n):
        p = uyum(dizi[i]) * (sonum ** (n - 1 - i))
        if p > en_p:
            en_p, en_iyi = p, dizi[i]
    return (en_iyi if en_iyi in NESNE_KUME else None), n - bas


KOVA = [(0, 32), (33, 64), (65, 999)]


def olc(ad, **k):
    dogru, toplam, karsi = [0, 0, 0], [0, 0, 0], 0
    for x in VERI:
        c, m = oku(x["dizi"], **k)
        karsi += m
        j = next(i for i, (a, b) in enumerate(KOVA) if a <= x["uzaklik"] <= b)
        toplam[j] += 1
        dogru[j] += c == x["nesne"]
    print(f"{ad:<26} {karsi / AKIS:>8.1f} {sum(dogru) / AKIS:>7.4f} "
          + " ".join(f"{d / t:>7.4f}" for d, t in zip(dogru, toplam)))


print(f"{'okuyucu':<26} {'karsi':>8} {'isabet':>7} "
      + " ".join(f"{a}-{b:<3}".rjust(7) for a, b in KOVA))
for k in (8, 16, 32, 64):
    olc(f"son {k} belirtec", pencere=k)
olc("uzaklikla sonumleme", sonum=0.94)
olc("tam dikkat")
print("kova basina akis" + "".join(
    f"{sum(1 for x in VERI if a <= x['uzaklik'] <= b):>8}" for a, b in KOVA).rjust(44))
y = [oku(x["dizi"], pencere=16)[0] for x in VERI]
print(f"son 16 belirtec: {sum(c == VERI[i]['nesne'] for i, c in enumerate(y))} dogru,"
      f" {sum(c is not None and c != VERI[i]['nesne'] for i, c in enumerate(y))} yanlis nesne,"
      f" {sum(c is None for c in y)} bos yanit")

okuyucu                       karsi  isabet   0-32   33-64   65-999
son 8 belirtec                  8.0  0.0000  0.0000  0.0000  0.0000
son 16 belirtec                16.0  0.0000  0.0000  0.0000  0.0000
son 32 belirtec                32.0  0.0458  0.9167  0.0000  0.0000
son 64 belirtec                56.8  0.4917  1.0000  0.9907  0.0000
uzaklikla sonumleme            69.7  0.3250  1.0000  0.6168  0.0000
tam dikkat                     69.7  1.0000  1.0000  1.0000  1.0000
kova basina akis                          12     107     121
son 16 belirtec: 0 dogru, 83 yanlis nesne, 157 bos yanit

Üçlü buradan okunur. Çıplak çağrı en ucuz okumadır: son 16 belirteç, akış başına 16 karşılaştırma, isabet 0,0000. Son satır bu sıfırın içini açıyor — 83 akışta pencereye giren ikinci nesne yanlış cevap olarak dönüyor, 157 akışta pencerede hiçbir nesne bulunmadığı için boş yanıt veriliyor. Ucuz okumanın iki ayrı başarısızlık biçimi vardır ve biri sessizdir, öteki değildir.

Pencere büyüdükçe isabet basamak basamak yükselir ama hep aynı yerde kesilir: son 32 belirteç 0-32 kovasında 0,9167 verir, ötesinde tam sıfır; son 64 belirteç 33-64 kovasında 0,9907’ye çıkar, 65 belirtecin ötesinde yine sıfır. Pencere, gördüğü yerde iyi, görmediği yerde hiçtir.

Sönümlemeli okuyucu daha ilginç bir başarısızlıktır. Her konuma bakar, yani kapsamı tamdır, ama 0,3250’de kalır. Uzaklık cezası 0,94 üzeri altmış, yani yaklaşık 0,024’e iner ve uzaktaki nesnenin 1,00’lık uyumu, yakındaki bir durum kökünün 0,25’inin altına düşer. Kapsam yetmez; ağırlığın uzaklıktan bağımsız olması gerekir. Dikkatin yaptığı tam olarak budur ve 1,0000 isabet buradan gelir.

Bedelin Büyüme Hızı

Uzaklıktan bağımsız ağırlık bedava değildir. Tek bir sorgu için okuma n karşılaştırma tutar; ama model bunu her konum için yapar. Nedensel bir geçişte i. konum kendinden önceki i konumu karşılaştırır ve toplam n(n+1)/2 olur.

print(f"{'baglam n':>9} {'tam dikkat':>12} {'pencere 64':>12} {'oran':>7} {'buyume':>7}")
onceki = None
for n in (64, 128, 256, 512, 1024):
    tam, pen = n * (n + 1) // 2, n * 64 - 64 * 63 // 2
    b = "-" if onceki is None else f"{tam / onceki:.2f}"
    print(f"{n:>9} {tam:>12} {pen:>12} {tam / pen:>7.2f} {b:>7}")
    onceki = tam


def ornekle(dizi, tohum):
    r = uretec(tohum + len(dizi))
    a = [uyum(t) for t in dizi]
    u, s = r() * sum(a), 0.0
    for t, w in zip(dizi, a):
        s += w
        if u < s:
            return t if t in NESNE_KUME else None
    return None


print(f"\nen olasi secim   isabet {sum(oku(x['dizi'])[0] == x['nesne'] for x in VERI) / AKIS:.4f}"
      "   (iki kosumda ayni)")
for t in (TOHUM, TOHUM + 1):
    d = sum(ornekle(x["dizi"], t) == x["nesne"] for x in VERI) / AKIS
    print(f"ornekleme tohum {t}   isabet {d:.4f}")

 baglam n   tam dikkat   pencere 64    oran  buyume
       64         2080         2080    1.00       -
      128         8256         6176    1.34    3.97
      256        32896        14368    2.29    3.98
      512       131328        30752    4.27    3.99
     1024       524800        63520    8.26    4.00

en olasi secim   isabet 1.0000   (iki kosumda ayni)
ornekleme tohum 20260218   isabet 0.3708
ornekleme tohum 20260219   isabet 0.3250

Büyüme sütunu tek cümlelik bir kuraldır: bağlam iki katına çıkınca karşılaştırma dört katına çıkar. Sabit pencere ise doğrusal büyür ve aradaki oran 1024 belirteçte 8,26’ya varır. Bir sonraki dersin bağlam penceresi tartışması, ve bu müfredatın bütün maliyet hesabı, bu iki eğrinin arasında geçer: sınırın niçin bir sayı olduğu ve niçin cömertçe büyütülmediği buradan görülür.

Bu tablonun kullanıcı tarafındaki karşılığı şudur: bağlama eklenen her belirteç, sonrakilerin hepsiyle karşılaştırılacağı için doğrusaldan hızlı bir bedel yazar. İsteme “her ihtimale karşı” eklenen bir belge, bedelini yalnız kendi uzunluğuyla ödemez. Gecikme de aynı eğriyi izler ve bu müfredatta sınıf olarak anılır: tek çağrı, zincir, paralel. Uzun bağlamlı tek bir çağrı, kısa bağlamlı iki çağrıdan pahalı olabilir ve hangisinin seçileceği ölçülmeden bilinmez.

Bu ders dikkatin ne olduğunu değil, ne satın aldığını ölçtü. Dikkat modelin bildiği şeyi açıklamaz; yalnız dizideki hangi konumların birbirine bağlanabildiğini belirler. Uyum puanlarının nereden geldiği hâlâ boşluktadır.

Son üç satır bu dersin belirsizlik ölçüsüdür. Karşılaştırma sayısı sayılan bir büyüklüktür ve koşumdan bağımsızdır; okuma kararı değildir. Ağırlıkların en büyüğü alındığında isabet iki koşumda da 1,0000’dır. Aynı ağırlıklardan örneklemeyle seçildiğinde aynı girdi 0,3708 ve 0,3250 verir: iki koşum, iki sayı, aynı düzenek. Seçim kuralının kendisi bir tasarım kararıdır ve sonraki ders onu ölçer.

Özet

• Dikkatin ayırt edici özelliği kapsam değil, ağırlığın uzaklıktan bağımsız olmasıdır. Kapsamı tam ama uzaklıkla sönümlenen okuyucu 0,3250’de kalırken dikkat 1,0000 verir.
• Sabit pencereli okuma gördüğü yerde iyi, görmediği yerde hiçtir: son 32 belirteç yakın kovada 0,9167, ötesinde 0,0000; son 64 belirteç 0,4917 genel isabet verir.
• Ucuz okumanın iki başarısızlık biçimi vardır: 83 akışta yakındaki ikinci nesne yanlış cevap olarak döner, 157 akışta boş yanıt gelir.
• Bedel karşılaştırma sayısıdır ve karesel büyür: bağlam iki katına çıkınca karşılaştırma dört katına çıkar, 1024 belirteçte sabit pencerenin 8,26 katıdır.
• Aynı ağırlıklardan en olası seçim iki koşumda da 1,0000 verir, örnekleme 0,3708 ve 0,3250 verir.

Sonraki Adım

Model uzak bağlamı kullanabiliyor ve bunun bedeli sayıldı. Ama bu yetenek nereden geldi: uyum puanları bu derste elle yazıldı, gerçek bir modelde öğrenilir. Öğrenmenin iki ayrı aşaması vardır ve ikisi ayrı sorunları çözer. Sonraki ders bir görev kümesini ikiye ayırır ve her birinin kaç örnekle düzeldiğini sayar: hangi soru geniş metin yığınından, hangisi alanın kendi örneklerinden cevaplanıyor.