--- title: 'Geri Adım İstemi' source: 'https://academia.sh/tr/kurslar/istem-muhendisligi/geri-adim-istemi' course: 'İstem Mühendisliği' language: tr updated: '2026-08-17T18:06:40+00:00' license: 'CC BY-SA 4.0' --- # Geri Adım İstemi Çözmeden önce ilke sormanın ölçülmesi: aynı 48 kurgu destek talebinde tek aşamalı istem 0,5417 kod isabeti ve 48 çağrı veriyor, önce genel kuralı sorup sonra çözüm isteyen iki aşamalı istem 0,7500 veriyor ve bunu 96 çağrı ile 1,66 kat belirteçle yapıyor. Kazancın tamamı birinci aşamaya bağlı: doğru ilkede kod isabeti 0,8000, yanlış ilke dayatıldığında 0,0000 ile 0,1458 arasına düşüyor, yani tek aşamalının altına iniyor. Aynı düzen yalnız derece soran görevde isabeti hiç oynatmıyor ama belirteci 2,69 katına çıkarıyor. Ö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 `gozlem`dir**: 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. ```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} # 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. ```python 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.