Geri Adım İstemi

Önceki üç ders modelden hep aynı şeyi istedi: daha çok adım. Adımlar tek yanıtın içine yazdırıldı, çoğaltılıp oylandı, dallandırılıp ayıklandı — ve üçünde de aynı yöne, talebin ayrıntısına doğru baktılar. Ağaç dersinde hata tam oradan geldi: yanıltıcı bir sözcük ilk adımı bozdu ve hiçbir adım “bu talepte neye bakmam gerekiyordu” diye sormadı.

Geri adım istemi ters yöne gider. Çözümü istemeden önce soyutlama düzeyini yükseltir: bu tür talepler hangi genel kurala göre çözülür. İstem yine metindir, ama bu kez iki aşamalıdır ve birincinin çıktısı ikincinin girdisine yazılır. Bedeli peşin bellidir — çağrı sayısı ikiye katlanır. Ölçülecek olan bunun karşılığında ne alındığıdır.

• AY28. Görev ve kurgu bir önceki derstekiyle aynıdır: 48 kurgu destek talebi, üç bileşenli arıza kodu, toplam otuz iki kod. Çağrılan şey bir benzeticidir; gerçek bir model uç noktasına hiçbir istek gitmez. Tohum 20260218, ikinci koşum 20260219.
• AY29. Kurgu ilke dağarcığı dört genel kuraldır. Bir ilke istemin başına yazıldığında benzeticinin hangi ize ne kadar ağırlık verdiği değişir; bu kurgu düzenek, gerçek bir yönergenin yaptığı şeyin ölçülebilir karşılığıdır — yönerge kanıt seçer.
• AY30. Bu kurguda doğru ilke gozlemdir: kod, talebin bildirdiği belirtiye ve yere göre seçilir, kaydın açıldığı kanala göre değil. Öbür üç ilke yanlıştır.
• AY31. İki aşama iki çağrıdır. Birinci aşamanın yanıtı ikinci istemin başına aynen yazılır; arada düzeltme, doğrulama ya da geri dönüş yoktur.
• AY32. Seçenekler isteme bileşen listeleri olarak yazılır; otuz iki kodun tek tek yazılması ilkeye yer bırakmaz.
• AY33. Bedel dört birimle yazılır: çağrı sayısı, giriş belirteci, çıkış belirteci ve başarısız çağrı. Ölçüt kod görevinde üç bileşenin birden, derece görevinde derecenin doğru olmasıdır.

Önce İlke, Sonra Çözüm

Önceki istem tektir: yönerge, seçenekler ve talep bir arada gider. Değiştirilmiş istem ikiye ayrılır. Birinci çağrı yalnız hangi genel kuralın geçerli olduğunu sorar; talebi görür ama kod seçeneklerini görmez. İkinci çağrı dönen kuralın metnini başına alıp asıl işi ister. İlk blok benzeticiyi, ilke dağarcığını ve bir talep üzerinde iki aşamayı kurar.

# BENZETICI. Bu kod gercek bir model uc noktasi cagirmaz; standart kitaplikla yazilmis
# bir dil modeli benzeticisidir. Destek talepleri ve ariza kodlari da KURGU'dur.
import math

TOHUM, M32 = 20260218, 0xFFFFFFFF
PENCERE = 240                       # baglam penceresi, belirtec


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 ayrik(u, w):
    t = 0.0
    for i, x in enumerate(w):
        t += x
        if u < t:
            return i
    return len(w) - 1


def belirtecle(m):                  # KURGU belirtecleyici: parca en cok bes damga
    b = []
    for s in m.lower().replace(",", " , ").split():
        while len(s) > 5:
            b.append(s[:5])
            s = s[5:]
        b.append(s)
    return b


def izno(m):                        # istemin icerigine bagli, kosumdan bagimsiz iz
    h = 2166136261
    for c in m:
        h = ((h ^ ord(c)) * 16777619) & M32
    return h


ALAN = ["dagitim", "sayac", "abonelik", "saha"]
BELIRTI = {"dagitim": ["kesinti", "basinc", "sizinti", "tikanma"],
           "sayac": ["endeks", "bozukluk", "degisim", "okuma"],
           "abonelik": ["tarife", "fatura", "odeme", "kayit"],
           "saha": ["randevu", "erisim", "malzeme", "gecikme"]}
DERECE = ["birinci", "ikinci"]
A_SOZ = {"dagitim": "sebeke", "sayac": "olcum", "abonelik": "sozlesme", "saha": "ekip"}
T_SOZ = {"dagitim": "hatti", "sayac": "cihaz", "abonelik": "hesap", "saha": "servis"}
B_SOZ = {"kesinti": "akmiyor", "basinc": "zayif", "sizinti": "islak", "tikanma": "dolmus",
         "endeks": "rakam", "bozukluk": "calismiyor", "degisim": "yenisi", "okuma": "girilmemis",
         "tarife": "basamak", "fatura": "tutar", "odeme": "borcum", "kayit": "musteri",
         "randevu": "saatte", "erisim": "kapali", "malzeme": "parca", "gecikme": "bekliyor"}
D_SOZ = {"birinci": "acil", "ikinci": "normal"}
A_IZ = {A_SOZ[a][:5]: a for a in ALAN}                 # yer izi, zayif
T_IZ = {T_SOZ[a][:5]: a for a in ALAN}                 # kanal izi, daha agir
B_IZ = {B_SOZ[b][:5]: b for a in ALAN for b in BELIRTI[a]}
D_IZ = {D_SOZ[d][:5]: d for d in DERECE}
I_IZ = {"sorun": "gozlem", "ilgil": "gozlem", "durum": "gozlem", "diye": "gozlem",
        "taraf": "gozlem", "yaziy": "gozlem", "kayit": "kanal", "uzeri": "kanal",
        "acilm": "sira", "bildi": "sira", "gerek": "sure", "deger": "sure"}
ILKE = {"gozlem": "ilke gozlem : kod , talebin bildirdigi belirtiye ve yere gore secilir .",
        "kanal": "ilke kanal : kod , kaydin acildigi kanala gore secilir .",
        "sure": "ilke sure : kod , bildirimin aciliyet duzeyine gore secilir .",
        "sira": "ilke sira : kod , talebin geldigi siraya gore secilir ."}
KURAL = {"gozle": {"A": 2.4, "T": 0.2, "B": 2.8},      # anahtar : ilke adinin ilk parcasi
         "kanal": {"A": 0.3, "T": 2.6}, "sure": {"B": 0.6}, "sira": {"A": 0.4, "B": 0.5}}

TALEP = []
for i in range(48):
    r = uretec(TOHUM + i)
    a = ALAN[int(r() * 4)]
    b = BELIRTI[a][int(r() * 4)]
    d = DERECE[int(r() * 2)]
    y = ALAN[(ALAN.index(a) + 1 + int(r() * 3)) % 4]    # talepte gecen kanal, yaniltici
    if r() < 0.5:
        m = (f"{T_SOZ[y]} icin kayit acilmisti ama sorun {A_SOZ[a]} tarafinda , "
             f"{B_SOZ[b]} durumu var , {D_SOZ[d]} bakilmasi gerekiyor")
    else:
        m = (f"{T_SOZ[y]} uzerinden bildirdim , {A_SOZ[a]} ile ilgili "
             f"{B_SOZ[b]} diye yaziyor , {D_SOZ[d]} olarak degerlendirin")
    TALEP.append({"no": 5001 + i, "metin": m, "kod": (a, b, d)})

TUM = [(a, b, d) for a in ALAN for b in BELIRTI[a] for d in DERECE]
SAYAC = [0, 0, 0, 0]                # cagri, giris belirteci, cikis belirteci, basarisiz


def yaz(y):
    return " ".join(y)


def cagir(istem, secenek, tohum=TOHUM, sicaklik=0.6):
    SAYAC[0] += 1
    bel = belirtecle(istem)
    SAYAC[1] += len(bel)
    if len(bel) > PENCERE or SAYAC[0] % 37 == 0:
        SAYAC[3] += 1
        return {"giris": len(bel), "yanit": None}
    ag = {"A": 1.0, "T": 1.3, "B": 1.6, "D": 0.9}
    for t in bel:
        ag.update(KURAL.get(t, {}))            # istemdeki ilke, iz agirliklarini degistirir
    r = uretec(tohum ^ izno(istem))
    p = {k: 0.15 for k in secenek}
    for t in bel:
        for tablo, w in ((A_IZ, ag["A"]), (T_IZ, ag["T"]), (B_IZ, ag["B"]),
                         (D_IZ, ag["D"]), (I_IZ, 1.0)):
            h = tablo.get(t)
            if h is not None:
                for k in p:
                    if h in k:
                        p[k] += w
    d = sorted(p, key=yaz)
    if sicaklik <= 0.0:
        k = max(d, key=lambda a: p[a])
    else:
        e = [math.exp(p[a] / sicaklik) for a in d]
        k = d[ayrik(r(), [v / sum(e) for v in e])]
    SAYAC[2] += len(belirtecle(yaz(k)))
    return {"giris": len(bel), "yanit": k}


KOD_ISTEM = ("Talebe bir ariza kodu ata . alanlar : " + " , ".join(ALAN)
             + " . belirtiler : " + " , ".join(b for a in ALAN for b in BELIRTI[a])
             + " . dereceler : " + " , ".join(DERECE) + " . Talep : ")
ILKE_ISTEM = ("Cozmeden once bu talebin hangi genel kurala girdigini yaz . kurallar : "
              + " , ".join(sorted(ILKE)) + " . Talep : ")

x = TALEP[2]
print(f"KURGU: {len(TALEP)} talep, {len(TUM)} ariza kodu, {len(ILKE)} genel kural")
print(f"talep {x['no']}: {x['metin']}")
print(f"dogru kod: {yaz(x['kod'])}")
t1 = cagir(KOD_ISTEM + x["metin"], TUM)
print(f"tek asamali: giris {t1['giris']} belirtec, yanit '{yaz(t1['yanit'])}'")
i1 = cagir(ILKE_ISTEM + x["metin"], [(k,) for k in sorted(ILKE)])
print(f"\nbirinci asama: giris {i1['giris']} belirtec, ilke '{yaz(i1['yanit'])}'")
for ad in ("gozlem", "kanal"):
    t2 = cagir(ILKE[ad] + " " + KOD_ISTEM + x["metin"], TUM)
    print(f"ikinci asama ilke {ad}: giris {t2['giris']} belirtec, yanit '{yaz(t2['yanit'])}'")
u = cagir(ILKE["gozlem"] + " Talebe bir ariza kodu ata . secenekler : "
          + " , ".join(yaz(k) for k in TUM) + " . Talep : " + x["metin"], TUM)
print(f"\notuz iki kod tek tek yazilsaydi: giris {u['giris']} belirtec (sinir {PENCERE}) , "
      f"yanit {u['yanit']}")

KURGU: 48 talep, 32 ariza kodu, 4 genel kural
talep 5003: hesap uzerinden bildirdim , olcum ile ilgili rakam diye yaziyor , acil olarak degerlendirin
dogru kod: sayac endeks birinci
tek asamali: giris 100 belirtec, yanit 'abonelik fatura birinci'

birinci asama: giris 49 belirtec, ilke 'gozlem'
ikinci asama ilke gozlem: giris 118 belirtec, yanit 'sayac endeks ikinci'
ikinci asama ilke kanal: giris 115 belirtec, yanit 'abonelik odeme birinci'

otuz iki kod tek tek yazilsaydi: giris 253 belirtec (sinir 240) , yanit None

Tek aşamalı istem abonelik fatura birinci diyor: talepte geçen “hesap” kaydın açıldığı kanaldır ve izi ağırdır, asıl kanıt olan “olcum” onun altında kaldı. Birinci aşama 49 belirteç harcayıp gozlem kuralını buluyor; kural ikinci istemin başına yazıldığında yanıt sayac endeks ikinci oluyor — alan ve belirti düzeldi, derece hâlâ yanlış. Kural derece hakkında bir şey söylemiyor, kalan hata da tam orada.

Üçüncü satır bedelin öbür yüzüdür. Yanlış ilke — kanal — ikinci istemin başına yazıldığında yanıt abonelik odeme birinci oluyor; tek aşamalıdan daha kötü. İkinci aşama kendi başına bir düzeltme yapmıyor, önüne konan kurala uyuyor. Son satır bir tasarım kısıtıdır: bir önceki dersin istemi otuz iki kodu tek tek yazıyordu ve başına ilke eklendiğinde giriş 253 belirtece çıkıp 240 sınırını aşıyor, çağrı hiç yanıt üretmeden dönüyor. Geri adım istemi için pencerede yer açılmış olması gerekir; seçenekler bu yüzden bileşen listesi olarak yazıldı.

İki Aşamanın Kattığı ve Aldığı

İkinci blok iki görevi ölçer: üç bileşenli kod, ve yalnız derece — talepte harfi harfine yazılı olan tek bileşen. Her görev tek aşamalı ve geri adımlı, her düzen iki koşumda koşturulur. Sonda kazancın kaynağı ayrılır: birinci aşama kaç talepte doğru ilkeyi buldu, ve her ilke tek tek dayatıldığında ikinci aşama ne veriyor.

DER_ISTEM = "Talebin derecesini yaz . dereceler : " + " , ".join(DERECE) + " . Talep : "
ILKE_SEC = [(k,) for k in sorted(ILKE)]
KOD, DER = lambda x: x["kod"], lambda x: (x["kod"][2],)


def tek(istem, secenek):
    return lambda x, t: (cagir(istem + x["metin"], secenek, t)["yanit"], None)


def geri(istem, secenek):                        # once ilke , sonra cozum
    def f(x, t):
        i = cagir(ILKE_ISTEM + x["metin"], ILKE_SEC, t)
        ad = i["yanit"][0] if i["yanit"] else "sira"
        return cagir(ILKE[ad] + " " + istem + x["metin"], secenek, t)["yanit"], ad
    return f


def olc(f, hedef, tohum=TOHUM):
    SAYAC[:] = [0, 0, 0, 0]
    d = ni = di = yi = 0
    for x in TALEP:
        y, ad = f(x, tohum)
        v = y == hedef(x)
        d += v
        if ad is not None:
            ni += ad == "gozlem"
            di += v and ad == "gozlem"
            yi += v and ad != "gozlem"
    n = len(TALEP)
    return {"isabet": d / n, "nd": ni, "di": di / ni if ni else 0.0,
            "yi": yi / (n - ni) if ni < n else 0.0, "cagri": SAYAC[0],
            "giris": SAYAC[1], "cikis": SAYAC[2], "hata": SAYAC[3]}


SIRA = [("kod tek asamali", tek(KOD_ISTEM, TUM), KOD),
        ("kod geri adim", geri(KOD_ISTEM, TUM), KOD),
        ("derece tek asamali", tek(DER_ISTEM, [(d,) for d in DERECE]), DER),
        ("derece geri adim", geri(DER_ISTEM, [(d,) for d in DERECE]), DER)]

print(f"{'istem duzeni':<20}{'isabet':>8}{'kosum2':>8}{'fark':>8}{'cagri':>7}"
      f"{'giris':>8}{'cikis':>7}{'basarisiz':>10}")
S = {}
for ad, f, h in SIRA:
    A, B = olc(f, h), olc(f, h, TOHUM + 1)
    S[ad] = A
    print(f"{ad:<20}{A['isabet']:>8.4f}{B['isabet']:>8.4f}"
          f"{B['isabet'] - A['isabet']:>+8.4f}{A['cagri']:>7d}{A['giris']:>8d}"
          f"{A['cikis']:>7d}{A['hata']:>10d}")
for ad in ("kod", "derece"):
    a, b = S[ad + " tek asamali"], S[ad + " geri adim"]
    ta, tb = a["giris"] + a["cikis"], b["giris"] + b["cikis"]
    print(f"\n{ad} gorevinin bedeli: cagri {a['cagri']} -> {b['cagri']} , "
          f"belirtec {ta} -> {tb} ({tb / ta:.2f} kat)")
K = S["kod geri adim"]
print(f"ilke asamasi: dogru ilke {K['nd']}/{len(TALEP)} , dogru ilkede kod isabeti "
      f"{K['di']:.4f} , yanlis ilkede {K['yi']:.4f} ({len(TALEP) - K['nd']} talep)")
print("ilke dayatildiginda kod isabeti:", end="")
for ad in sorted(ILKE):
    A = olc(lambda x, t, a=ad: (cagir(ILKE[a] + " " + KOD_ISTEM + x["metin"],
                                      TUM, t)["yanit"], None), KOD)
    print(f" {ad} {A['isabet']:.4f}", end="")
print()

istem duzeni          isabet  kosum2    fark  cagri   giris  cikis basarisiz
kod tek asamali       0.5417  0.4792 -0.0625     48    4889    249         1
kod geri adim         0.7500  0.6458 -0.1042     96    8185    339         2
derece tek asamali    0.7708  0.7500 -0.0208     48    1913     94         1
derece geri adim      0.7708  0.7917 +0.0208     96    5209    186         2

kod gorevinin bedeli: cagri 48 -> 96 , belirtec 5138 -> 8524 (1.66 kat)

derece gorevinin bedeli: cagri 48 -> 96 , belirtec 2007 -> 5395 (2.69 kat)
ilke asamasi: dogru ilke 45/48 , dogru ilkede kod isabeti 0.8000 , yanlis ilkede 0.0000 (3 talep)
ilke dayatildiginda kod isabeti: gozlem 0.7708 kanal 0.0000 sira 0.0625 sure 0.1458

Kod görevinde iki aşamalı istem 0,5417’den 0,7500’e çıkıyor, ikinci koşumda 0,4792’den 0,6458’e. Kazanç iki koşumda +0,2083 ve +0,1667; düzenlerin kendi iki koşum farkları 0,0625 ve 0,1042. Kazanç ikisinden de büyük olduğu için bu fark ölçülmüş sayılır — bu konudaki tekniklerin hepsi bu sınavı geçmiyor. Bedel de kesindir: çağrı 48’den 96’ya, giriş belirteci 4889’dan 8185’e, toplam belirteç 1,66 kat, doğru kod başına bedel 198’den 237 belirtece. Teknik hem işe yaradı hem pahalılaştı.

Son iki satır kazancın kaynağını ve tekniğin asıl riskini söylüyor. Birinci aşama 48 talebin 45’inde doğru kuralı buldu ve o 45 talepte kod isabeti 0,8000. Yanlış kural seçilen üç talebin üçünde de kod yanlış çıktı — küçük bir sayı, ama son satır bunu tek başına kanıtlıyor. Dört kural sırayla dayatıldığında ikinci aşama gozlem ile 0,7708, sure ile 0,1458, sira ile 0,0625 ve kanal ile 0,0000 veriyor; üçü de tek aşamalının 0,5417’sinin altında. Geri adım istemi modele akıl yürütme eklemiyor, isteme yanlış olabilecek yeni bir yer ekliyor.

Alt iki satır tekniğin sınırıdır. Derece görevinde tek aşamalı istem 0,7708 ve 0,7500, geri adımlı istem 0,7708 ve 0,7917 veriyor; fark bir koşumda 0,0000, öbüründe +0,0417 ve ikisi de düzenlerin kendi koşum farkları mertebesinde. Ölçülmemiş sayılır. Buna karşılık çağrı yine ikiye katlanıyor, belirteç 2,69 kata çıkıyor — kod görevindekinden kötü bir oran, çünkü asıl istem kısaldıkça ilke metninin payı büyüyor. Derece talepte harfi harfine yazılıdır; çözüm yanlış soyutlama düzeyinde takılmıyor. Geri adım istemi, hatanın kaynağı kanıt seçimi olduğunda kazandırır; kanıt zaten doğru seçiliyorsa yalnız iki kat çağrıdır.

Özet

• Geri adım istemi istemi ikiye böler: birinci çağrı talebin girdiği genel kuralı sorar, ikinci çağrı o kuralı başına yazıp çözümü ister. Arada düzeltme yoktur.
• Kod görevinde isabet 0,5417’den 0,7500’e çıkıyor (ikinci koşumda 0,4792’den 0,6458’e) ve kazanç düzenlerin iki koşum farklarından büyük olduğu için ölçülmüş sayılır.
• Bedel kesindir: çağrı 48’den 96’ya, toplam belirteç 1,66 kat, doğru kod başına bedel 198’den 237 belirtece.
• Kazanç birinci aşamaya bağlıdır: doğru kural 45 talepte bulundu ve orada isabet 0,8000. Kurallar tek tek dayatıldığında ikinci aşama 0,7708 ile 0,0000 arasında değişiyor; üç yanlış kural da tek aşamalının altında.
• Yalnız derece soran görevde fark 0,0000 ile +0,0417 arasında kalıp ölçülemiyor, belirteç ise 2,69 kata çıkıyor. Harfi harfine yazılı bir bileşen için soyutlama düzeyini yükseltmenin karşılığı yoktur.

Sonraki Adım

Dört ders dört ayrı istem düzeni kurdu ve dördü de aynı yerden kazanmaya çalıştı: modelin kendi içinde daha çok adım atması. Hepsinde adımların tamamı benzeticinin içinde geçti; dışarıdan gelen tek şey talebin metniydi ve o metin ilk çağrıda zaten elde vardı.

Bu derste bunun sınırı göründü. Doğru kuralın ne olduğu talebin içinde yazılı değildi; birinci aşama onu benzeticinin kendi eğiliminden çıkardı ve üç talepte yanıldı. Kuralın dışarıdan okunabildiği bir durum — kurgu belge dağarcığına bakmak, bir kaydı sorgulamak — hiç ele alınmadı. Adımlardan birinin dışarıya bakmak olduğu istem düzeni sonraki dersin konusudur: düşünce ile eylemin aynı istemde istenmesi ve bunun kaç yanıtta geçerli bir eylem ürettiği.