--- title: 'Düşünce Ağacı' source: 'https://academia.sh/tr/kurslar/istem-muhendisligi/dusunce-agaci' course: 'İstem Mühendisliği' language: tr updated: '2026-08-17T18:06:40+00:00' license: 'CC BY-SA 4.0' --- # Düşünce Ağacı Çözümün ortasından dallanmanın ölçülmesi: aynı 48 kurgu destek talebinde otuz iki arıza kodunu tek istemde soran düzen 0,4792 isabet ve 48 çağrı veriyor, çözümü adımlara bölüp her adımda birkaç uzatma isteyen düşünce ağacı dal 1'de 0,0833'e düşüyor, dal 3'te 0,6250'ye çıkıyor ve dal 4'te duruyor. Dallanma 3'ten 4'e çıkarken isabet 0,0208 geriliyor ama çağrı sayısı 795'ten 1086'ya, belirteç 43182'den 59835'e yükseliyor; bu fark aynı düzenin iki koşumu arasındaki 0,0417 farktan küçük olduğu için ölçülmemiş sayılıyor. 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. ```python # 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. ```python 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.