Düşünce Ağacı

Bir önceki ders aynı istemi birden çok kez koşturup yanıtları oyladı. Öz tutarlılık işe yaradı: tek yanıtın yakaladığı sayı, dokuz örneğin uzlaşmasıyla yukarı çıktı. Ama üretilen çözümlerin ortak bir yanı vardı. Her biri baştan sona birbirinden bağımsız üretildi; hiçbiri ötekinin neresinde yanıldığını görmedi. Bir çözümün ilk adımı sabit tutulup ikinci adımı birkaç ayrı yönde denenmedi, kötü giden bir yol yarıda bırakılmadı.

Bu ders o boşluğu doldurur. Değiştirilen şey yine metindir, ama bu kez tek bir istem değil istemlerin düzenidir: uzun tek bir istem yerine, her biri çözümü bir adım ilerleten kısa istemler ve tutulacak dalları seçen bir kural. Ölçülecek olan bunun ne kazandırdığı ve kaç çağrıya mal olduğudur.

• AY21. Görev kurgudur: kısa Türkçe destek taleplerine üç bileşenli bir arıza kodu atanır — alan, belirti ve derece. Dört alan, alan başına dört belirti, iki derece; toplam otuz iki kod.
• AY22. Çağrılan şey bir benzeticidir; gerçek bir model uç noktasına hiçbir istek gitmez. Benzetici bu müfredatın giriş kursunda kurulan biçimini sürdürür, tek farkla: seçenek kümesi dışarıdan verilir ve her seçenek bir yoldur, puanı bileşenlerinin izlerinden toplanır.
• AY23. Tohum 20260218; aynı istem aynı tohumda aynı yanıtı verir. Belirsizlik tohum değiştirilerek ölçülür ve her düzenin ikinci koşumu 20260219 ile alınır.
• AY24. Talep metninde alan izi zayıf, belirti izi güçlüdür; ayrıca her talepte yanıltıcı bir alan adı geçer ve izi doğru alanınkinden ağırdır. Kurgu bu yapı ağacın ölçüleceği yeri açar: ilk adım en zayıf kanıtla atılır.
• AY25. Ağaç iki tür çağrı yapar. Uzatma çağrısı bir yolu bir adım uzatır ve dal sayısı kadar tekrarlanır; seçim çağrısı biriken adaylardan tutulacakları ayıklar. İkisi de sayılır.
• AY26. Dallanma çarpanı ile tutulan dal sayısı eşit tutulur. Ölçek küçüktür: dal en çok dört, derinlik en çok üç. Ölçüt üç bileşenin birden doğru olmasıdır.
• AY27. Bedel üç birimle yazılır: çağrı sayısı, belirteç ve başarısız çağrı. Hız sınırı çağrı sayısına bağlı olduğu için dallanma başarısızlığı da çoğaltır.

Yolun Ortasından Dallanmak

Önceki istem tektir ve her şeyi bir kerede ister: otuz iki kodun tamamı isteme yazılır, talep eklenir, tek yanıt beklenir. Değiştirilmiş düzen aynı işi üç adıma böler — önce alan, sonra o alanın belirtisi, sonra derece — ve her adımda birkaç ayrı uzatma ister; biriken adaylardan bir bölümü tutulur, kalanı atılır. İlk blok benzeticiyi, kurgu kod ağacını ve bir talebin ilk iki düzeyini 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}                 # alan izi, zayif
T_IZ = {T_SOZ[a][:5]: a for a in ALAN}                 # yaniltici alan 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}

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 yaniltici alan
    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]                   # cagri sayisi, belirtec, basarisiz cagri


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


def uzat(p, k):                     # yolu k bilesen uzatan butun secenekler
    y = [p]
    for _ in range(k):
        z = []
        for q in y:
            z += [q + (s,) for s in (ALAN if not q else
                                     BELIRTI[q[0]] if len(q) == 1 else DERECE)]
        y = z
    return 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[2] += 1
        return {"giris": len(bel), "yanit": None}
    r = uretec(tohum ^ izno(istem))
    p = {k: 0.15 for k in secenek}
    for t in bel:
        for tablo, w in ((A_IZ, 1.0), (T_IZ, 1.3), (B_IZ, 1.6), (D_IZ, 0.9)):
            h = tablo.get(t)
            if h is not None:
                for k in p:
                    if h in k:      # secenek bir yoldur; puan bilesenlerden toplanir
                        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[1] += len(belirtecle(yaz(k)))
    return {"giris": len(bel), "yanit": k}


def istemle(basmak, secenek, metin):
    return (basmak + " secenekler : " + " , ".join(yaz(k) for k in secenek)
            + " . Talep : " + metin)


x = TALEP[2]
print(f"KURGU: {len(TALEP)} talep, {len(TUM)} ariza kodu (4 alan x 4 belirti x 2 derece)")
print(f"talep {x['no']}: {x['metin']}")
print(f"dogru kod: {yaz(x['kod'])}")
s = cagir(istemle("Talebe bir ariza kodu ata .", TUM, x["metin"]), TUM)
print(f"tek cagri: giris {s['giris']} belirtec, yanit '{yaz(s['yanit'])}'")
ilk, aday = uzat((), 1), []
print("\nilk duzeyde uc ayri uzatma cagrisi:")
for j in range(3):
    u = cagir(istemle("Cozum yolunu bir adim uzat .", ilk, x["metin"]), ilk, TOHUM + j)
    print(f"  aday {j + 1}: {yaz(u['yanit'])} (giris {u['giris']} belirtec)")
    if u["yanit"] not in aday:
        aday.append(u["yanit"])
print("ikinci duzeyde her dalin uzantisi:")
for p in aday:
    se = uzat(p, 1)
    u = cagir(istemle("Cozum yolunu bir adim uzat .", se, x["metin"]), se)
    print(f"  {yaz(p)} -> {yaz(u['yanit'])}")

KURGU: 48 talep, 32 ariza kodu (4 alan x 4 belirti x 2 derece)
talep 5003: hesap uzerinden bildirdim , olcum ile ilgili rakam diye yaziyor , acil olarak degerlendirin
dogru kod: sayac endeks birinci
tek cagri: giris 235 belirtec, yanit 'sayac endeks birinci'

ilk duzeyde uc ayri uzatma cagrisi:
  aday 1: abonelik (giris 43 belirtec)
  aday 2: abonelik (giris 43 belirtec)
  aday 3: sayac (giris 43 belirtec)
ikinci duzeyde her dalin uzantisi:
  abonelik -> abonelik kayit
  sayac -> sayac endeks

İki sayı hemen görünüyor. Otuz iki kodu isteme yazmak istemi 235 belirtece çıkarıyor; bağlam penceresi 240, yani tek istemli düzen sınırın beş belirteç altında duruyor. Ağacın istemi yalnız o düzeyin seçeneklerini taşıdığı için 43 belirteç. Bölmenin ilk kazancı budur.

Alt dört satır dallanmanın niçin gerekli olduğunu gösteriyor. Talepte geçen “hesap” yanıltıcı alanın izidir ve doğru alanın izi olan “olcum” sözcüğünden ağırdır; bu yüzden ilk iki uzatma çağrısı abonelik diyor, doğru alan sayac ancak üçüncüde çıkıyor. Tek dallı bir arama burada biterdi ve ikinci düzeyde abonelik kayit üretip talepte karşılığı olmayan bir yolda derinleşirdi. Doğru dal tutulduğunda ikinci düzey sayac endeks veriyor, çünkü belirti izi güçlüdür. Ağacın vaat ettiği şey budur: zayıf kanıtla atılmış yanlış bir ilk adım, tek adım olmadığı sürece geri alınabilir.

Dal, Derinlik ve Çağrı Sayısı

İkinci blok ağacı kurar ve altı düzeni yan yana koyar: dallanma bire, ikiye, üçe ve dörde çıkarılır, sonra dal üçte tutulup derinlik bire ve ikiye indirilir. Tek çağrı ile bir önceki dersin beş örnekli öz tutarlılığı da tabloya girer; her satırın ikinci koşumu tohum değiştirilerek alınır.

BOLUM = {1: (3,), 2: (2, 1), 3: (1, 1, 1)}      # yol kac adima bolunuyor


def agac(x, dal, tut, derinlik, tohum):
    yol = [()]
    for k in BOLUM[derinlik]:
        aday = []
        for p in yol:                            # uretim: her dali dal kez uzat
            se = uzat(p, k)
            for j in range(min(dal, len(se))):
                s = cagir(istemle("Cozum yolunu bir adim uzat .", se, x), se, tohum + j)
                if s["yanit"] is not None and s["yanit"] not in aday:
                    aday.append(s["yanit"])
        if not aday:
            aday = uzat(yol[0], k)[:1]
        if len(aday) <= tut:
            yol = aday                           # secilecek bir sey yok, cagri harcanmaz
        else:
            yol = []
            for j in range(tut):                 # secim: tutulacak dallari ayikla
                s = cagir(istemle("En umut verici yollari sec .", aday, x), aday, tohum + j)
                if s["yanit"] is not None and s["yanit"] not in yol:
                    yol.append(s["yanit"])
            yol = yol or aday[:tut]
    s = cagir(istemle("Kalan yollardan birini kod olarak yaz .", yol, x), yol, tohum)
    return s["yanit"] or yol[0]


def tekli(x, k, tohum):                          # k = 1 tek cagri, k > 1 oz tutarlilik
    sayim = {}
    for j in range(k):
        s = cagir(istemle("Talebe bir ariza kodu ata .", TUM, x), TUM, tohum + j)
        if s["yanit"] is not None:
            sayim[s["yanit"]] = sayim.get(s["yanit"], 0) + 1
    return max(sorted(sayim, key=yaz), key=lambda a: sayim[a]) if sayim else None


def olc(f, tohum):
    SAYAC[:] = [0, 0, 0]
    d = 0
    for x in TALEP:
        d += f(x["metin"], tohum) == x["kod"]
    return {"isabet": d / len(TALEP), "cagri": SAYAC[0], "bel": SAYAC[1], "hata": SAYAC[2]}


SIRA = [("tek cagri", lambda x, t: tekli(x, 1, t)),
        ("oz tutarlilik 5 ornek", lambda x, t: tekli(x, 5, t)),
        ("agac dal 1 derinlik 3", lambda x, t: agac(x, 1, 1, 3, t)),
        ("agac dal 2 derinlik 3", lambda x, t: agac(x, 2, 2, 3, t)),
        ("agac dal 3 derinlik 3", lambda x, t: agac(x, 3, 3, 3, t)),
        ("agac dal 4 derinlik 3", lambda x, t: agac(x, 4, 4, 3, t)),
        ("agac dal 3 derinlik 1", lambda x, t: agac(x, 3, 3, 1, t)),
        ("agac dal 3 derinlik 2", lambda x, t: agac(x, 3, 3, 2, t))]

print(f"{'istem duzeni':<22}{'isabet':>8}{'kosum2':>8}{'fark':>8}{'cagri':>7}"
      f"{'belirtec':>10}{'basarisiz':>10}")
for ad, f in SIRA:
    A, B = olc(f, TOHUM), olc(f, TOHUM + 1)
    print(f"{ad:<22}{A['isabet']:>8.4f}{B['isabet']:>8.4f}"
          f"{B['isabet'] - A['isabet']:>+8.4f}{A['cagri']:>7d}{A['bel']:>10d}"
          f"{A['hata']:>10d}")

istem duzeni            isabet  kosum2    fark  cagri  belirtec basarisiz
tek cagri               0.4792  0.5208 +0.0417     48     11617         1
oz tutarlilik 5 ornek   0.7292  0.7708 +0.0417    240     58074         6
agac dal 1 derinlik 3   0.0833  0.2708 +0.1875    192      9776         5
agac dal 2 derinlik 3   0.4167  0.5417 +0.1250    506     26651        13
agac dal 3 derinlik 3   0.6250  0.5833 -0.0417    795     43182        21
agac dal 4 derinlik 3   0.6042  0.5833 -0.0208   1086     59835        29
agac dal 3 derinlik 1   0.6250  0.6250 +0.0000    192     37617         5
agac dal 3 derinlik 2   0.7292  0.7500 +0.0208    421     30650        11

Üçüncü satır bu dersin en sert sayısıdır. Çözümü üç adıma bölmek ama hiç dallanmamak isabeti 0,4792’den 0,0833’e düşürüyor ve bunu dört kat çağrıyla yapıyor. Sebep birinci blokta görüldü: dallanmayan bir arama ilk adımı en zayıf kanıtla atar ve bir daha dönemez. Tek istemli düzende üç bileşen aynı puanda birlikte değerlendirildiği için güçlü belirti izi zayıf alan izini taşıyabiliyordu; bölme bu taşımayı kesti. Adıma bölmek tek başına bir iyileştirme değildir; bedeli kesin, kazancı eksidir.

Dallanma bunu geri alıyor. Dal ikide 0,4167, dal üçte 0,6250. Kazancın nerede durduğu dördüncü adımda görünür: dal dörde çıkarıldığında isabet 0,0208 geriliyor, buna karşılık çağrı sayısı 795’ten 1086’ya, belirteç 43182’den 59835’e, başarısız çağrı 21’den 29’a çıkıyor. Aynı düzenin iki koşumu arasındaki fark dal üçte 0,0417’dir. Dal üçten dörde geçişin kattığı fark bu sayıdan küçük olduğu için ölçülmemiş sayılır: iki yüz doksan bir çağrı ve on altı binden fazla belirteç, gösterilemeyen bir değişiklik için harcandı.

Son iki satır derinlik eksenidir ve tersine bir sonuç verir. Aynı dal sayısıyla derinlik üçten ikiye indirildiğinde isabet 0,6250’den 0,7292’ye çıkıyor ve çağrı 795’ten 421’e iniyor: alanla belirti birlikte seçildiğinde güçlü belirti izi zayıf alan izini yeniden taşıyabiliyor. Derinlik bire indiğinde isabet 0,6250’de kalıyor ve çağrı 192’ye düşüyor, ama istemler otuz iki seçeneği birden taşıdığı için belirteç 30650’den 37617’ye çıkıyor. Çağrı sıralaması ile belirteç sıralaması aynı değildir.

Tablonun ikinci satırı dersi kapatır. Bir önceki dersin beş örnekli öz tutarlılığı 0,7292 veriyor — en iyi ağaç düzeniyle aynı sayı — ve bunu 421 yerine 240 çağrıyla yapıyor. Belirteçte durum tersine dönüyor: 58074’e karşı 30650. İki teknik arasındaki seçim bir üstünlük sıralaması değil bir birim seçimidir; ağacın bu görevde kattığı ölçülebilir tek şey, aynı isabete daha az belirteçle ulaşmasıdır. Ölçülmeden değiştirilen istem bir iyileştirme değil bir tahmindir, ve bu tabloda değiştirilen istemlerin yarısı bir iyileştirme değildi.

Özet

• Düşünce ağacı tek bir istem değil bir istem düzenidir: çözüm adımlara bölünür, her adımda birden çok uzatma istenir, adayların bir bölümü tutulur. Uzatma ve seçim çağrıları birlikte sayılır.
• Adıma bölmek dallanmadan yapıldığında zarar verir: isabet 0,4792’den 0,0833’e düşüyor, çağrı 48’den 192’ye çıkıyor. Yanlış atılan ilk adım tek adımsa geri alınamıyor.
• Dallanma kazandırıyor ama doyuyor: dal 1’den 3’e isabet 0,0833’ten 0,6250’ye çıkıyor, dal 4’te 0,0208 geriliyor. Çağrı 192’den 1086’ya, belirteç 9776’dan 59835’e yükseliyor.
• Dal üçten dörde geçişin farkı, aynı düzenin iki koşumu arasındaki 0,0417 farktan küçüktür; ölçülmemiş sayılır ve kazanç olarak yazılamaz.
• Derinlik ters yönde çalışıyor: 3 yerine 2 kullanmak isabeti 0,7292’ye çıkarıp çağrıyı 421’e indiriyor. Öz tutarlılık aynı isabeti 240 çağrı ve 58074 belirteçle veriyor; ağacın 30650 belirteci ucuz, 421 çağrısı pahalıdır.

Sonraki Adım

Bu üç teknik de aynı yönde çalıştı: modelden daha çok adım istendi. Düşünce zinciri adımları tek yanıtın içine yazdırdı, öz tutarlılık aynı adımları birden çok kez ürettirip oyladı, düşünce ağacı adımların arasına bir seçim kuralı koydu. Üçünde de adımlar aynı düzeydedir: hepsi çözümün ayrıntısına doğru ilerler. Yanlış giden şey ise bu derste ayrıntının kendisiydi; yanıltıcı bir sözcük ilk adımı bozdu ve sonraki bütün adımlar o bozuk adımın üzerine kuruldu.

Ayrıntıya inmeden önce yukarı çıkmak hiç denenmedi. Bir talebe kod atamadan önce o talebin hangi genel kurala girdiğini sormak elde bulunan bir seçenekti. Sonraki ders bunu ölçer: istem iki aşamaya bölünür, önce ilke sorulur sonra çözüm istenir, ve iki aşamalının tek aşamalıya göre isabeti ne kadar oynattığı ile kaç belirteç eklediği yan yana basılır.