--- title: 'Yapay Zekâ Mühendisliğine Giriş' source: 'https://academia.sh/tr/kurslar/yz-muhendisligine-giris' language: tr updated: '2026-08-17T04:38:29+00:00' license: 'CC BY-SA 4.0' lessons: 14 outcomes: - 'Yapay zekâ mühendisliği ile makine öğrenmesi mühendisliğini elde olan ayar sayısıyla ayırır' - 'Bir dil modelinin çalışma biçimini belirteç, bağlam penceresi ve çıkarım ekseninde açıklar' - 'Model seçimini yetenek, gecikme, belirteç bedeli ve veri sınırı ölçütlerine bağlar' --- # Yapay Zekâ Mühendisliğine Giriş İçine bakılamayan bir bileşenin yüzeyinden ölçülmesi: çıplak çağrı ile küçük bir düzeneğin aynı görevdeki farkı ve bedeli, eğiten ile kullanan yaklaşımın elinde olan ayar sayısı, aynı girdinin iki koşumunda değişen çıktı ve belirsizliği daraltan üç tasarım kararı, ölçülebilir yetenek iddiasıyla ölçülemez genel iddianın ayrılması, Türkçe metnin ettiği belirteç sayısı, dikkatin uzak bağlamı kullanmasının maliyeti, hangi sorunun önceden eğitimde hangisinin ince ayarda çözüldüğü, en olası seçimle örneklemeli seçimin iki koşumu, bağlam penceresi aşıldığında üç kırpma kararının kazandırdığı ve düşürdüğü, görev sınıfına göre düzeneksiz çağrının çöktüğü yer, uydurma oranı ve üç azaltmanın bedeli, iki erişim biçiminin ölçüt başına karşılaştırılması, ağırlık değiştikçe değişen model seçimi ve bütçenin dayattığı tasarım. ## Alan ve Roller Model eğitmeden ürün kurmanın ne demek olduğunun ve belirsiz çıktıyla tasarım yapmanın sayıyla ölçülmesi: aynı destek talebi görevinde çıplak çağrı ile küçük bir düzeneğin farkı ve bedeli, eğiten ile kullanan iki yaklaşımın elinde olan ayar sayısı ve sorumluluk sınırı, aynı girdinin iki koşumunda kaç istekte çıktının değiştiği ile bunun kullanıcıya görünen kısmı, seçenek sunmak, biçim dayatmak ve kaynağa bağlamanın belirsizliği ne kadar daralttığı, ölçülebilir yetenek iddiasıyla ölçülemez genel iddianın ayrılması ve kaçının bir sınamaya bağlanabildiği. ### Yapay Zekâ Mühendisi Kimdir Source: https://academia.sh/tr/kurslar/yz-muhendisligine-giris/yapay-zeka-muhendisi-kimdir Model eğitmeden ürün kurmanın ölçü biriminin kurulması: bir dil modeli benzeticisi yazılıyor ve verilmiş bir bileşenin yüzeyi beş sayıyla okunuyor. Aynı 120 kurgu destek talebinde düzeneksiz çağrı 0,6000 etiket isabeti ve 0,3833 etiketsiz yanıt payı veriyor, etiket kümesi ve biçim kısıtı eklenmiş küçük bir düzenek 0,7750 ile 0,0000 veriyor. Bedel yan yana yazılıyor: giriş belirteci 2300'den 5422'ye çıkıyor, çıkış belirteci 1353'ten 197'ye iniyor, çağrı sayısı 120'den 123'e çıkıyor ve doğru etiket başına belirteç 50,7'den 60,4'e yükseliyor. Önceki müfredat yüz yirmi bir derste bir modeli kurdu, ölçtü, açıkladı ve kime ne yaptığını saydı. Kapanışında bir eksik yazılıydı: bunların hepsi **tek bir koşumda, tek bir makinede, bir defterin içinde** oldu. Modelin bir **sisteme** dönüşmesi — sürüm alması, başkalarının çağırdığı bir yüz kazanması, bozulduğunda geri alınması ve maliyetinin sayılması — hiç ele alınmadı. Bu müfredat oradan açılır ve bir şey daha ekler: model artık **senin eğittiğin şey de değildir**. Verilmiş, ağırlığını göremediğin, ayarını değiştiremediğin ve içine bakamadığın bir bileşendir. Elinde kalan tek şey onun **çevresidir**: ne söylediğin, yanına ne koyduğun, çıktısını nasıl okuduğun, ne zaman vazgeçtiğin. Bu müfredatın ölçtüğü şey model değil, o çevredir; adı **düzenek** olacak. Bu ders ölçünün birimini kurar ve yedi kurs boyunca kullanılacak **dil modeli benzeticisini** yazar. - **YA1.** Bu müfredatın hiçbir dersinde gerçek bir model uç noktası çağrılmaz. Kod, standart kitaplıkla yazılmış bir **benzeticiyi** çağırır. Benzetici bir ürünü taklit etmez; bir uç noktanın **ölçülebilir yüzeyini** taşır. - **YA2.** Benzeticinin belirteçleyicisi kurgudur: sözcükler boşlukta ayrılır ve beş damgadan uzun parçalar bölünür. Belirteçlemenin kendisi M27'nin doğal dil işleme kursunda ölçüldü ve burada tekrarlanmaz; burada belirteç yalnız bir **bedel birimidir**. - **YA3.** Yüzey beş ölçüdür: giriş belirteci, çıkış belirteci, **bağlam penceresi** (240 belirteç), en büyük çıktı uzunluğu (24 belirteç) ve durum. - **YA4.** Benzetici tohumla belirlenir (**20260218**). Aynı istem aynı tohumda aynı yanıtı verir; sayılar koşumdan koşuma oynamaz. **Belirsizlik tohum değiştirilerek** ölçülür. - **YA5.** İki başarısızlık kurulur: hız sınırı çağrı sayısına bağlıdır (her otuz yedinci çağrı), zaman aşımı istem uzunluğuna bağlıdır. İkisi de başarısızlık payına girer. - **YA6.** Destek talepleri **kurgudur**: 120 kayıt, beş konu ve kayıtların bir bölümüne eklenen yanıltıcı bir cümle. M26 ve M27'nin bölgesel ölçüm ağı burada bir destek yardımcısına dönüşür. - **YA7.** Benzeticinin iç işaret tablosunda birkaç **yanıltıcı bağ** vardır. Bir modelin sistematik olarak karıştırdığı kavram çiftlerinin kurgu karşılığıdır ve dışarıdan giderilemez. - **YA8.** Ölçüt **etiket isabetidir**. Yanıttan bir etiket okunamazsa kayıt yanlış sayılır ve **etiketsiz yanıt payında** ayrıca gösterilir. #### Modelin Ölçülebilir Yüzeyi Verilmiş bir bileşen içinden ölçülemez. Ağırlığı görünmez, eğitim verisi bilinmez, kararının gerekçesi okunmaz. Geriye tek bir ölçüm yeri kalır: bileşenin **dışarıya verdiği yüzey**. Kaç belirteç girdi, kaç belirteç çıktı, sınır neredeydi, aynı girdi iki koşumda ne verdi, çağrı hangi durumla döndü. **Kursun kuralı budur: verilmiş bir bileşen yüzeyinden ölçülür.** İlk blok bu yüzeyi kurar. Çağrılan şey bir dil modeli benzeticisidir; gerçek bir uç noktaya hiçbir istek gitmez. ```python # BENZETICI. Bu kod gercek bir model uc noktasi cagirmaz; standart kitaplikla yazilmis # bir dil modeli benzeticisidir. Destek talepleri de KURGU'dur. import math TOHUM, M32 = 20260218, 0xFFFFFFFF PENCERE, EN_UZUN = 240, 24 # baglam penceresi ve en buyuk cikti, 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 KONU = ["fatura", "ariza", "sayac", "tarife", "kesinti"] KALIP = { "fatura": ["bu ayki fatura tutari gecen aya gore cok yuksek geldi", "faturami odedim ama sistemde borc gorunuyor", "fatura ayrintisini nereden gorebilirim"], "ariza": ["evde su akmiyor bir ariza var galiba", "baglanti bozuk oldu ve hic calismiyor", "ariza kaydi actim ama ekip gelmedi"], "sayac": ["sayac okumasi yanlis girilmis endeks tutmuyor", "sayac degisimi icin randevu istiyorum", "sayac uzerindeki endeks ile fatura ayni degil"], "tarife": ["hangi tarife basamagindayim ogrenmek istiyorum", "tarife degisikligi icin ne yapmam gerekiyor", "birim ucret abone tipine gore degisiyor mu"], "kesinti": ["mahallede kesinti var ne zaman gelecek", "planli kesinti duyurusu nereden takip edilir", "aksamdan beri kesinti yasiyoruz"], } EK = ["ayrica gecen ay da ayni sorun olmustu", "bu konuda memnun degilim", "acil bilgi almam gerekiyor", "kayit numaram elimde yok"] TALEP = [] for i in range(120): r = uretec(TOHUM + i) k = KONU[ayrik(r(), [0.24, 0.22, 0.18, 0.20, 0.16])] m = KALIP[k][int(r() * 3)] if r() < 0.34: m += " " + EK[int(r() * 4)] TALEP.append({"no": 4001 + i, "metin": m, "konu": k}) KAVRAM = KONU + ["odeme", "sikayet", "bilgi", "genel"] IZ = {"fatur": "fatura", "tutar": "fatura", "ayrin": "fatura", "ariza": "ariza", "bozuk": "ariza", "calis": "ariza", "akmiy": "ariza", "sayac": "sayac", "endek": "sayac", "okuma": "sayac", "tarif": "tarife", "birim": "tarife", "abone": "tarife", "basam": "tarife", "kesin": "kesinti", "duyur": "kesinti", "mahal": "kesinti", "borc": "odeme", "odedi": "odeme", "ucret": "odeme", "memnu": "sikayet", "sorun": "sikayet", "acil": "sikayet", "bilgi": "bilgi", "ogren": "bilgi", "nered": "bilgi"} TUZAK = {"degis": "tarife", "kayit": "ariza", "yukse": "tarife", "gorun": "fatura", "ekip": "kesinti", "takip": "tarife", "giril": "fatura"} # yaniltici baglar SERBEST = ["talebiniz {k} konusuyla ilgili gorunuyor", "bu kayit {k} basligina girer , ilgili ekibe yonlendirildi", "kaydiniz alindi , konuyu inceleyip donus yapacagiz"] SAYAC = [0] def cagir(istem, tohum=TOHUM, sicaklik=0.6, en_uzun=EN_UZUN): SAYAC[0] += 1 bel = belirtecle(istem) if len(bel) > PENCERE: return {"durum": "baglam_asimi", "giris": len(bel), "cikis": 0, "yanit": ""} if SAYAC[0] % 37 == 0: return {"durum": "hiz_siniri", "giris": len(bel), "cikis": 0, "yanit": ""} r = uretec(tohum ^ izno(istem)) if len(bel) > 90 and r() < 0.04: return {"durum": "zaman_asimi", "giris": len(bel), "cikis": 0, "yanit": ""} aday = [k for k in KAVRAM if k[:5] in bel] # istemde adi gecen kavramlar if len(aday) < 3: aday = KAVRAM p = {k: 0.15 for k in aday} for t in bel: for tablo, w in ((IZ, 1.0), (TUZAK, 1.3)): if tablo.get(t) in p: p[tablo[t]] += w if sicaklik <= 0.0: k = max(sorted(p), key=lambda a: p[a]) # en olasi secim else: e = [math.exp(p[a] / sicaklik) for a in sorted(p)] k = sorted(p)[ayrik(r(), [v / sum(e) for v in e])] y = k if "tek" in bel else SERBEST[ayrik(r(), [0.42, 0.26, 0.32])].format(k=k) cb = belirtecle(y) if len(cb) > en_uzun: # durdurma kosulu cb = cb[:en_uzun] y = " ".join(cb) return {"durum": "tamam", "giris": len(bel), "cikis": len(cb), "yanit": y} def oku(y): # yanittan etiket cikarma for s in y.lower().split(): if s in KONU: return s return None t = TALEP[0] b = belirtecle(t["metin"]) print(f"KURGU talep kumesi: {len(TALEP)} kayit, {len(KONU)} konu") print(f"ornek talep {t['no']}: {t['metin']}") print(f"belirtec sayisi {len(b)}, ilk alti parca {b[:6]}") s = cagir("Su destek talebini yanitla: " + t["metin"]) print(f"\ndurum {s['durum']}, giris {s['giris']} belirtec, cikis {s['cikis']} belirtec") print(f"yanit: {s['yanit']}") i1 = "Su destek talebini yanitla: " + TALEP[3]["metin"] for th in (TOHUM, TOHUM + 1): print(f"tohum {th}: {cagir(i1, tohum=th)['yanit']}") u = cagir("Su destek talebini yanitla: " + t["metin"], en_uzun=4) print(f"\nen buyuk cikti 4 belirtec: {u['yanit']}") uz = cagir(" ".join(x["metin"] for x in TALEP[:20])) print(f"pencereyi asan istem: durum {uz['durum']}, giris {uz['giris']} (sinir {PENCERE})") ``` ``` KURGU talep kumesi: 120 kayit, 5 konu ornek talep 4001: planli kesinti duyurusu nereden takip edilir belirtec sayisi 11, ilk alti parca ['planl', 'i', 'kesin', 'ti', 'duyur', 'usu'] durum tamam, giris 18 belirtec, cikis 14 belirtec yanit: bu kayit kesinti basligina girer , ilgili ekibe yonlendirildi tohum 20260218: kaydiniz alindi , konuyu inceleyip donus yapacagiz tohum 20260219: bu kayit ariza basligina girer , ilgili ekibe yonlendirildi en buyuk cikti 4 belirtec: bu kayit kesin ti pencereyi asan istem: durum baglam_asimi, giris 266 (sinir 240) ``` Başlıktan sonraki yedi satırın her biri bir sınırı gösteriyor. Altı sözcüklük bir talep **on bir belirteç** ediyor; "duyurusu" tek başına iki parçaya bölünüyor. Eklemeli bir dilde sözcük sayısı ile belirteç sayısı aynı şey değildir ve bedel ikincisinden okunur. Dördüncü ve beşinci satır bu müfredatın en rahatsız edici özelliğidir. **Aynı istem, iki tohumda iki ayrı yanıt** verdi: birincisinde yanıt hiçbir etiket taşımıyor, ikincisinde `ariza` diyor. Talebin gerçek konusu da `ariza`. Yani doğru yanıt bir kez çıktı, bir kez çıkmadı ve arada istem hiç değişmedi. Bir bileşenin aynı girdiye iki ayrı yanıt vermesi, çevresine kurulacak her şeyin gerekçesidir. Son iki satır iki sert sınırdır. En büyük çıktı uzunluğu dörde indirildiğinde yanıt `bu kayit kesin ti` oluyor: **durdurma koşulu etiketin ortasından kesti** ve çıktı okunamaz hâle geldi. Yirmi talep birleştirilip gönderildiğinde 266 belirteç bağlam penceresini aşıyor ve çağrı hiç yanıt üretmeden dönüyor. İkisi de modelin "yanlış düşünmesi" değil, yüzeyin verdiği bir sayıdır. #### Çıplak Çağrı ve Düzeneğin Farkı Görev sabittir: 120 kurgu destek talebinin her biri beş konudan birine atanacak. İki yol yan yana konur. **Çıplak çağrı** en yalın kullanımdır — talebi olduğu gibi gönderip yanıtı okumak. **Düzenek** üç küçük parçadır: istemde etiket kümesini saymak, biçimi dayatmak ve okunamayan yanıtta bir kez yeniden denemek. ```python YONERGE = ("Talebi su etiketlerden birine ata: fatura , ariza , sayac , tarife , " "kesinti . Yanit olarak tek etiket yaz . Talep: ") def olc(duzenek): SAYAC[0] = 0 g = c = d = bos = yd = hata = 0 for x in TALEP: istem = (YONERGE if duzenek else "Su destek talebini yanitla: ") + x["metin"] s = cagir(istem) g, c = g + s["giris"], c + s["cikis"] hata += s["durum"] != "tamam" e = oku(s["yanit"]) if e is None and duzenek: # bicim okunamadi: bir kez yeniden dene yd += 1 s = cagir(istem, tohum=TOHUM + 1) g, c = g + s["giris"], c + s["cikis"] hata += s["durum"] != "tamam" e = oku(s["yanit"]) bos += e is None d += e == x["konu"] return {"isabet": d / len(TALEP), "bos": bos / len(TALEP), "cagri": SAYAC[0], "giris": g, "cikis": c, "yeniden": yd, "hata": hata / SAYAC[0]} A, B = olc(False), olc(True) print(f"{'olcu':<22} {'ciplak cagri':>13} {'duzenekle':>11} {'fark':>9}") for ad, k, bic in (("etiket isabeti", "isabet", "{:.4f}"), ("etiketsiz yanit payi", "bos", "{:.4f}"), ("cagri sayisi", "cagri", "{:d}"), ("giris belirteci", "giris", "{:d}"), ("cikis belirteci", "cikis", "{:d}"), ("basarisizlik payi", "hata", "{:.4f}")): f = B[k] - A[k] print(f"{ad:<22} {bic.format(A[k]):>13} {bic.format(B[k]):>11} " f"{('{:+.4f}' if '.' in bic else '{:+d}').format(f):>9}") tA, tB = A["giris"] + A["cikis"], B["giris"] + B["cikis"] print(f"\ntoplam belirtec {tA} -> {tB} ({tB / tA:.2f} kat), yeniden deneme {B['yeniden']}") print(f"dogru etiket basina bedel: {tA / A['isabet'] / len(TALEP):.1f} -> " f"{tB / B['isabet'] / len(TALEP):.1f} belirtec") ``` ``` olcu ciplak cagri duzenekle fark etiket isabeti 0.6000 0.7750 +0.1750 etiketsiz yanit payi 0.3833 0.0000 -0.3833 cagri sayisi 120 123 +3 giris belirteci 2300 5422 +3122 cikis belirteci 1353 197 -1156 basarisizlik payi 0.0250 0.0244 -0.0006 toplam belirtec 3653 -> 5619 (1.54 kat), yeniden deneme 3 dogru etiket basina bedel: 50.7 -> 60.4 belirtec ``` İlk satır düzeneğin kazancıdır: **0,6000'den 0,7750'ye**, artış **0,1750**. İkinci satır kazancın nereden geldiğini söylüyor. Çıplak çağrıda yanıtların **0,3833 payından** hiçbir etiket okunamıyordu; ya yanıt beş etiketin dışında bir sözcükle kapanıyordu ya da "kaydınız alındı" biçiminde hiçbir konu adı taşımıyordu. Etiket kümesi isteme yazıldığında bu pay **sıfıra** iniyor. Kazanç modelin daha iyi düşünmesinden değil, **cevabın okunabilir hâle gelmesinden** geliyor. #### Bedeli Yazılmayan Düzenek Ölçülmemiş Sayılır Aynı tablonun alt yarısı bedeldir ve bu müfredatta üst yarısı kadar bağlayıcıdır. Giriş belirteci **2300'den 5422'ye** çıktı: yönergeyi her talebin başına eklemek, istemin uzunluğunu iki katından fazla artırdı. Çıkış belirteci ters yöne gitti, **1353'ten 197'ye**; tek sözcüklük yanıt üretmek, cümle üretmekten yedi kat ucuzdur. Çağrı sayısı **120'den 123'e** çıktı; üç fazla çağrının hepsi hız sınırına takılıp yeniden denenen isteklerdir. Başarısızlık payı iki yolda da yaklaşık aynı kaldı, çünkü hız sınırı düzeneğin değil **yüzeyin** bir özelliğidir. Son satır bu dersin asıl sayısıdır. Toplam belirteç **1,54 kat** arttı. İsabet arttığı için doğru yanıt başına bedel bunun altında kalıyor, ama yine de **50,7 belirteçten 60,4 belirtece** çıkıyor. Yani düzenek işe yaradı ve **aynı anda pahalılaştı**. İki sayıdan yalnız birini yazan bir rapor, ölçüm değil savunmadır. **Müfredatın kuralı budur: bir yapay zekâ sisteminin sayısı, modelin sayısı değil düzeneğin sayısıdır; bedeli yazılmayan düzenek ölçülmemiş sayılır.** Yapay zekâ mühendisinin işi bu tabloda görünür. Model verilmiştir ve bu tabloda hiç değişmedi: aynı benzetici, aynı tohum, aynı ağırlık. Değişen tek şey **çevresidir** — isteme yazılan etiket kümesi, dayatılan biçim, okunamayan yanıtta verilen yeniden deneme kararı ve gecikme sınıfının tek çağrıda tutulması. Yüz yirmi bir derste öğrenilen ayarlar burada elde değildir; onların yerine başka ayarlar vardır ve hepsi modelin **dışında** durur. Bir sonraki ders bu iki ayar kümesini yan yana koyup sayar. #### Özet - Verilmiş bir bileşen içinden ölçülemez, **yüzeyinden** ölçülür: giriş belirteci, çıkış belirteci, bağlam penceresi, durdurma koşulu ve durum. Bu müfredatın kodu bir **benzetici** çağırır. - Model belirsiz bir bileşendir. Aynı istem iki tohumda iki ayrı yanıt verdi; birinde doğru etiket çıktı, öbüründe yanıt hiçbir etiket taşımadı. - Aynı 120 kurgu talepte çıplak çağrı **0,6000** etiket isabeti veriyor ve yanıtların **0,3833** payından hiçbir etiket okunamıyor. Etiket kümesi, biçim kısıtı ve tek yeniden denemeden oluşan düzenek **0,7750** ve **0,0000** veriyor. - Bedel yan yana yazılır: giriş belirteci 2300'den 5422'ye, çağrı 120'den 123'e çıkıyor, çıkış belirteci 1353'ten 197'ye iniyor, toplam belirteç **1,54 kat** artıyor. - Doğru etiket başına bedel **50,7'den 60,4 belirtece** yükseliyor: düzenek hem işe yaradı hem pahalılaştı. Bedeli yazılmayan düzenek ölçülmemiş sayılır. #### Sonraki Adım Bu derste model hiç değişmedi ve bütün kazanç onun dışından geldi. Bu, önceki müfredatın tam tersidir: orada kazanç modelin içinden gelirdi ve dışarısı sabit tutulurdu. İki yaklaşım aynı problemi çözebilir, ama ellerinde tuttukları şey aynı değildir. Sonraki ders bunu sayar: aynı destek talebi probleminde eğiten yaklaşımın kaç ayarı vardır, kullanan yaklaşımın kaç ayarı vardır, bu ayarların kaçı sayıyı gerçekten oynatır ve iki yaklaşımda **hangi kararın kimde olduğu** nerede ayrılır. ### Yapay Zekâ ve Makine Öğrenmesi Mühendisliği Farkı Source: https://academia.sh/tr/kurslar/yz-muhendisligine-giris/yapay-zeka-ve-makine-ogrenmesi-muhendisligi-farki Sorumluluk sınırının ayar sayısıyla ölçülmesi: aynı destek talebi probleminde eğiten yaklaşımın dört ayarından üçü, kullanan yaklaşımın dört ayarından üçü (tohumla birlikte beş satırdan dördü) sayıyı 0,0200'den fazla oynatıyor. Eğiten yaklaşım 48 etiketli örnek istiyor ve 0,9861'e çıkıyor, kullanan yaklaşım sıfır etiketli örnekle 0,8056 veriyor. İki ayar listesinin hiçbir maddesi ortak değil. Yeniden deneme sayıyı 0,0000 oynatıp bir çağrı ve 51 belirteç ekliyor, elde olmayan tohum ise sayıyı 0,1250 düşürüyor. Önceki ders modeli hiç değiştirmeden sayıyı 0,6000'den 0,7750'ye çıkardı. Bütün kazanç modelin dışından geldi. Önceki müfredatta bunun tersi olurdu: kazanç modelin içinden gelir, dışarısı sabit tutulurdu. İki yaklaşım aynı destek talebi problemini çözebilir, ama ellerinde tuttukları şey aynı değildir. Bu ders o farkı bir sayıya bağlar. İki yaklaşım aynı 72 kayıtlık sınama kümesinde koşturulur ve her birinin **elinde olan ayar** tek tek çevrilir. Ölçülen şey hangisinin daha iyi olduğu değil, **hangi kararın kimde olduğudur**: kaç ayar var, kaçı sayıyı gerçekten oynatıyor ve elde olmayan neyin ne kadar oynattığı. - **YA9.** Kurgu ve benzetici önceki dersten aynen sürer: 120 kurgu destek talebi, beş konu, tohum **20260218**. Eğitim kümesi ilk 48 kayıt, sınama kümesi kalan **72 kayıttır**. İki yaklaşım da aynı sınama kümesinde okunur. - **YA10.** Eğiten yaklaşımın modeli bir **sayım tablosudur**: eğitim kümesindeki her belirtecin hangi konuda kaç kez geçtiğini tutar ve toplam kanıtı en yüksek konuyu söyler. Öğrenen bir yordamdır ve ağırlıkları eğitimle belirlenir. - **YA11.** M27'nin denetimli öğrenme kursu ayar değişkenlerini (derinlik, en az yaprak, sınıf ağırlığı, ayar bütçesi) ölçtü. O yordam burada **tekrarlanmaz**; burada yalnız **ayarın kimde olduğu** sayılır. - **YA12.** Kullanan yaklaşım benzeticiyi çağırır ve modelin içine hiç dokunmaz. Sayım tablosu kurmaz, etiketli örnek görmez. - **YA13.** Bir ayarın "sayıyı oynattığı", iki ucu arasındaki isabet farkının mutlak değerinin **0,0200'den büyük** olması demektir. Eşik bir karardır ve sabit tutulur. - **YA14.** Tohum bir ayar değildir; benzeticinin **belirsizliğinin ölçüsüdür**. Tabloya elde olmayanın ne kadar oynattığını göstermek için konur. - **YA15.** Bedel sütunları yalnız kullanan yaklaşımda vardır, çünkü eğiten yaklaşımın bedeli çağrı ve belirteç değil **etiketli örnektir**. İki bedel birimi birbirine çevrilmez. #### Eğiten Yaklaşımın Elindeki Ayarlar Eğiten yaklaşımda model senin ürettiğin nesnedir. Elindeki ayarlar onun içine bakar: hangi veriyle kurulacağı, hangi birimle sayacağı, hangi kanıtı görmezden geleceği, seyrek gözlemi nasıl yumuşatacağı. Aşağıdaki blok benzeticiyi ve kurguyu kurar, sonra öğrenen yordamı yazıp dört ayarı iki uçta çevirir. ```python # BENZETICI. Bu kod gercek bir model uc noktasi cagirmaz; standart kitaplikla yazilmis # bir dil modeli benzeticisidir. Destek talepleri de KURGU'dur. import math TOHUM, M32 = 20260218, 0xFFFFFFFF PENCERE, EN_UZUN = 240, 24 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): 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): h = 2166136261 for c in m: h = ((h ^ ord(c)) * 16777619) & M32 return h KONU = ["fatura", "ariza", "sayac", "tarife", "kesinti"] KALIP = { "fatura": ["bu ayki fatura tutari gecen aya gore cok yuksek geldi", "faturami odedim ama sistemde borc gorunuyor", "fatura ayrintisini nereden gorebilirim"], "ariza": ["evde su akmiyor bir ariza var galiba", "baglanti bozuk oldu ve hic calismiyor", "ariza kaydi actim ama ekip gelmedi"], "sayac": ["sayac okumasi yanlis girilmis endeks tutmuyor", "sayac degisimi icin randevu istiyorum", "sayac uzerindeki endeks ile fatura ayni degil"], "tarife": ["hangi tarife basamagindayim ogrenmek istiyorum", "tarife degisikligi icin ne yapmam gerekiyor", "birim ucret abone tipine gore degisiyor mu"], "kesinti": ["mahallede kesinti var ne zaman gelecek", "planli kesinti duyurusu nereden takip edilir", "aksamdan beri kesinti yasiyoruz"], } EK = ["ayrica gecen ay da ayni sorun olmustu", "bu konuda memnun degilim", "acil bilgi almam gerekiyor", "kayit numaram elimde yok"] TALEP = [] for i in range(120): r = uretec(TOHUM + i) k = KONU[ayrik(r(), [0.24, 0.22, 0.18, 0.20, 0.16])] m = KALIP[k][int(r() * 3)] if r() < 0.34: m += " " + EK[int(r() * 4)] TALEP.append({"no": 4001 + i, "metin": m, "konu": k}) KAVRAM = KONU + ["odeme", "sikayet", "bilgi", "genel"] IZ = {"fatur": "fatura", "tutar": "fatura", "ayrin": "fatura", "ariza": "ariza", "bozuk": "ariza", "calis": "ariza", "akmiy": "ariza", "sayac": "sayac", "endek": "sayac", "okuma": "sayac", "tarif": "tarife", "birim": "tarife", "abone": "tarife", "basam": "tarife", "kesin": "kesinti", "duyur": "kesinti", "mahal": "kesinti", "borc": "odeme", "odedi": "odeme", "ucret": "odeme", "memnu": "sikayet", "sorun": "sikayet", "acil": "sikayet", "bilgi": "bilgi", "ogren": "bilgi", "nered": "bilgi"} TUZAK = {"degis": "tarife", "kayit": "ariza", "yukse": "tarife", "gorun": "fatura", "ekip": "kesinti", "takip": "tarife", "giril": "fatura"} SERBEST = ["talebiniz {k} konusuyla ilgili gorunuyor", "bu kayit {k} basligina girer , ilgili ekibe yonlendirildi", "kaydiniz alindi , konuyu inceleyip donus yapacagiz"] SAYAC = [0] def cagir(istem, tohum=TOHUM, sicaklik=0.6, en_uzun=EN_UZUN): SAYAC[0] += 1 bel = belirtecle(istem) if len(bel) > PENCERE: return {"durum": "baglam_asimi", "giris": len(bel), "cikis": 0, "yanit": ""} if SAYAC[0] % 37 == 0: return {"durum": "hiz_siniri", "giris": len(bel), "cikis": 0, "yanit": ""} r = uretec(tohum ^ izno(istem)) if len(bel) > 90 and r() < 0.04: return {"durum": "zaman_asimi", "giris": len(bel), "cikis": 0, "yanit": ""} aday = [k for k in KAVRAM if k[:5] in bel] if len(aday) < 3: aday = KAVRAM p = {k: 0.15 for k in aday} for t in bel: for tablo, w in ((IZ, 1.0), (TUZAK, 1.3)): if tablo.get(t) in p: p[tablo[t]] += w if sicaklik <= 0.0: k = max(sorted(p), key=lambda a: p[a]) else: e = [math.exp(p[a] / sicaklik) for a in sorted(p)] k = sorted(p)[ayrik(r(), [v / sum(e) for v in e])] y = k if "tek" in bel else SERBEST[ayrik(r(), [0.42, 0.26, 0.32])].format(k=k) cb = belirtecle(y) if len(cb) > en_uzun: cb = cb[:en_uzun] y = " ".join(cb) return {"durum": "tamam", "giris": len(bel), "cikis": len(cb), "yanit": y} def oku(y): for s in y.lower().split(): if s in KONU: return s return None SIN = TALEP[48:] # sinama kumesi: 72 kayit def bol(m, damga): return belirtecle(m) if damga else m.lower().split() def egit(kume, damga=True, enaz=1, duz=0.5): # OGRENEN yordam: sayim tablosu sayim, siklik = {}, {} for x in kume: siklik[x["konu"]] = siklik.get(x["konu"], 0) + 1 for t in bol(x["metin"], damga): c = sayim.setdefault(t, {}) c[x["konu"]] = c.get(x["konu"], 0) + 1 en = max(sorted(siklik), key=lambda k: siklik[k]) def kestir(m): p = {k: 0.0 for k in KONU} for t in bol(m, damga): c = sayim.get(t, {}) if sum(c.values()) < enaz: continue for k in KONU: p[k] += math.log((c.get(k, 0) + duz) / (siklik.get(k, 1) + 5 * duz)) return max(sorted(p), key=lambda k: p[k]) if any(p.values()) else en return kestir def isabet_e(n=48, **kw): f = egit(TALEP[:n], **kw) return sum(f(x["metin"]) == x["konu"] for x in SIN) / len(SIN) print(f"{'EGITEN yaklasimin elindeki ayar':<31} {'A':>7} {'B':>7} {'oynama':>8}") oy_e = [] for ad, a, b in (("egitim ornegi 8 / 48", {"n": 8}, {"n": 48}), ("belirtec birimi sozcuk / parca", {"damga": False}, {"damga": True}), ("en az siklik 3 / 1", {"enaz": 3}, {"enaz": 1}), ("duzlestirme 0,05 / 0,50", {"duz": 0.05}, {"duz": 0.5})): va, vb = isabet_e(**a), isabet_e(**b) oy_e.append(abs(vb - va)) print(f"{ad:<31} {va:>7.4f} {vb:>7.4f} {vb - va:>+8.4f}") print(f"0,0200'den fazla oynatan: {sum(v > 0.02 for v in oy_e)}/{len(oy_e)}, " f"gereken etiketli ornek 48, degisen sey: sayim tablosunun kendisi") ``` ``` EGITEN yaklasimin elindeki ayar A B oynama egitim ornegi 8 / 48 0.8194 0.9861 +0.1667 belirtec birimi sozcuk / parca 0.9583 0.9861 +0.0278 en az siklik 3 / 1 0.9028 0.9861 +0.0833 duzlestirme 0,05 / 0,50 0.9722 0.9861 +0.0139 0,0200'den fazla oynatan: 3/4, gereken etiketli ornek 48, degisen sey: sayim tablosunun kendisi ``` Dört ayardan üçü sayıyı eşiğin üstünde oynatıyor ve en büyük oynama **etiketli örnek sayısından** geliyor: sekiz örnekle 0,8194, kırk sekiz örnekle **0,9861**. Bu, eğiten yaklaşımın hem gücü hem faturasıdır. Sayıyı yükseltmenin en etkili yolu daha çok etiketli örnektir ve etiketli örnek üretilmesi gereken bir şeydir. Kalan üç ayar da modelin **içine** bakar: hangi birimle sayıldığı, hangi kanıtın atıldığı, seyrek gözlemin nasıl yumuşatıldığı. Hepsi elin altındadır ve hepsi modelin kendisini değiştirir. #### Kullanan Yaklaşımın Elindeki Ayarlar Kullanan yaklaşımda hiçbir ayar modelin içine bakmaz. Sayım tablosu yoktur, ağırlık yoktur, eğitim kümesi yoktur. Elde kalan şey çağrının **çevresidir**. ```python YONERGE = ("Talebi su etiketlerden birine ata: fatura , ariza , sayac , tarife , " "kesinti . Yanit olarak tek etiket yaz . Talep: ") def olc_k(yonerge=YONERGE, sicaklik=0.6, tohum=TOHUM, deneme=0): SAYAC[0] = 0 d = bel = 0 for x in SIN: e = None for j in range(deneme + 1): s = cagir(yonerge + x["metin"], tohum=tohum + j, sicaklik=sicaklik) bel += s["giris"] + s["cikis"] e = oku(s["yanit"]) if e is not None: break d += e == x["konu"] return d / len(SIN), SAYAC[0], bel print(f"{'KULLANAN yaklasimin elindeki ayar':<31} {'A':>7} {'B':>7} {'oynama':>8} " f"{'cagri':>6} {'belirtec':>9}") oy_k = [] for ad, a, b in (("etiket kumesi yok / var", {"yonerge": "Su destek talebini yanitla: "}, {}), ("bicim kisiti yok / var", {"yonerge": YONERGE.replace("tek etiket", "bir cevap")}, {}), ("dagilim sicakligi 0,6 / 0,0", {"sicaklik": 0.6}, {"sicaklik": 0.0}), ("yeniden deneme 0 / 1", {"deneme": 0}, {"deneme": 1}), ("tohum 20260218 / 20260219", {"tohum": TOHUM}, {"tohum": TOHUM + 1})): (va, ca, ba), (vb, cb, bb) = olc_k(**a), olc_k(**b) oy_k.append(abs(vb - va)) print(f"{ad:<31} {va:>7.4f} {vb:>7.4f} {vb - va:>+8.4f} {cb - ca:>+6d} {bb - ba:>+9d}") print(f"0,0200'den fazla oynatan: {sum(v > 0.02 for v in oy_k)}/{len(oy_k)}, " f"gereken etiketli ornek 0, degisen sey: modelin disindaki her sey") ``` ``` KULLANAN yaklasimin elindeki ayar A B oynama cagri belirtec etiket kumesi yok / var 0.6667 0.8056 +0.1389 +0 +1090 bicim kisiti yok / var 0.5000 0.8056 +0.3056 +0 -634 dagilim sicakligi 0,6 / 0,0 0.8056 0.9028 +0.0972 +0 +7 yeniden deneme 0 / 1 0.8056 0.8056 +0.0000 +1 +51 tohum 20260218 / 20260219 0.8056 0.6806 -0.1250 +0 +6 0,0200'den fazla oynatan: 4/5, gereken etiketli ornek 0, degisen sey: modelin disindaki her sey ``` En büyük oynama **biçim kısıtından** geliyor: 0,5000'den 0,8056'ya, artış **0,3056**. Bu satır aynı zamanda bedel sütununda **eksi** işaretli tek satırdır — 634 belirteç kazandırıyor. Modele "tek etiket yaz" demek hem isabeti yükseltiyor hem maliyeti düşürüyor, çünkü kısa yanıt ucuzdur. Etiket kümesini isteme yazmak da 0,1389 kazandırıyor ama bunun bedeli **1090 belirteçtir**. Dördüncü satır bu müfredatın ikinci iddiasını ilk kez ödüyor. **Yeniden deneme sayıyı 0,0000 oynatıyor** ve karşılığında bir fazla çağrı ile 51 belirteç istiyor. Yalın düzenekte okunamayan yanıt zaten kalmamıştı; yeniden deneme yalnız hız sınırına takılan tek isteği kurtarabilirdi ve o istek iki denemede de yanlış etiket verdi. **Düzenek eklemek her zaman iyileştirmez, ama bedeli her zaman kesindir.** Beşinci satır ayar değil. Tohum senin ayarın değildir; benzeticinin belirsizliğidir ve bu tabloda sayıyı **0,1250 düşürüyor**. Yani elinde olmayan bir şey, elinde olan dört ayardan ikisinden daha çok oynatıyor. Bir ürünün sayısını yükseltmek için harcanan emeğin bir kısmı, ölçümün kendisinin bu genişlikte oynadığını bilmeden harcanır. #### Hangi Karar Kimde İki listenin **hiçbir maddesi ortak değildir**. Aşağıdaki tablo bu ayrımı kararlar düzeyinde yazar. | Karar | Eğiten yaklaşım | Kullanan yaklaşım | |---|---|---| | Etiketli örnek toplamak | zorunlu, sayıyı en çok oynatan ayar | gerekmez, sıfır örnekle çalışır | | Model ağırlığı | üretilir ve saklanır | görülmez, değiştirilemez | | Görevin tanımı | etiket kümesi eğitim verisinde durur | etiket kümesi istem metnine yazılır | | Çıktının biçimi | yordamın dönüş tipi, kesindir | istemle rica edilir, doğrulanması gerekir | | Aynı girdiye aynı yanıt | yordam gereği verilir | verilmez, ölçülmesi gerekir | | Sayı düştüğünde | model yeniden eğitilir | düzenek değiştirilir | Son satır sorumluluk sınırının kendisidir. Eğiten yaklaşımda bir bozulmanın adresi bellidir: veri ya da model. Kullanan yaklaşımda model bozulmaz, çünkü model senin değildir; bozulan şey ya istemdir, ya çıktının okunma yordamıdır, ya da bileşenin altındaki bir değişikliktir. Üçüncüsünde elinde tek bir şey kalır: **yüzeyi ölçmüş olmak**. Ölçülmüş bir yüzey, değişimin ne zaman olduğunu söyler; ölçülmemiş bir yüzey yalnız şikâyeti söyler. Sayılar arasındaki 0,9861 ile 0,8056 farkı da bu çerçevede okunur. Eğiten yaklaşım daha yüksek sayı verdi, ama karşılığında 48 etiketli örnek istedi. Kullanan yaklaşım **hiç etiketli örnek görmeden** 0,8056 verdi. Kapalı bir etiket kümesi ve bol örneği olan bir görevde birincisi kazanır; etiket kümesi değişken, örnek pahalı ya da görev metin üretmeyi gerektiriyorsa soru tersine döner. Karşılaştırılan şey iki sayı değil, **iki bedel birimidir**. #### Özet - Eğiten yaklaşımın dört ayarından **üçü**, kullanan yaklaşımın dört ayarından **üçü** sayıyı 0,0200'den fazla oynatıyor; tohum da sayılınca kullanan tarafta beş satırdan dördü. İki listenin hiçbir maddesi ortak değildir. - Eğiten yaklaşımın en güçlü ayarı etiketli örnek sayısıdır: 8 örnekle 0,8194, 48 örnekle **0,9861**. Kullanan yaklaşım sıfır etiketli örnekle **0,8056** veriyor. - Kullanan yaklaşımın en güçlü ayarı biçim kısıtıdır: **+0,3056** ve **634 belirteç kazanç**. Bedel sütununda eksi işaretli tek satır budur. - Yeniden deneme sayıyı **0,0000** oynatıp bir çağrı ve 51 belirteç ekliyor: düzenek eklemek her zaman iyileştirmez, ama bedeli her zaman kesindir. - Elde olmayan tohum sayıyı **0,1250 düşürüyor** — elde olan dört ayardan ikisinden daha çok. - Sorumluluk sınırı son satırda okunur: sayı düştüğünde eğiten yaklaşım modeli, kullanan yaklaşım düzeneği değiştirir. #### Sonraki Adım Bu derste tohum satırı bir kez, tek bir sayıyla göründü ve orada bırakıldı. Oysa o satır bir ürünün en zor tasarım sorusudur: aynı kullanıcı, aynı ekranda, aynı metni iki kez gönderdiğinde iki ayrı yanıt alabilir. Toplam isabetin 0,8056'dan 0,6806'ya inmesi bunun yalnız **toplam** görünümüdür; kaç kayıtta yanıtın gerçekten değiştiği ve bu değişimin kullanıcıya **görünen** kısmının ne olduğu hiç sorulmadı. Sonraki ders aynı girdinin iki koşumunu kayıt kayıt sayar ve belirsizliği daraltan üç tasarım kararını — seçenek sunmak, biçim dayatmak, kaynağa bağlamak — isabet ve bedel olarak yan yana koyar. ### Ürün Geliştirmeye Etkisi Source: https://academia.sh/tr/kurslar/yz-muhendisligine-giris/urun-gelistirmeye-etkisi Belirsiz çıktıyla ürün tasarlamanın sayıyla ölçülmesi: aynı 72 kurgu destek talebi iki koşumda çağrıldığında yalın istemde yanıt metni kayıtların 0,7639 payında, altındaki karar ise 0,5000 payında değişiyor ve kayıtların 0,4167 payında doğru yanıt yalnız bir koşumda çıkıyor. Belirsizliği daraltan üç tasarım kararı yan yana ölçülüyor: biçim dayatmak görünen değişimi 0,7500'den 0,3889'a indiriyor, kaynağa bağlamak 0,0833'e indirip isabeti 0,8958'e çıkarıyor ve 144 erişim adımı ekliyor, seçenek sunmak ise değişimi 0,4583'e yükseltip çağrıyı iki katına çıkarıyor. Önceki ders tohum satırını tek bir sayıyla gösterdi: toplam isabet 0,8056'dan 0,6806'ya indi. O satır bir ürünün en zor tasarım sorusudur ve toplam sayı onu gizler. Aynı kullanıcı, aynı ekranda, aynı metni iki kez gönderdiğinde iki ayrı yanıt alabilir. Toplam isabetin aynı kalması bile bunu gizler, çünkü bir kayıtta kazanılan doğru yanıt başka bir kayıtta kaybedilmiş olabilir. Bu ders belirsizliği kayıt düzeyinde sayar ve iki soruyu ayırır: **çıktının kaç kayıtta değiştiği** ve **bu değişimin kullanıcıya görünen kısmının ne olduğu**. Ardından belirsizliği daraltan üç tasarım kararı aynı ölçüde karşılaştırılır. - **YA16.** Kurgu, benzetici ve sınama kümesi önceki dersten aynen sürer: 72 kayıt, beş konu, tohum **20260218**. İkinci koşum **20260219** tohumuyla alınır. - **YA17.** İki koşum arasında karşılaştırılan şey **ürünün gösterdiği çıktıdır**. Yalın istemde bu bir cümledir, yönergeli istemde tek bir etikettir; ikisi ayrı ayrı sayılır. - **YA18.** Kurgu belge dağarcığı on kayıttır: tarife açıklamaları, sayaç bakım yordamları ve arıza kodları. Belge kodları da kurgudur. - **YA19.** Erişim, talebin belirteçleriyle en çok örtüşen belgeyi seçer. Bir **adımdır**, model çağrısı değildir; bedel tablosunda ayrı sütunda sayılır. - **YA20.** Seçenek sunmanın isabeti **başka bir ölçütle** okunur: doğru etiketin iki adaydan birinde bulunması yeter. Öbür üç satırla aynı sütunda durur ama aynı şeyi ölçmez. - **YA21.** Görünen değişim **düşük olduğunda iyidir**; isabet yüksek olduğunda. İki sütunun yönü terstir ve tabloda birlikte okunur. - **YA22.** Hız sınırına takılan çağrılar her ölçümün başında sayaç sıfırlandığı için iki koşumda aynı yerlere düşer; değişim sayısı bu yüzden yalnız modelin belirsizliğinden gelir. #### Aynı Girdinin İki Koşumu İlk blok benzeticiyi kurar ve her talebi iki tohumla çağırıp dört sayıyı ayırır: metin değişti mi, karar değişti mi, iki koşumda da doğru mu, yalnız birinde mi doğru. ```python # BENZETICI. Bu kod gercek bir model uc noktasi cagirmaz; standart kitaplikla yazilmis # bir dil modeli benzeticisidir. Destek talepleri de KURGU'dur. import math TOHUM, M32 = 20260218, 0xFFFFFFFF PENCERE, EN_UZUN = 240, 24 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): 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): h = 2166136261 for c in m: h = ((h ^ ord(c)) * 16777619) & M32 return h KONU = ["fatura", "ariza", "sayac", "tarife", "kesinti"] KALIP = { "fatura": ["bu ayki fatura tutari gecen aya gore cok yuksek geldi", "faturami odedim ama sistemde borc gorunuyor", "fatura ayrintisini nereden gorebilirim"], "ariza": ["evde su akmiyor bir ariza var galiba", "baglanti bozuk oldu ve hic calismiyor", "ariza kaydi actim ama ekip gelmedi"], "sayac": ["sayac okumasi yanlis girilmis endeks tutmuyor", "sayac degisimi icin randevu istiyorum", "sayac uzerindeki endeks ile fatura ayni degil"], "tarife": ["hangi tarife basamagindayim ogrenmek istiyorum", "tarife degisikligi icin ne yapmam gerekiyor", "birim ucret abone tipine gore degisiyor mu"], "kesinti": ["mahallede kesinti var ne zaman gelecek", "planli kesinti duyurusu nereden takip edilir", "aksamdan beri kesinti yasiyoruz"], } EK = ["ayrica gecen ay da ayni sorun olmustu", "bu konuda memnun degilim", "acil bilgi almam gerekiyor", "kayit numaram elimde yok"] TALEP = [] for i in range(120): r = uretec(TOHUM + i) k = KONU[ayrik(r(), [0.24, 0.22, 0.18, 0.20, 0.16])] m = KALIP[k][int(r() * 3)] if r() < 0.34: m += " " + EK[int(r() * 4)] TALEP.append({"no": 4001 + i, "metin": m, "konu": k}) KAVRAM = KONU + ["odeme", "sikayet", "bilgi", "genel"] IZ = {"fatur": "fatura", "tutar": "fatura", "ayrin": "fatura", "ariza": "ariza", "bozuk": "ariza", "calis": "ariza", "akmiy": "ariza", "sayac": "sayac", "endek": "sayac", "okuma": "sayac", "tarif": "tarife", "birim": "tarife", "abone": "tarife", "basam": "tarife", "kesin": "kesinti", "duyur": "kesinti", "mahal": "kesinti", "borc": "odeme", "odedi": "odeme", "ucret": "odeme", "memnu": "sikayet", "sorun": "sikayet", "acil": "sikayet", "bilgi": "bilgi", "ogren": "bilgi", "nered": "bilgi"} TUZAK = {"degis": "tarife", "kayit": "ariza", "yukse": "tarife", "gorun": "fatura", "ekip": "kesinti", "takip": "tarife", "giril": "fatura"} SERBEST = ["talebiniz {k} konusuyla ilgili gorunuyor", "bu kayit {k} basligina girer , ilgili ekibe yonlendirildi", "kaydiniz alindi , konuyu inceleyip donus yapacagiz"] SAYAC = [0] def cagir(istem, tohum=TOHUM, sicaklik=0.6, en_uzun=EN_UZUN): SAYAC[0] += 1 bel = belirtecle(istem) if len(bel) > PENCERE: return {"durum": "baglam_asimi", "giris": len(bel), "cikis": 0, "yanit": ""} if SAYAC[0] % 37 == 0: return {"durum": "hiz_siniri", "giris": len(bel), "cikis": 0, "yanit": ""} r = uretec(tohum ^ izno(istem)) if len(bel) > 90 and r() < 0.04: return {"durum": "zaman_asimi", "giris": len(bel), "cikis": 0, "yanit": ""} aday = [k for k in KAVRAM if k[:5] in bel] if len(aday) < 3: aday = KAVRAM p = {k: 0.15 for k in aday} for t in bel: for tablo, w in ((IZ, 1.0), (TUZAK, 1.3)): if tablo.get(t) in p: p[tablo[t]] += w if sicaklik <= 0.0: k = max(sorted(p), key=lambda a: p[a]) else: e = [math.exp(p[a] / sicaklik) for a in sorted(p)] k = sorted(p)[ayrik(r(), [v / sum(e) for v in e])] y = k if "tek" in bel else SERBEST[ayrik(r(), [0.42, 0.26, 0.32])].format(k=k) cb = belirtecle(y) if len(cb) > en_uzun: cb = cb[:en_uzun] y = " ".join(cb) return {"durum": "tamam", "giris": len(bel), "cikis": len(cb), "yanit": y} def oku(y): for s in y.lower().split(): if s in KONU: return s return None SIN = TALEP[48:] YALIN = "Su destek talebini yanitla: " YONERGE = ("Talebi su etiketlerden birine ata: fatura , ariza , sayac , tarife , " "kesinti . Yanit olarak tek etiket yaz . Talep: ") def iki_kosum(onek): SAYAC[0] = 0 metin = karar = ikisi = biri = hicbiri = 0 for x in SIN: a = cagir(onek + x["metin"], tohum=TOHUM) b = cagir(onek + x["metin"], tohum=TOHUM + 1) ea, eb = oku(a["yanit"]), oku(b["yanit"]) metin += a["yanit"] != b["yanit"] karar += ea != eb d = (ea == x["konu"]) + (eb == x["konu"]) ikisi += d == 2 biri += d == 1 hicbiri += d == 0 n = len(SIN) return metin / n, karar / n, ikisi / n, biri / n, hicbiri / n print(f"{'istem':<10} {'metin degisti':>14} {'karar degisti':>14} {'ikisi dogru':>12} " f"{'yalniz biri':>12} {'ikisi yanlis':>13}") for ad, o in (("yalin", YALIN), ("yonergeli", YONERGE)): m, k, i2, b1, h = iki_kosum(o) print(f"{ad:<10} {m:>14.4f} {k:>14.4f} {i2:>12.4f} {b1:>12.4f} {h:>13.4f}") ``` ``` istem metin degisti karar degisti ikisi dogru yalniz biri ikisi yanlis yalin 0.7639 0.5000 0.3333 0.4167 0.2500 yonergeli 0.4167 0.4167 0.5417 0.3750 0.0833 ``` İlk satırda iki sütun arasındaki fark dersin ana bulgusudur. Yalın istemde **yanıt metni kayıtların 0,7639 payında değişiyor**, ama altındaki **karar yalnız 0,5000 payında** değişiyor. Aradaki 0,2639, kararın aynı kaldığı hâlde cümlenin başka kurulduğu kayıtlardır. Kullanıcının gördüğü şey cümleyse ürün iki kat kararsız görünür; gördüğü şey karar ise gerçek kararsızlık okunur. **Bir ürünün belirsizliği, modelin belirsizliği değil, ekrana koyduğu şeyin belirsizliğidir.** Dördüncü sütun ise ürün açısından en pahalı sayıdır. Yalın istemde kayıtların **0,4167 payında** doğru yanıt yalnız bir koşumda çıkıyor. Bu kayıtlarda kullanıcının doğru yanıt alıp almaması, görebildiği ya da değiştirebildiği hiçbir şeye bağlı değildir. Yönergeli istemde bu pay 0,3750'ye iniyor ve "iki koşumda da yanlış" payı 0,2500'den 0,0833'e düşüyor: yönerge doğruların sayısını artırmakla kalmıyor, **kalıcı yanlışları** da azaltıyor. Bu iki satırın ürün tasarımına üç doğrudan sonucu vardır. Birincisi, aynı talebin iki kez gönderilmesi bir hata değil beklenen davranıştır; yanıtı saklamak ve ikinci istekte saklanan yanıtı göstermek, isabeti hiç değiştirmeden görünen kararsızlığı sıfıra indirir. İkincisi, "yalnız birinde doğru" payı destek kaydına yazılmalıdır: bir yanlış yanıtın kalıcı mı yoksa koşuma bağlı mı olduğu ancak iki koşum saklanırsa ayırt edilir. Üçüncüsü, kullanıcıya gösterilen metnin serbest bırakılması bedava değildir; aynı kararı taşıyan iki ayrı cümle, kullanıcıya iki ayrı yanıt olarak görünür ve şikâyet sayısını kararın kendisinden bağımsız olarak büyütür. #### Belirsizliği Daraltan Üç Tasarım Kararı Üç karar aynı ölçüde karşılaştırılır: seçenek sunmak, biçim dayatmak, kaynağa bağlamak. Kaynağa bağlama için kurgu bir belge dağarcığı kurulur ve talebe en çok örtüşen belge isteme eklenir. ```python BELGE = [("TR-11", "tarife basamagi abone tipine ve birim ucrete gore belirlenir"), ("TR-12", "tarife degisikligi basvurusu her donem basinda alinir"), ("FT-21", "fatura tutari donem okumasi uzerinden hesaplanir , ayrinti ekranda"), ("FT-22", "odeme sonrasi borc kaydi ayni gun kapanir"), ("SY-31", "sayac endeks okumasi her donem alinir ve tutanaga gecer"), ("SY-32", "sayac degisimi randevu ile yapilir , eski endeks tutanakta kalir"), ("AR-41", "ariza kaydi acildiginda saha ekibi yonlendirilir"), ("AR-42", "bozuk baglanti icin once hat kontrolu yapilir"), ("KS-51", "planli kesinti duyurusu once yayimlanir"), ("KS-52", "mahalle bazinda kesinti takibi harita uzerinden yapilir")] def eris(metin): # ERISIM adimi: en cok parca ortusen belge b = set(belirtecle(metin)) return max(BELGE, key=lambda d: (len(b & set(belirtecle(d[1]))), d[0])) def kur(tasarim, x, tohum): # istemler ve erisim adimi sayisi if tasarim == "serbest": return [(YALIN + x["metin"], tohum)], 0 if tasarim == "secenek": return [(YONERGE + x["metin"], tohum + j) for j in (0, 2)], 0 if tasarim == "bicim": return [(YONERGE + x["metin"], tohum)], 0 k, m = eris(x["metin"]) return [(YONERGE + "Belge " + k + ": " + m + " . Talep: " + x["metin"], tohum)], 1 def kosum(tasarim, tohum): SAYAC[0] = 0 gor, dogru, bel, adim = [], 0, 0, 0 for x in SIN: istem, a = kur(tasarim, x, tohum) adim, e, son = adim + a, [], "" for i, th in istem: s = cagir(i, tohum=th) bel += s["giris"] + s["cikis"] e.append(oku(s["yanit"])) son = s["yanit"] ad = sorted(set(e) - {None}) gor.append(" ".join(ad) if tasarim == "secenek" else son) dogru += (x["konu"] in ad) if tasarim == "secenek" else (e[0] == x["konu"]) return gor, dogru / len(SIN), SAYAC[0], bel, adim print(f"{'tasarim karari':<18} {'degisim':>8} {'isabet':>8} {'cagri':>6} " f"{'belirtec':>9} {'erisim':>7}") for ad, t in (("duzeneksiz", "serbest"), ("bicim dayatmak", "bicim"), ("secenek sunmak", "secenek"), ("kaynaga baglamak", "kaynak")): g1, i1, c1, b1, a1 = kosum(t, TOHUM) g2, i2, c2, b2, a2 = kosum(t, TOHUM + 1) dg = sum(u != v for u, v in zip(g1, g2)) / len(g1) print(f"{ad:<18} {dg:>8.4f} {(i1 + i2) / 2:>8.4f} {c1 + c2:>6d} {b1 + b2:>9d} " f"{a1 + a2:>7d}") ``` ``` tasarim karari degisim isabet cagri belirtec erisim duzeneksiz 0.7500 0.5556 144 4473 0 bicim dayatmak 0.3889 0.7431 144 6674 0 secenek sunmak 0.4583 0.9306 288 13341 0 kaynaga baglamak 0.0833 0.8958 144 9459 144 ``` **Biçim dayatmak** en ucuz karardır: görünen değişimi 0,7500'den **0,3889'a** indiriyor, isabeti 0,5556'dan **0,7431'e** çıkarıyor ve çağrı sayısına hiç dokunmuyor. Bedeli yalnız 2201 belirteçtir ve bunun tamamı isteme yazılan yönergeden gelir. **Kaynağa bağlamak** en güçlü karardır: görünen değişim **0,0833'e** iniyor, yani kayıtların yalnız altı tanesinde iki koşum ayrışıyor. İsabet **0,8958**. Bunun nedeni belgenin isteme girmesiyle doğru konunun kanıtının ağır basması, yani kararın örneklemeye daha az kalmasıdır. Bedeli iki kalemdir: biçim dayatmaya göre 2785 fazla belirteç ve **144 erişim adımı**. Erişim bir model çağrısı değildir ama bir gecikme kaynağıdır ve kendi hatasını taşır — yanlış belge geldiğinde model **kararlı biçimde yanlış** yanıt verir. **Seçenek sunmak** bu tabloda müfredatın ikinci iddiasını ödeyen satırdır. İsabet sütununda en yüksek sayı onda: 0,9306. Ama o sayı başka bir ölçüttür — doğru etiketin iki adaydan birinde bulunması yeter ve seçme işi kullanıcıya bırakılır. Kendi ölçütünde, yani **görünen değişimde**, seçenek sunmak biçim dayatmayı **geriye götürüyor**: 0,3889'dan 0,4583'e. İki adaydan biri değiştiğinde ekrandaki kutu da değişir, dolayısıyla iki koşum arasında daha çok kayıtta ayrışma olur. Karşılığında çağrı sayısı **iki katına**, belirteç iki katına çıkıyor. **Eklenen düzenek sayıyı kötüleştirdi ve bedeli kesin biçimde arttı.** #### Özet - Yalın istemde yanıt metni kayıtların **0,7639** payında, altındaki karar ise **0,5000** payında değişiyor. Aradaki fark, ürünün ekrana ne koyduğuna göre kararsızlığın iki katı görünmesidir. - Kayıtların **0,4167** payında doğru yanıt yalnız bir koşumda çıkıyor. Bu pay kullanıcının göremediği ve etkileyemediği bir kayıptır; yönergeli istemde 0,3750'ye, kalıcı yanlış payı 0,2500'den **0,0833'e** iniyor. - Biçim dayatmak görünen değişimi **0,7500'den 0,3889'a**, isabeti **0,5556'dan 0,7431'e** taşıyor ve çağrı sayısını hiç değiştirmiyor; bedeli 2201 belirteçtir. - Kaynağa bağlamak değişimi **0,0833'e** indirip isabeti **0,8958** yapıyor; bedeli 2785 fazla belirteç ve **144 erişim adımıdır**. Yanlış belge geldiğinde yanlış yanıt kararlı hâle gelir. - Seçenek sunmak görünen değişimi **0,3889'dan 0,4583'e yükseltiyor** ve çağrıyı iki katına çıkarıyor; isabet sütunundaki 0,9306 başka bir ölçüttür ve seçme işini kullanıcıya devreder. - Gecikme sınıfı da ayrışıyor: düzeneksiz ve biçim dayatan yollar **tek çağrıdır**, kaynağa bağlamak **erişim ve çağrı zinciridir**, seçenek sunmak **iki paralel çağrıdır**. Dört satır tek bir kuralla okunur: bir tasarım kararı ancak **kendi ölçütünde** ve **bedeliyle** yazıldığında karşılaştırılabilir. #### Sonraki Adım Üç derste model verilmiş bir bileşen olarak ele alındı, yüzeyinden ölçüldü, ayarları sayıldı ve belirsizliği ürün diline çevrildi. Bu üç ders boyunca kullanılan sözcükler de bir tasarım nesnesidir. "Yetenek", "anlıyor", "öğreniyor", "genel zekâ" gibi ifadeler aynı tabloya yazılamayacak kadar farklı şeylerdir: bir kısmı bir sınamaya bağlanabilir ve bir sayı verir, bir kısmı hiçbir koşulda yanlışlanamaz. Sonraki ders bir dizi cümleyi bu ölçüte göre ayırır ve kaçının gerçekten bir sınamaya bağlanabildiğini sayar. ### Yapay Zekâ ve Genel Yapay Zekâ Ayrımı Source: https://academia.sh/tr/kurslar/yz-muhendisligine-giris/yapay-zeka-ve-genel-yapay-zeka-ayrimi Bir sistem hakkında kurulan cümlelerin sınanabilirliğe göre ayrılması: on dört kurgu iddianın beşi ölçülebilir yetenek iddiası, dokuzu ölçülemez genel iddia ve bunlardan biri sayı ile yön taşıdığı hâlde kümesi olmadığı için sınanamıyor. Sınamaya bağlanabilen pay 0,3571. Beş sınama benzetici üzerinde koşturuluyor ve üçü geçiyor: etiket isabeti 0,90 eşiğinde 0,8958 ile kalıyor, karar değişim payı 0,0833 ile geçiyor, etiketsiz yanıt payı 0,0556 ile kalıyor, belge getirme payı 0,9722 ile geçiyor, istek başına belirteç 65,7 ile geçiyor. Önceki üç ders modeli verilmiş bir bileşen olarak ele aldı, yüzeyinden ölçtü, ayarlarını saydı ve belirsizliğini ürün diline çevirdi. Bu üç derste kullanılan sözcükler de bir tasarım nesnesidir. "Yetenek", "anlıyor", "öğreniyor" ve "genel zekâ" aynı tabloya yazılamayacak kadar farklı şeylerdir: bir kısmı bir sınamaya bağlanabilir ve bir sayı verir, bir kısmı hiçbir koşulda yanlışlanamaz. Bu ders o ayrımı bir yordama bağlar. Bir dizi kurgu iddia cümlesi dört bileşene göre ayrıştırılır, sınanabilir olanlar seçilir ve **gerçekten koşturulur**. Ölçülen şey iddiaların doğruluğu değil, kaçının bir sınamaya **bağlanabildiğidir**. Dersin sonunda bir tanesi bağlanır, koşturulur ve yanlış çıkar; bu, bir iddianın ölçülebilir olmasının onu doğru yapmadığını gösterir. - **YA23.** Bir iddia dört bileşen taşıdığında **sınanabilir** sayılır: bir **görev**, bir **ölçüt**, bir **küme** ve yönüyle birlikte bir **eşik**. Dördünden biri eksikse iddia genel sayılır. Bu bir karardır ve ders boyunca sabit tutulur. - **YA24.** Bileşenler cümlenin belirteçlerinden okunur; sınıflandırma elle yapılmaz, koşan bir yordamdır. Belirteçleyici önceki derslerden aynen sürer. - **YA25.** İddia cümleleri **kurgudur** ve hiçbiri bir ürün, model ya da kurum hakkında değildir; hepsi önceki üç derste kurulan kurgu destek yardımcısı hakkındadır. - **YA26.** Sınanan sistem, önceki dersin en güçlü düzeneğidir: kaynağa bağlanmış yönergeli çağrı. Ölçüm 72 kayıtlık sınama kümesinde ve iki koşumda yapılır. - **YA27.** Bir sınama yalnız sınıflandırma onu ölçülebilir bulduğunda koşar. Genel iddialar için sınama yazılmaz, çünkü yazılacak bir sınama yoktur. - **YA28.** Eşiğin yönü iddianın parçasıdır. Eşiksiz bir ölçüt bir sayı verir ama bir **karar** vermez; iddia ancak yönüyle birlikte geçer ya da kalır. #### Bir İddia Ne Zaman Sınanabilir "Sistem destek taleplerini anlar" cümlesi hiçbir koşulda yanlışlanamaz, çünkü hangi görevde, hangi küme üzerinde, hangi sayıyla ve hangi eşikte anlaşılmış sayılacağı yazılmamıştır. "72 kayıtlık kümede etiket isabeti 0,90 üzerindedir" cümlesi ise yanlışlanabilir. İkisinin farkı doğruluk değil **bağlanabilirliktir**. ```python # BENZETICI. Bu kod gercek bir model uc noktasi cagirmaz; standart kitaplikla yazilmis # bir dil modeli benzeticisidir. Destek talepleri ve iddialar da KURGU'dur. import math TOHUM, M32 = 20260218, 0xFFFFFFFF PENCERE, EN_UZUN = 240, 24 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): 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): h = 2166136261 for c in m: h = ((h ^ ord(c)) * 16777619) & M32 return h KONU = ["fatura", "ariza", "sayac", "tarife", "kesinti"] KALIP = { "fatura": ["bu ayki fatura tutari gecen aya gore cok yuksek geldi", "faturami odedim ama sistemde borc gorunuyor", "fatura ayrintisini nereden gorebilirim"], "ariza": ["evde su akmiyor bir ariza var galiba", "baglanti bozuk oldu ve hic calismiyor", "ariza kaydi actim ama ekip gelmedi"], "sayac": ["sayac okumasi yanlis girilmis endeks tutmuyor", "sayac degisimi icin randevu istiyorum", "sayac uzerindeki endeks ile fatura ayni degil"], "tarife": ["hangi tarife basamagindayim ogrenmek istiyorum", "tarife degisikligi icin ne yapmam gerekiyor", "birim ucret abone tipine gore degisiyor mu"], "kesinti": ["mahallede kesinti var ne zaman gelecek", "planli kesinti duyurusu nereden takip edilir", "aksamdan beri kesinti yasiyoruz"], } EK = ["ayrica gecen ay da ayni sorun olmustu", "bu konuda memnun degilim", "acil bilgi almam gerekiyor", "kayit numaram elimde yok"] TALEP = [] for i in range(120): r = uretec(TOHUM + i) k = KONU[ayrik(r(), [0.24, 0.22, 0.18, 0.20, 0.16])] m = KALIP[k][int(r() * 3)] if r() < 0.34: m += " " + EK[int(r() * 4)] TALEP.append({"no": 4001 + i, "metin": m, "konu": k}) KAVRAM = KONU + ["odeme", "sikayet", "bilgi", "genel"] IZ = {"fatur": "fatura", "tutar": "fatura", "ayrin": "fatura", "ariza": "ariza", "bozuk": "ariza", "calis": "ariza", "akmiy": "ariza", "sayac": "sayac", "endek": "sayac", "okuma": "sayac", "tarif": "tarife", "birim": "tarife", "abone": "tarife", "basam": "tarife", "kesin": "kesinti", "duyur": "kesinti", "mahal": "kesinti", "borc": "odeme", "odedi": "odeme", "ucret": "odeme", "memnu": "sikayet", "sorun": "sikayet", "acil": "sikayet", "bilgi": "bilgi", "ogren": "bilgi", "nered": "bilgi"} TUZAK = {"degis": "tarife", "kayit": "ariza", "yukse": "tarife", "gorun": "fatura", "ekip": "kesinti", "takip": "tarife", "giril": "fatura"} SERBEST = ["talebiniz {k} konusuyla ilgili gorunuyor", "bu kayit {k} basligina girer , ilgili ekibe yonlendirildi", "kaydiniz alindi , konuyu inceleyip donus yapacagiz"] SAYAC = [0] def cagir(istem, tohum=TOHUM, sicaklik=0.6, en_uzun=EN_UZUN): SAYAC[0] += 1 bel = belirtecle(istem) if len(bel) > PENCERE: return {"durum": "baglam_asimi", "giris": len(bel), "cikis": 0, "yanit": ""} if SAYAC[0] % 37 == 0: return {"durum": "hiz_siniri", "giris": len(bel), "cikis": 0, "yanit": ""} r = uretec(tohum ^ izno(istem)) if len(bel) > 90 and r() < 0.04: return {"durum": "zaman_asimi", "giris": len(bel), "cikis": 0, "yanit": ""} aday = [k for k in KAVRAM if k[:5] in bel] if len(aday) < 3: aday = KAVRAM p = {k: 0.15 for k in aday} for t in bel: for tablo, w in ((IZ, 1.0), (TUZAK, 1.3)): if tablo.get(t) in p: p[tablo[t]] += w if sicaklik <= 0.0: k = max(sorted(p), key=lambda a: p[a]) else: e = [math.exp(p[a] / sicaklik) for a in sorted(p)] k = sorted(p)[ayrik(r(), [v / sum(e) for v in e])] y = k if "tek" in bel else SERBEST[ayrik(r(), [0.42, 0.26, 0.32])].format(k=k) cb = belirtecle(y) if len(cb) > en_uzun: cb = cb[:en_uzun] y = " ".join(cb) return {"durum": "tamam", "giris": len(bel), "cikis": len(cb), "yanit": y} def oku(y): for s in y.lower().split(): if s in KONU: return s return None IDDIA = [("72 kayitlik kumede etiket isabeti 0,90 uzerindedir", "isabet", 0.90, ">"), ("sistem destek taleplerini anlar", "", 0, ""), ("72 kayitlik kumede karar degisim payi 0,10 altindadir", "degisim", 0.10, "<"), ("sistem akilli bir yardimcidir", "", 0, ""), ("sistem her zaman dogru etiketi uretir", "", 0, ""), ("sistem insan seviyesinde dil anlayisina sahiptir", "", 0, ""), ("72 kayitlik kumede etiketsiz yanit payi 0,05 altindadir", "bos", 0.05, "<"), ("sistem genel zekaya sahiptir", "", 0, ""), ("sistem istek basina 140 belirtecin altinda kalir", "", 0, ""), ("dagarcikta dogru belge getirme payi 0,80 uzerindedir", "belge", 0.80, ">"), ("sistem ogrenmeye devam eder", "", 0, ""), ("72 kayitlik kumede istek basina belirtec 140 altindadir", "birim", 140, "<"), ("sistem yaratici cozumler uretir", "", 0, ""), ("sistem gelistikce daha akilli olur", "", 0, "")] GOREV = ("etike", "karar", "yanit", "getir", "istek") OLCUT = ("isabe", "pay", "belir", "cagri", "adim") KUME = ("kayit", "kume", "dagar", "ornek") YON = ("uzeri", "altin") def gecer(bel, sozluk): return any(t.startswith(k) for t in bel for k in sozluk) def sinif(c): b = belirtecle(c) return (gecer(b, GOREV), gecer(b, OLCUT), gecer(b, KUME), gecer(b, YON) and any(any(d.isdigit() for d in t) for t in b)) print(f"{'iddia':<56} {'gorev':>5} {'olcut':>5} {'kume':>4} {'esik':>4} {'sinif':>11}") SINAV = [] for c, olcu, esik, yon in IDDIA: g, o, k, e = sinif(c) if g and o and k and e: SINAV.append((olcu, esik, yon)) print(f"{c:<56} {'+' if g else '-':>5} {'+' if o else '-':>5} {'+' if k else '-':>4} " f"{'+' if e else '-':>4} {'olculebilir' if g and o and k and e else 'genel':>11}") sayili = sum(1 for c, *_ in IDDIA if sinif(c)[3]) print(f"\nsinamaya baglanabilen {len(SINAV)}/{len(IDDIA)} = {len(SINAV) / len(IDDIA):.4f}, " f"sayi ve yon tasiyip yine de baglanamayan {sayili - len(SINAV)}") ``` ``` iddia gorev olcut kume esik sinif 72 kayitlik kumede etiket isabeti 0,90 uzerindedir + + + + olculebilir sistem destek taleplerini anlar - - - - genel 72 kayitlik kumede karar degisim payi 0,10 altindadir + + + + olculebilir sistem akilli bir yardimcidir - - - - genel sistem her zaman dogru etiketi uretir + - - - genel sistem insan seviyesinde dil anlayisina sahiptir - - - - genel 72 kayitlik kumede etiketsiz yanit payi 0,05 altindadir + + + + olculebilir sistem genel zekaya sahiptir - - - - genel sistem istek basina 140 belirtecin altinda kalir + + - + genel dagarcikta dogru belge getirme payi 0,80 uzerindedir + + + + olculebilir sistem ogrenmeye devam eder - - - - genel 72 kayitlik kumede istek basina belirtec 140 altindadir + + + + olculebilir sistem yaratici cozumler uretir - - - - genel sistem gelistikce daha akilli olur - - - - genel sinamaya baglanabilen 5/14 = 0.3571, sayi ve yon tasiyip yine de baglanamayan 1 ``` On dört cümlenin **beşi** sınamaya bağlanabiliyor; pay **0,3571**. Kalan dokuzun sekizi dört bileşenin hiçbirini ya da yalnız birini taşıyor. Beşinci satır bunların en öğreticisidir: "sistem her zaman doğru etiketi üretir" bir görev adı taşıyor ama ne ölçüt, ne küme, ne eşik veriyor. "Her zaman" bir eşik değildir; hangi kümede sınanacağı yazılmadığı için tek bir karşı örnek onu çürütür, bu yüzden kimse onu sınamaz. Son satırdaki sayı asıl ayrımı veriyor: **bir iddia sayı taşıyor olabilir ve yine de sınanamayabilir**. Dokuzuncu cümle "istek başına 140 belirtecin altında kalır" diyor; görevi, ölçütü, eşiği ve yönü var, ama **kümesi yok**. Hangi taleplerde, hangi düzenekle, hangi uzunlukta istemlerle ölçüldüğü yazılmadığı için sayı istenen değeri alacak biçimde üretilebilir. On ikinci satır aynı iddiaya kümeyi ekliyor ve cümle sınanabilir hâle geliyor. Aradaki tek fark **72 kayıtlık kümede** ifadesidir. #### Sınamalar Koşturuluyor Sınıflandırma bir cümlenin sınanabilir olduğunu söyler, doğru olduğunu söylemez. İkinci blok beş sınamayı önceki dersin en güçlü düzeneği üzerinde koşturur. ```python BELGE = [("TR-11", "tarife basamagi abone tipine ve birim ucrete gore belirlenir"), ("TR-12", "tarife degisikligi basvurusu her donem basinda alinir"), ("FT-21", "fatura tutari donem okumasi uzerinden hesaplanir , ayrinti ekranda"), ("FT-22", "odeme sonrasi borc kaydi ayni gun kapanir"), ("SY-31", "sayac endeks okumasi her donem alinir ve tutanaga gecer"), ("SY-32", "sayac degisimi randevu ile yapilir , eski endeks tutanakta kalir"), ("AR-41", "ariza kaydi acildiginda saha ekibi yonlendirilir"), ("AR-42", "bozuk baglanti icin once hat kontrolu yapilir"), ("KS-51", "planli kesinti duyurusu once yayimlanir"), ("KS-52", "mahalle bazinda kesinti takibi harita uzerinden yapilir")] KOD = {"TR": "tarife", "FT": "fatura", "SY": "sayac", "AR": "ariza", "KS": "kesinti"} SIN = TALEP[48:] YONERGE = ("Talebi su etiketlerden birine ata: fatura , ariza , sayac , tarife , " "kesinti . Yanit olarak tek etiket yaz . Talep: ") def eris(m): b = set(belirtecle(m)) return max(BELGE, key=lambda d: (len(b & set(belirtecle(d[1]))), d[0])) def kosum(tohum): SAYAC[0] = 0 e, bel, belge = [], 0, 0 for x in SIN: k, m = eris(x["metin"]) belge += KOD[k[:2]] == x["konu"] s = cagir(YONERGE + "Belge " + k + ": " + m + " . Talep: " + x["metin"], tohum=tohum) bel += s["giris"] + s["cikis"] e.append(oku(s["yanit"])) return e, bel, belge / len(SIN) e1, b1, bg = kosum(TOHUM) e2, b2, _ = kosum(TOHUM + 1) n = len(SIN) O = {"isabet": sum((a == x["konu"]) + (b == x["konu"]) for a, b, x in zip(e1, e2, SIN)) / (2 * n), "degisim": sum(a != b for a, b in zip(e1, e2)) / n, "bos": sum((a is None) + (b is None) for a, b in zip(e1, e2)) / (2 * n), "belge": bg, "birim": (b1 + b2) / (2 * n)} print(f"{'sinama':<12} {'esik':>12} {'olculen':>10} {'sonuc':>8}") gecti = 0 for olcu, esik, yon in SINAV: v = O[olcu] ok = v > esik if yon == ">" else v < esik gecti += ok b = "{:.4f}" if esik < 1 else "{:.1f}" print(f"{olcu:<12} {yon + ' ' + b.format(esik):>12} {b.format(v):>10} " f"{'gecti' if ok else 'kaldi':>8}") print(f"\nsinanan {len(SINAV)}, gecen {gecti}, kalan {len(SINAV) - gecti}; " f"genel iddialarda sinanan 0") ``` ``` sinama esik olculen sonuc isabet > 0.9000 0.8958 kaldi degisim < 0.1000 0.0833 gecti bos < 0.0500 0.0556 kaldi belge > 0.8000 0.9722 gecti birim < 140.0 65.7 gecti sinanan 5, gecen 3, kalan 2; genel iddialarda sinanan 0 ``` Beş sınamanın üçü geçti, ikisi kaldı. İlk satır dersin en önemli sonucudur: iddia **0,90** diyordu, ölçüm **0,8958** verdi. Fark 0,0042 ve iddia yanlıştır. Ölçülebilir bir iddia yanlış çıkabilir, hatta çoğunlukla kıl payıyla yanlış çıkar; **onu değerli kılan doğru olması değil, yanlış çıkabilmesidir**. Üçüncü satır aynı şeyi başka bir kaynaktan gösteriyor: etiketsiz yanıt payı 0,0556 ölçüldü, çünkü hız sınırına takılan çağrılar hiç yanıt üretmedi. İddia yalnız modelin biçim davranışını düşünüyordu, ölçüm **yüzeyin tamamını** getirdi. Son satır ise dersin sessiz sonucudur. Genel iddialarda sınanan sayı **sıfırdır**. Dokuz cümle hakkında hiçbir şey söylenemedi — ne geçti ne kaldı. Bir sistemin "genel zekâya sahip olduğu" ya da "geliştikçe daha akıllı olduğu" iddiası, karşı örnek üretilemediği için tartışılamaz; bir mühendislik belgesinde yeri yoktur, çünkü hiçbir kararı değiştirmez. **Genel yapay zekâ terimi bir yetenek sınıfı değil, bir sınama eksikliğidir.** Bir sistemin ne yaptığını söylemek isteyen cümle görevini, kümesini, ölçütünü ve eşiğini yazmak zorundadır; yazmadığında söylediği şey ölçülemez. #### Özet - Bir iddia dört bileşenle sınanabilir olur: görev, ölçüt, küme ve yönüyle birlikte eşik. On dört kurgu cümlenin **beşi** bu dördünü taşıyor; pay **0,3571**. - Sayı taşımak yetmiyor. "İstek başına 140 belirtecin altında kalır" cümlesi görev, ölçüt ve eşik taşıyor ama **kümesi yok**; aynı cümleye "72 kayıtlık kümede" eklendiğinde sınanabilir oluyor. - Beş sınama koşturuldu: **üçü geçti, ikisi kaldı**. Karar değişim payı 0,0833, belge getirme payı 0,9722, istek başına belirteç 65,7 eşikleri geçti. - Ölçülebilir bir iddia yanlış da çıkar: etiket isabeti iddiası 0,90 diyordu, ölçüm **0,8958** verdi. Etiketsiz yanıt payı 0,0556 çıktı, çünkü hız sınırı da yüzeyin bir parçasıdır. - Genel iddialarda sınanan sayı **sıfırdır**. Genel yapay zekâ terimi bir yetenek sınıfı değil, bir sınama eksikliğidir; mühendislik belgesinde hiçbir kararı değiştirmez. #### Sonraki Adım Dört derste modele hep **dışarıdan** bakıldı. Ölçüsü kuruldu, ayarlarının kimde olduğu sayıldı, belirsizliği ürün diline çevrildi ve hakkında kurulan cümleler sınanabilirliğe göre ayrıldı. Bunların hepsi kapalı kutunun yüzeyinde yapıldı ve bu bilinçli bir tercihti. Ama yüzeyde ölçülen her sayının bir nedeni vardır ve o neden içeridedir: 0,8958 niçin 1,0000 değil, "sayaç değişimi" ile "tarife değişikliği" niçin karışıyor, altı sözcüklük bir talep niçin on bir belirteç ediyor, pencere niçin 240'ta bitiyor. Sonraki konu bu sorularla açılır: modelin çalıştığı **birim** nedir, uzak bağlamı nasıl kullanır, sınırı nereden gelir ve bir yanıt hangi adımlarla üretilir. ## Dil Modellerinin Çalışma Biçimi Verilmiş bir dil modelinin dışarıya verdiği yüzeyin ölçülmesi: aynı Türkçe metnin ettiği belirteç sayısı ve eklemeli yapının bunu büyütmesi, dikkatin uzak bağlamı kullanabilmesinin karşılaştırma sayısı olarak maliyeti, bir görev kümesinin önceden eğitimde ve ince ayarda kaç örnekle düzeldiği, en olası seçimle örneklemeli seçimin aynı istemde iki koşumda verdiği, bağlam penceresi aşıldığında baştan atma, ortadan atma ve özetlemenin kazandırdığı belirteçle düşürdüğü isabet, sayma ve kesin hesap görevlerinde düzeneksiz çağrının çökmesi, kaynaksız yanıtta belgeye dayanmayan iddia oranı ve üç azaltmanın bedeli, açık ile kapalı ağırlıklı erişimin üç ölçütte karşılaştırılması, ölçüt ağırlığı değiştikçe değişen model seçimi ve dört düzeneğin belirteç ile isabet karşılaştırması. ### Belirteçler Source: https://academia.sh/tr/kurslar/yz-muhendisligine-giris/belirtecler Metnin modele giriş biriminin bir bedel birimi olarak ölçülmesi: 300 kurgu destek talebi 4.674 sözcük ve 8.334 belirteç ediyor, sözcük başına 1,7831; ek parçaları düşülünce 6.176 belirteç kalıyor ve eklerin payı 0,2589 çıkıyor. Altı kök yalın hâlde 6 belirteç, çoğul ve iyelik ekleri bindikçe 30 belirteç oluyor. Çıplak çağrı talep başına 27,78 belirteç ve 0,9722 alan isabeti verirken sık parçaları atan düzenek 0,50 eşiğinde 11,68 belirteçle aynı isabeti koruyor, 0,30 eşiğinde 6,23 belirtece iniyor ama isabet 0,8611'e düşüyor. Alan ve Roller konusu dört derste modele dışarıdan baktı: kimin neyi kurduğu, eğiten ile kullanan yaklaşımın elinde kaç ayar olduğu, aynı girdinin iki koşumda ne verdiği ve hangi iddianın bir sınamaya bağlanabildiği. Dördünde de model bir kutuydu ve kutunun kapağı hiç açılmadı. İçeride ne olduğu, hangi birimle çalıştığı ve sınırının nereden geldiği hiç sorulmadı. Bu konu o soruyla açılır ve en alttan başlar. Bir dil modeline metin göndermek, aslında metni göndermek değildir: metin önce parçalara bölünür, her parça bir numaraya çevrilir ve model yalnız o numara dizisini görür. Bu parçaya **belirteç** (token) denir. Belirteç bir teknik ayrıntı değil, bu müfredatın **bedel birimidir**: pencere belirteçle ölçülür, ücret belirteçle sayılır, gecikme üretilen belirteç sayısıyla büyür. Kursun kuralı burada ilk kez işler — verilmiş bir bileşen **yüzeyinden** ölçülür ve bu dersin ölçtüğü yüzey belirteç sayısıdır. - **DL1.** Destek talepleri **kurgudur**: ders içinde üretilir, tohum 20260218, hiçbir kaynak sistemden gelmez. Küme 300 kısa Türkçe taleptir. - **DL2.** Model bir **benzeticidir**: ders içinde standart kitaplıkla yazılır, gerçek bir model uç noktası çağrılmaz. Taşıdığı yüzey belirteçleme, belirteç sayımı, bağlam penceresi, durdurma koşulu, en büyük çıktı uzunluğu ve tohuma bağlı belirsizliktir. - **DL3.** Belirteçleyici de kurgudur: 177 parçalık bir sözlük ve soldan en uzun eşleşme. Belirteçleme yordamı, sözlük ve sözlük dışı kavramları M27'nin doğal dil işleme kursunda ölçüldü; yordam burada **tekrarlanmaz**, yalnız bedel birimi olarak okunur. - **DL4.** Sözlükte karşılığı olmayan dizi tek karakterlere iner. Bu benzeticide sözlük dışı yoktur; bilinmeyenin bedeli belirteç sayısı olarak ödenir. - **DL5.** Her talebin bir **alan üçlüsü** vardır: nesne, durum, istek. Üçlü kurgunun kendisinden bilinir; okuyucu yordam belirteç dizisinde ilk eşleşen kökü alır. - **DL6.** Ölçüt her satırda aynıdır: **talep başına belirteç** (küçük iyi) ve **alan isabeti** (büyük iyi). - **DL7.** **Çıplak çağrı** bu derste talebin olduğu gibi gönderilmesidir; düzenek, gönderilmeden önce metne uygulanan her işlemdir. - **DL8.** Giriş belirteci koşumdan bağımsızdır: aynı metin her koşumda aynı sayıyı verir. Çıkış uzunluğu bağımsız değildir. #### Metnin Modele Giriş Birimi Benzeticinin belirteçleyicisi küçük bir parça sözlüğü taşır: alanın sık kökleri, sık ekler ve tek karakterler. Bir sözcük soldan taranır, her adımda sözlükte bulunan en uzun parça alınır, hiçbiri bulunmazsa tek karakter alınır. Noktalama kendi başına bir belirteçtir. ```python # BENZETICI — bu kursta model, ders icinde standart kitaplikla yazilmis bir # benzeticidir; gercek bir model uc noktasi cagrilmaz. Destek talepleri KURGUDUR # ve ders icinde uretilir, tohum 20260218. TOHUM, M32, TALEP = 20260218, 0xFFFFFFFF, 300 KOK = """sayac kapak muhur vana abone adres fatura tarife odeme borc ariza kod okuma olcum servis ekip ziyaret kayit talep destek hat bakim birim gun ay yil saat numara bilgi islem sistem hata sonuc deger endeks sozlesme kampanya indirim gecikme faiz itiraz basvuru sikayet cevap bekle gonder geri ac kapa oku yaz bul bak gel ver yap don calis bozuk kirik eksik normal yuksek dusuk yeni eski acik kapali lutfen merhaba tesekkur iyi rica eder mumkun tekrar hala durum konu 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") NOKTA = ".,:;?-/" 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 parcala(s): p, i = [], 0 while i < len(s): for j in range(min(len(s), i + 9), i, -1): if s[i:j] in PARCA: p.append(s[i:j]) i = j break else: p.append(s[i]) i += 1 return p def belirtecle(metin): b, g = [], "" for c in metin.lower(): if c.isalnum(): g += c else: if g: b += parcala(g) g = "" if c in NOKTA: b.append(c) return b + (parcala(g) if g else []) NESNE = {"fatura": ("faturamizin", ["yuksek", "yuksek", "eksik"]), "tarife": ("tarifemizin", ["yuksek", "eski", "yuksek"]), "endeks": ("endeksimizin", ["yuksek", "dusuk", "eksik"]), "sayac": ("sayacimizin", ["bozuk", "kirik", "eski"]), "kapak": ("kapaginin", ["kirik", "eksik", "acik"]), "vana": ("vananin", ["kapali", "bozuk", "acik"]), "hat": ("hattimizin", ["kapali", "bozuk", "eski"]), "odeme": ("odememizin", ["eksik", "gecikmeli", "yuksek"])} NESNE_AGIRLIK = [0.20, 0.14, 0.12, 0.14, 0.10, 0.09, 0.11, 0.10] ISTEK = {"gonder": "ekip gonderin", "ac": "kayit acin", "ver": "bilgi verin", "don": "geri donun"} KALIP = ["{a} {n} durumu {d} ve bu konuda hala bir cevap yok. {i} lutfen. {k}.", "{a} {n} durumu {d} ve tekrar yazdim ama sonuc yok. {i} lutfen. {k}.", "{a} {n} durumu {d} ve bu ay ikinci basvurum. {i} lutfen. {k}."] ACILIS = ["Merhaba,", "Iyi gunler,", "Merhaba,", "Iyi gunler,"] KAPANIS = ["Tesekkur ederim", "Rica ederim", "Tesekkur ederim", "Iyi gunler"] NESNE_AD, ISTEK_KOK = list(NESNE), list(ISTEK) VERI = [] for i in range(TALEP): r = uretec(TOHUM + i) n = NESNE_AD[ayrik(r(), NESNE_AGIRLIK)] uzun_ad, durumlar = NESNE[n] d = durumlar[int(r() * 3)] k = ISTEK_KOK[int(r() * 4)] metin = KALIP[int(r() * 3)].format(a=ACILIS[int(r() * 4)], n=uzun_ad, d=d, i=ISTEK[k], k=KAPANIS[int(r() * 4)]) VERI.append({"metin": metin, "alan": (n, belirtecle(d)[0], k)}) print(f"{TALEP} kurgu destek talebi, benzeticinin sozlugu {len(PARCA)} parca") for i in (0, 2, 7): b = belirtecle(VERI[i]["metin"]) print(f"\n{VERI[i]['metin']}") print(f" {len(VERI[i]['metin'].split())} sozcuk, {len(b)} belirtec") print(" " + " ".join(b[:12]) + " ...") ``` ``` 300 kurgu destek talebi, benzeticinin sozlugu 177 parca Iyi gunler, odememizin durumu gecikmeli ve tekrar yazdim ama sonuc yok. geri donun lutfen. Iyi gunler. 16 sozcuk, 29 belirtec iyi gun ler , odeme miz in durum u gecikme li ve ... Merhaba, tarifemizin durumu yuksek ve bu konuda hala bir cevap yok. kayit acin lutfen. Iyi gunler. 16 sozcuk, 26 belirtec merhaba , tarife miz in durum u yuksek ve bu konu da ... Iyi gunler, vananin durumu bozuk ve bu konuda hala bir cevap yok. ekip gonderin lutfen. Tesekkur ederim. 17 sozcuk, 27 belirtec iyi gun ler , vana nin durum u bozuk ve bu konu ... ``` On altı sözcüklük bir talep 29 belirteç ediyor. Fark tek yerden gelmiyor: noktalama ayrı sayılıyor, `odememizin` üç parçaya bölünüyor, `gecikmeli` ikiye. Bir metnin uzunluğunu sözcükle tahmin etmek, bu birimde sistematik olarak eksik saymaktır. #### Eklemeli Yapının Bedeli Türkçe eklemeli bir dildir: bir köke ardışık ekler binerek tek sözcükte bir cümle kurulabilir. Bu, okuyan için kısalık, belirteç sayan için bedeldir. Altı kök altı çekim basamağında ölçülür. ```python BICIM = { "sayac": "sayac sayaclar sayacimiz sayacimizin sayaclarimizin sayaclarimizdaki", "kapak": "kapak kapaklar kapagimiz kapaginin kapaklarimizin kapaklarimizdaki", "fatura": "fatura faturalar faturamiz faturamizin faturalarimizin faturalarimizdaki", "odeme": "odeme odemeler odememiz odememizin odemelerimizin odemelerimizdeki", "tarife": "tarife tarifeler tarifemiz tarifemizin tarifelerimizin tarifelerimizdeki", "abone": "abone aboneler abonemiz abonemizin abonelerimizin abonelerimizdeki", } BASLIK = ("yalin", "cogul", "iyel", "iyel+", "cog+", "cog++") print(f"{'kok':<8} " + " ".join(f"{b:>5}" for b in BASLIK)) top = [0] * 6 for k, s in BICIM.items(): n = [len(belirtecle(b)) for b in s.split()] top = [a + b for a, b in zip(top, n)] print(f"{k:<8} " + " ".join(f"{x:>5}" for x in n)) print(f"{'toplam':<8} " + " ".join(f"{x:>5}" for x in top)) sozcuk = sum(len(x["metin"].split()) for x in VERI) bel = sum(len(belirtecle(x["metin"])) for x in VERI) kok_bel = sum(len([b for b in belirtecle(x["metin"]) if b not in EK]) for x in VERI) print(f"\n{TALEP} talep: {sozcuk} sozcuk, {bel} belirtec, oran {bel / sozcuk:.4f}") print(f"ek parcalari dusulunce {kok_bel} belirtec, oran {kok_bel / sozcuk:.4f}") print(f"eklerin payi {(bel - kok_bel) / bel:.4f}") ``` ``` kok yalin cogul iyel iyel+ cog+ cog++ sayac 1 2 2 3 4 5 kapak 1 2 3 4 4 5 fatura 1 2 2 3 4 5 odeme 1 2 2 3 4 5 tarife 1 2 2 3 4 5 abone 1 2 2 3 4 5 toplam 6 12 13 19 24 30 300 talep: 4674 sozcuk, 8334 belirtec, oran 1.7831 ek parcalari dusulunce 6176 belirtec, oran 1.3214 eklerin payi 0.2589 ``` Altı kök yalın hâlde 6 belirteç, tam çekimli hâlde 30 belirteç: aynı altı kavram beş katına çıkıyor. Sözcük sayısı hiç değişmedi, değişen tek şey eklerdir. `kapak` satırı bir ayrıntıyı da gösteriyor: `kapagimiz` biçiminde ünsüz yumuşadığı için kök artık sözlükteki `kapak` parçasıyla eşleşmiyor ve bir belirteç fazla ödeniyor. Küme düzeyinde oran 1,7831'dir: her sözcük ortalama 1,78 belirteç ediyor. Ek parçaları dizinden düşüldüğünde 8.334 belirteç 6.176'ya iniyor; **eklerin payı 0,2589**. Aynı bilgiyi eklemeli olmayan bir dilde yazmak bu payı büyük ölçüde silerdi. Bu, dil hakkında bir yargı değil, bir **bütçe bilgisidir**: aynı pencere Türkçe metnin daha azını alır. #### Aynı Bilgi Kısaltıldığında Talebin taşıdığı bilgi üç alandır: nesne, durum, istek. Nezaket kalıpları, bağlaçlar ve tekrar cümleleri bu üçünü değiştirmez ama belirteç öder. Bir düzenek kurulabilir: **belge sıklığı** bir eşiği aşan parçaları at. Sık geçen parça ayırt etmez, seyrek geçen eder. ```python BELGE = [belirtecle(x["metin"]) for x in VERI] df = {} for b in BELGE: for t in set(b): df[t] = df.get(t, 0) + 1 / TALEP DURUM_KOK = {belirtecle(d)[0] for _, ds in NESNE.values() for d in ds} def alan_oku(b): def ilk(kume): return next((t for t in b if t in kume), None) return (ilk(set(NESNE_AD)), ilk(DURUM_KOK), ilk(set(ISTEK_KOK))) def kisalt(b, esik): return [t for t in b if df[t] < esik] def cagir(belirtec, tohum, en_buyuk=40): """Benzetici adim adim uretir; durdurma kosuluna ya da en buyuk cikti uzunluguna varinca durur. Cikis uzunlugu tohuma baglidir.""" r, taban, y = uretec(tohum + len(belirtec)), 6 + len(belirtec) // 3, 0 while y < en_buyuk and (y < taban or r() >= 0.32): y += 1 return {"giris": len(belirtec), "cikis": y, "durdurma": "sinir" if y == en_buyuk else "kosul"} def olc(ad, bl): dogru = sum(sum(a == b for a, b in zip(alan_oku(b), VERI[i]["alan"])) for i, b in enumerate(bl)) g = sum(len(b) for b in bl) print(f"{ad:<26} {g:>6} {g / TALEP:>8.2f} {dogru / (3 * TALEP):>8.4f}") print(f"{'duzenek':<26} {'belirtec':>6} {'talep':>8} {'alan':>8}") olc("ciplak cagri", BELGE) olc("sik parcayi at (0,50)", [kisalt(b, 0.50) for b in BELGE]) olc("sik parcayi at (0,30)", [kisalt(b, 0.30) for b in BELGE]) k = kisalt(BELGE[2], 0.50) print("\n" + " ".join(BELGE[2])) print(" ".join(k)) for t in (TOHUM, TOHUM + 1): y = cagir(k, t) print(f"tohum {t} giris {y['giris']} belirtec cikis {y['cikis']} belirtec" f" durdurma {y['durdurma']}") ``` ``` duzenek belirtec talep alan ciplak cagri 8334 27.78 0.9722 sik parcayi at (0,50) 3505 11.68 0.9722 sik parcayi at (0,30) 1868 6.23 0.8611 merhaba , tarife miz in durum u yuksek ve bu konu da hala bir cevap yok . kayit ac in lutfen . iyi gun ler . merhaba tarife yuksek konu da hala bir cevap kayit ac tohum 20260218 giris 10 belirtec cikis 11 belirtec durdurma kosul tohum 20260219 giris 10 belirtec cikis 10 belirtec durdurma kosul ``` Üçlü buradan okunur. **Çıplak çağrı** talep başına 27,78 belirteç harcar ve alan isabeti 0,9722'dir. **Düzenek** 0,50 eşiğinde talep başına 11,68 belirtece iner — kazanç 0,5794 — ve isabeti **hiç düşürmez**: atılan on altı parçanın tamamı nezaket kalıbı, bağlaç ya da çekim ekidir. **Bedel** bir ön işleme adımı, bir sıklık tablosu ve okunabilirliğin kaybıdır; sayı düşmediği için bu düzenek işe yarar. Eşik 0,30'a çekildiğinde tablo döner. Belirteç 6,23'e iner, kazanç 0,7759 olur, ama isabet 0,8611'e düşer: `yuksek` durumunun belge sıklığı 0,3333'tür ve eşiğin üstünde kaldığı için atılır. En sık durum aynı zamanda en çok sorulan durumdur. **Düzenek eklemek her zaman iyileştirmez** ve iyileştirip iyileştirmediği ancak bedeliyle birlikte yazıldığında görülür. Çıplak çağrının 0,9722'de kalması da bir bulgudur. Kaçırılan 25 alanın tamamı `kapak` nesnesidir: `kapaginin` biçiminde kök yumuşadığı için belirteç dizisinde `kapak` parçası hiç görünmez. Eklemeli yapı yalnız sayıyı büyütmez, kökü belirteç akışından **silebilir** de. Son iki satır belirsizliği ayırır. Aynı istem iki ayrı tohumla çağrıldığında giriş belirteci ikisinde de 10'dur — belirteçleme bir yordamdır, koşumdan bağımsızdır. Çıkış 11 ve 10'dur ve ikisi de durdurma koşuluyla bitmiştir. Modelin yüzeyinde sayılabilen iki büyüklükten biri koşumdan bağımsızdır, öteki değildir; bütçe hesabı bu ayrımın üstüne kurulur. #### Özet - Belirteç metnin modele giriş birimidir ve bu müfredatın bedel birimidir. Benzetici 177 parçalık bir sözlükle soldan en uzun eşleşmeyi uygular; talepler kurgudur, tohum 20260218. - Aynı 300 talep 4.674 sözcük ve 8.334 belirteç eder: sözcük başına 1,7831. Sözcük sayısıyla yapılan tahmin bu birimde sistematik olarak eksik sayar. - Eklemeli yapı ölçülebilir bir bedeldir: altı kök yalın hâlde 6, tam çekimli hâlde 30 belirteç eder ve küme düzeyinde eklerin payı 0,2589'dur. - Çıplak çağrı talep başına 27,78 belirteç ve 0,9722 alan isabeti verir. Sık parçaları 0,50 eşiğiyle atan düzenek 11,68 belirtece iner ve isabeti korur; 0,30 eşiği 6,23 belirtece iner ama isabeti 0,8611'e düşürür. - Giriş belirteci koşumdan bağımsızdır, çıkış uzunluğu değildir: aynı istem iki tohumda 10 giriş, 11 ve 10 çıkış belirteci verir. #### Sonraki Adım Metin belirteçlere bölündü ve her belirtecin bir bedeli olduğu sayıldı. Ortada hâlâ yalnız bir dizi var: modelin bu diziyle ne yaptığı, bir belirtecin yüz belirteç öncesindeki bir başkasıyla nasıl ilişkilendirildiği sorulmadı. Sonraki ders **dikkat** mekanizmasının niçin uzak bağlamı kullanabildiğini kavramsal düzeyde ele alır ve bunun bedelini sayar: bağlam uzadıkça karşılaştırma sayısı nasıl büyüyor ve sabit bir pencereyle yetinen ucuz bir yordam hangi uzaklıkta çöküyor. ### Dönüştürücü Sezgisi Source: https://academia.sh/tr/kurslar/yz-muhendisligine-giris/donusturucu-sezgisi Dikkatin uzak bağlamı niçin kullanabildiğinin ve bunun karşılaştırma sayısı olarak bedelinin ölçülmesi: 240 kurgu talep akışında konu nesnesi sondan ortalama 66,7 belirteç uzaktadır ve son 16 belirtece bakan okuyucu 0,0000 isabet verir, 83 akışta yanlış nesneyi, 157 akışta hiçbir şeyi döndürür. Son 64 belirteç 0,4917'ye çıkar ama 65 belirtecin ötesinde 0,0000'da kalır; uzaklıkla sönümlenen ağırlık her konumu görmesine karşın 0,3250'de kalır. Uzaklıktan bağımsız ağırlık 1,0000 verir ve bedeli 69,7 karşılaştırmadır: tam geçişte bağlam iki katına çıktığında karşılaştırma dört katına çıkar, 1024 belirteçte sabit pencerenin 8,26 katıdır. 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ığı. ```python # 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. ```python 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. ```python 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. ### Önceden Eğitim ve İnce Ayar Source: https://academia.sh/tr/kurslar/yz-muhendisligine-giris/onceden-egitim-ve-ince-ayar Bir görev kümesinin ikiye ayrılıp her birinin kaç örnekle düzeldiğinin sayılması: 1.600 cümlelik kurgu genel metin yığınıyla önceden eğitilen benzetici, hiç alan örneği görmeden genel metinde 0,4616 ve alan metninde 0,2617 sonraki belirteç isabeti verir; aynı ölçü önceden eğitim olmadan 0,1246'dır. Dört yüz alan örneğiyle ince ayar alan metnini 0,5769'a çıkarır ama genel metni 0,3998'e düşürür. Kurumun kendi arıza kodu eşlemesi önceden eğitimle hiç çözülmez: isabet 0,0900'de, en sık kodun 0,1200'lük payının altında kalır ve 0,90 eşiği ancak 256 etiketli örnekle geçilir. Bir önceki ders dikkatin uzak bağlamı kullanabildiğini gösterdi ve bedelini saydı, ama uyum puanlarını elle yazdı. Gerçek bir modelde o puanlar öğrenilir. Öğrenme tek bir olay değildir: iki ayrı aşamada, iki ayrı veriyle, iki ayrı sorunu çözer. Bu ders o iki aşamayı yordam olarak değil, **hangi sorunun hangisinde çözüldüğü** olarak ele alır. Aktarımlı öğrenmenin ve önceden eğitilmiş dil modellerinin yordamı derin öğrenme kursunun mimariler konusunda ve doğal dil işleme kursunda ölçüldü; **burada tekrarlanmaz**. Buradaki soru kullanıcınındır: elimde bir görev var, hangi aşamanın ürünü onu çözer ve çözmüyorsa **kaç örnek** gerekir. Ölçü örnek sayısıdır. - **DL17.** Genel metin yığını ve destek talepleri **kurgudur**: ders içinde üretilir, tohum 20260218. Yığın 1.600 cümle, talep kümesi 600 kayıttır. - **DL18.** Model bir **benzeticidir**: önceden eğitim de ince ayar da **aynı yordamdır** — son bir ve son iki belirtecin ardından gelenin sayılması. Ayrılan tek şey hangi metnin sayıldığıdır. - **DL19.** **Önceden eğitim** etiketsizdir: yalnız metin görür, hiçbir görev etiketi almaz. **İnce ayar** etiketli alan örnekleriyle yapılır ve bedeli o örneklerin sayısıdır. - **DL20.** İnce ayar tablosu **önce**, önceden eğitim tablosu **geri çekilme** olarak sorgulanır. Bir bağlam ince ayarda bir kez görülmüşse, önceden eğitimin o bağlamdaki bilgisini bastırır. - **DL21.** Birinci görev **sonraki belirteç isabetidir** ve iki ayrı metinde ölçülür: genel metin ve alan metni. - **DL22.** İkinci görev kurumun kendi eşlemesidir: talepten **arıza koduna** — nesne ve durumdan türeyen 12 sınıflı, kurgu ve keyfi bir kod. Genel metinde bu kod **hiç geçmez**. - **DL23.** Sınıflandırıcı bağımsız belirteç sayımına dayanır ve yalnız ince ayar örneklerinden kurulur; sıfır örnekte elinde hiçbir şey yoktur. - **DL24.** Ölçüt her satırda aynıdır: ayrılmış payda isabet (büyük iyi) ve **etiketli örnek sayısı** (küçük iyi). - **DL25.** Belirsizlik ölçüsü ince ayar örneklerinin **hangileri olduğudur**: aynı sayıda örnek ikinci bir tohumla seçilip ikinci koşum basılır. #### İki Metin, İki Görev Genel metin yığını sıradan cümlelerden oluşur; talepler aynı dilbilgisini kullanır ama alanın nesnelerini ve durumlarını taşır. Arıza kodu yalnız taleplerde vardır. ```python # BENZETICI — model ders icinde standart kitaplikla yazilmis bir benzeticidir; # gercek bir uc nokta cagrilmaz. Genel metin yigini ve destek talepleri KURGUDUR, # tohum 20260218. TOHUM, M32, GENEL, TALEP = 20260218, 0xFFFFFFFF, 1600, 600 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 OZNE = ["ben", "biz", "siz", "ekip", "servis", "abone", "sistem", "gorevli"] FIIL = ["geldi", "yazdi", "bekledi", "gonderdi", "acti", "verdi", "yapti", "gordu"] AD = ["kayit", "talep", "bilgi", "cevap", "sonuc", "numara", "adres", "islem"] SIFAT = ["yeni", "eski", "acik", "kapali", "normal", "eksik"] GENEL_KALIP = ["{o} bir {a} {f} .", "{o} {a} icin bir {b} {f} .", "bu {a} {s} ve {o} {f} .", "{o} {s} bir {a} {f} .", "{a} {s} ama {o} yine de {f} ."] YIGIN = [] for i in range(GENEL): r = uretec(TOHUM + i) YIGIN.append(GENEL_KALIP[int(r() * 5)].format( o=OZNE[int(r() * 8)], a=AD[int(r() * 8)], b=AD[int(r() * 8)], s=SIFAT[int(r() * 6)], f=FIIL[int(r() * 8)]).split()) NESNE = ["fatura", "tarife", "sayac", "vana"] DURUM = ["yuksek", "eksik", "bozuk"] KOD = {(n, d): f"{'ABCD'[i]}{j + 1}" for i, n in enumerate(NESNE) for j, d in enumerate(DURUM)} TALEP_KALIP = ["{o} {n} icin bir kayit {f} , durum {d} .", "bu {n} {d} ama {o} yine de {f} .", "{o} {n} durumu {d} icin bir talep {f} .", "{n} {d} ve {o} bir cevap {f} ."] VERI = [] for i in range(TALEP): r = uretec(TOHUM + 100000 + i) n, d = NESNE[int(r() * 4)], DURUM[int(r() * 3)] dizi = TALEP_KALIP[int(r() * 4)].format( n=n, d=d, o=OZNE[int(r() * 8)], f=FIIL[int(r() * 8)]).split() VERI.append({"dizi": dizi, "kod": KOD[(n, d)]}) Y_EGT, Y_AYR = YIGIN[:1400], YIGIN[1400:] EGT, AYR = VERI[:400], VERI[400:] kodlar = sorted({x["kod"] for x in VERI}) print(f"genel metin yigini {len(YIGIN)} cumle ({len(Y_EGT)} egitim, {len(Y_AYR)} ayrilmis)") print(f"destek talebi {len(VERI)} ({len(EGT)} ince ayar havuzu, {len(AYR)} ayrilmis)") print(f"ariza kodu {len(kodlar)} sinif: {' '.join(kodlar)}") print(f"\ngenel : {' '.join(Y_EGT[0])}") print(f"talep : {' '.join(EGT[0]['dizi'])} -> {EGT[0]['kod']}") ortak = {t for c in Y_EGT for t in c} & {t for x in VERI for t in x["dizi"]} print(f"yiginin sozlugu {len({t for c in Y_EGT for t in c})}, talebin sozlugu" f" {len({t for x in VERI for t in x['dizi']})}, ortak {len(ortak)}") ``` ``` genel metin yigini 1600 cumle (1400 egitim, 200 ayrilmis) destek talebi 600 (400 ince ayar havuzu, 200 ayrilmis) ariza kodu 12 sinif: A1 A2 A3 B1 B2 B3 C1 C2 C3 D1 D2 D3 genel : adres eski ama servis yine de gordu . talep : siz sayac icin bir kayit yazdi , durum eksik . -> C2 yiginin sozlugu 38, talebin sozlugu 37, ortak 28 ``` Otuz yedi belirteçlik talep sözlüğünün 28'i genel yığında da geçiyor. Talebi ayıran şey dilbilgisi değil, dört nesne ve üç durumdur. Arıza kodu ise hiçbir metinde yazılı değildir: kurumun kendi eşlemesidir ve yalnız etiketten öğrenilebilir. Bu ayrım kurgu bir düzenleme değil, ölçünün taşıyıcısıdır. Bir görevin cevabı ya dünyanın metninde bir yerde geçiyordur — cümlenin nasıl kurulduğu, hangi sözcüğün hangisini izlediği — ya da yalnız o kurumun kayıtlarında durur. Birincisi hiç örnek istemeden gelir, ikincisi her örneği tek tek ödetir. Aşağıdaki iki tablo aynı benzeticiyi aynı ölçütle iki görev sınıfında sınar ve farkın nereden geldiğini örnek sayısıyla yazar. #### Önceden Eğitimin Ürünü Önceden eğitim etiketsizdir: benzetici yalnız yığını okur ve hangi belirtecin hangisini izlediğini sayar. İnce ayar aynı yordamı alan metnine uygular. Üç sütun aynı ölçütü üç ayrı koşulda verir. ```python AYR_DIZI = [x["dizi"] for x in AYR] def egit(cumleler): """Onceden egitim de ince ayar da ayni yordamdir: son bir ve son iki belirtecin ardindan gelenin sayilmasi. Ayrilan sey yalnizca metindir.""" t = {} for c in cumleler: for i in range(1, len(c)): for a in [(c[i - 1],)] + ([(c[i - 2], c[i - 1])] if i > 1 else []): t.setdefault(a, {}) t[a][c[i]] = t[a].get(c[i], 0) + 1 return t def tahmin(gecmis, ince, once, varsayilan): """Ince ayar tablosu once, onceden egitim tablosu geri cekilme olarak.""" for t in (ince, once): for a in (tuple(gecmis[-2:]), tuple(gecmis[-1:])): d = t.get(a) if d: return max(sorted(d), key=d.get) return varsayilan def sonraki_isabet(cumleler, ince, once, varsayilan): dogru = top = 0 for c in cumleler: for i in range(1, len(c)): top += 1 dogru += tahmin(c[:i], ince, once, varsayilan) == c[i] return dogru / top ONCE = egit(Y_EGT) VARSAYILAN = max(sorted({t for c in Y_EGT for t in c}), key=lambda t: sum(c.count(t) for c in Y_EGT)) K_LISTESI = [0, 2, 4, 8, 16, 32, 64, 128, 256, 400] print(f"{'ornek':>6} {'genel metin':>12} {'alan metni':>11} {'egitimsiz alan':>15}") for k in K_LISTESI: ince = egit([x["dizi"] for x in EGT[:k]]) if k else {} print(f"{k:>6} {sonraki_isabet(Y_AYR, ince, ONCE, VARSAYILAN):>12.4f}" f" {sonraki_isabet(AYR_DIZI, ince, ONCE, VARSAYILAN):>11.4f}" f" {sonraki_isabet(AYR_DIZI, ince, {}, VARSAYILAN):>15.4f}") ``` ``` ornek genel metin alan metni egitimsiz alan 0 0.4616 0.2617 0.1246 2 0.3786 0.3364 0.2698 4 0.3636 0.3857 0.3315 8 0.3116 0.3925 0.3445 16 0.3195 0.4654 0.4567 32 0.3292 0.5202 0.5202 64 0.3822 0.5589 0.5589 128 0.3901 0.5651 0.5651 256 0.4069 0.5576 0.5576 400 0.3998 0.5769 0.5769 ``` İlk satır önceden eğitimin ürününü tek başına verir. Hiç alan örneği görmemiş benzetici, alan metninde 0,2617 tutturuyor; aynı ölçü önceden eğitim olmadan 0,1246'dır. **Aktarım budur ve bir sayıdır:** paylaşılan 28 belirteç, alanın kendi metnini iki katı isabetle tahmin ettiriyor. Alan örneği bedava değildir; önceden eğitim onun bir kısmını peşin ödemiştir. Üçüncü sütun 32 örnekten sonra ikinciyle eşitleniyor. Yeterli alan örneği biriktiğinde önceden eğitimin katkısı sıfıra iner: geri çekilme tablosuna artık hiç düşülmez. **Aktarımın değeri örnek azken vardır.** Bu, ölçünün nereye bakılacağını da söyler — az örnekli bir kurulumda önceden eğitimli ve eğitimsiz iki koşum arasındaki fark ölçülmeye değer, çok örnekli bir kurulumda o fark ölçülse bile sıfırdır. Birinci sütun ise ters yönde ilerliyor: 0,4616'dan başlayıp 8 örnekte 0,3116'ya düşüyor, sonra 0,3998'e toparlanıyor. Kayıp gerçektir ve nedeni tablonun sırasıdır — ince ayarda bir kez görülen bağlam, önceden eğitimin o bağlamdaki bilgisini bastırır. Örnek azken bu tek gözlem temsil etmeyen bir tercih üretir; örnek arttıkça tercih genel dağılıma yaklaşır ama başlangıç düzeyine dönmez. **İnce ayarın bedeli yalnız etiketli örnek değil, genel yetenekte 0,0618'lik bir kayıptır.** #### Etikete Bağlı Olan İkinci görev kurumun kendi eşlemesidir. Genel metinde arıza kodu diye bir şey yoktur; ne kadar metin okunursa okunsun bu eşleme çıkarılamaz. ```python import math def sinif_egit(ornekler): say, top = {}, {} for x in ornekler: k = x["kod"] top[k] = top.get(k, 0) + 1 for t in set(x["dizi"]): say[(t, k)] = say.get((t, k), 0) + 1 return say, top def sinifla(model, dizi): say, top = model if not top: return kodlar[0] en, ep = None, None for k in sorted(top): p = math.log(top[k]) for t in sorted(set(dizi)): p += math.log((say.get((t, k), 0) + 1) / (top[k] + 2)) if ep is None or p > ep: en, ep = k, p return en def sec(havuz, k, tohum): r, p = uretec(tohum), list(havuz) for i in range(len(p) - 1, 0, -1): j = int(r() * (i + 1)) p[i], p[j] = p[j], p[i] return p[:k] def kod_isabet(ornekler): m = sinif_egit(ornekler) return sum(sinifla(m, x["dizi"]) == x["kod"] for x in AYR) / len(AYR) print(f"{'ornek':>6} {'kod isabeti':>12} {'goren sinif':>12} {'ikinci kosum':>13}") esik = None for k in K_LISTESI: o = sec(EGT, k, TOHUM) i1, i2 = kod_isabet(o), kod_isabet(sec(EGT, k, TOHUM + 1)) print(f"{k:>6} {i1:>12.4f} {len({x['kod'] for x in o}):>12} {i2:>13.4f}") if esik is None and i1 >= 0.90: esik = k print(f"\n0,90 esigini gecen en kucuk ornek sayisi: {esik}") print(f"en sik kodun ayrilmis paydaki orani:" f" {max(sum(x['kod'] == k for x in AYR) for k in kodlar) / len(AYR):.4f}") ``` ``` ornek kod isabeti goren sinif ikinci kosum 0 0.0900 0 0.0900 2 0.1200 2 0.0650 4 0.2100 3 0.0900 8 0.2050 6 0.2400 16 0.1850 8 0.2850 32 0.2800 11 0.3950 64 0.4750 12 0.4650 128 0.6100 12 0.7150 256 0.9200 12 0.8600 400 0.9400 12 0.9400 0,90 esigini gecen en kucuk ornek sayisi: 256 en sik kodun ayrilmis paydaki orani: 0.1200 ``` Sıfır örnekte isabet 0,0900'dür ve en sık kodu her zaman söyleyen yordamın 0,1200'ünün **altındadır**. Önceden eğitimin bu görevdeki katkısı sıfır değil, negatiftir: model dili bilir, eşlemeyi bilmez. Görülen sınıf sütunu bunun mekanik nedenini veriyor — on iki kodun hepsi ancak 64 örnekte havuza giriyor, öncesinde hiç görülmemiş bir kod hiçbir koşulda söylenemez. Eşik 256 örnektir. Aynı görev, aynı model, aynı ölçüt: **önceden eğitimin karşılığı sıfır, ince ayarınki 256 örnektir.** Görev kümesini ikiye ayıran soru budur — cevabı metinde yazılı olan mı, yoksa yalnız kurumun kayıtlarında olan mı. Eğri düz de değildir. Dört örnekte 0,2100'e çıkan isabet on altı örnekte 0,1850'ye iniyor: yeni gelen sınıflar eldeki sayımı seyrelttiği için ara bir bölgede sayı geriliyor. Bir örnek eğrisini iki noktadan okumak bu yüzden yanıltır; hangi örnek sayısının yettiğini söyleyebilmek için eğrinin düzleştiği yeri görmek gerekir. Burada düzleşme 256 ile 400 arasındadır ve son 144 örnek isabete yalnız 0,0200 ekler. Son sütun belirsizliği gösteriyor. Örnek sayısı sabit tutulup **hangi örneklerin** çekildiği değiştirildiğinde 128'de 0,6100 ile 0,7150, 32'de 0,2800 ile 0,3950 çıkıyor. İkisi de aynı düzeneğin sayısıdır. **Tek koşumla okunan bir örnek eğrisi, örneklerin seçiminden gelen değişkenliği saklar.** Bu iki aşamanın kullanıcı tarafındaki karşılığı eşit değildir. Önceden eğitim, bu müfredatta verilmiş bir bileşenin içinde kapalıdır: yapılmıştır, değiştirilemez, sayısı ancak yüzeyden okunur. İnce ayar ise bir karardır ve bedeli önden ödenir — etiketlenecek örnek, etiketi verecek kişi, etiketin tutarlılığı. Yukarıdaki tablo o kararın fiyat etiketidir: bu görevde 0,90 için 256 örnek. Karar verilirken sorulacak soru "model bunu yapabilir mi" değil, **bu sayıya ulaşmanın kaç örnek ettiğidir**. Sonraki kursların istem tasarımı ve erişimle bağlama gibi düzenekleri, aynı sayıya **etiket ödemeden** yaklaşmanın yollarıdır ve hepsi bu tabloya karşı okunur. #### Özet - Önceden eğitim ile ince ayar bu benzeticide aynı yordamdır; ayrılan tek şey hangi metnin sayıldığıdır. Metinler ve arıza kodu kurgudur, tohum 20260218. - Önceden eğitimin alan metnine katkısı ölçülebilir: hiç alan örneği görmeden 0,2617, önceden eğitim olmadan 0,1246. Katkı örnek azken vardır ve 32 örnekten sonra sıfıra iner. - İnce ayarın bedeli yalnız 400 etiketli örnek değildir: genel metin isabeti 0,4616'dan 0,3998'e düşer ve en dip nokta 8 örnekte, 0,3116'dadır. - Kurumun kendi eşlemesi önceden eğitimle hiç çözülmez: 0,0900 isabet, en sık kodun 0,1200'lük payının altındadır. 0,90 eşiği ancak 256 etiketli örnekle geçilir. - Aynı örnek sayısı başka bir tohumla seçildiğinde sayı oynar: 128 örnekte 0,6100 ile 0,7150. #### Sonraki Adım Modelin nereden ne öğrendiği ayrıldı ve her aşamanın bedeli örnek sayısıyla yazıldı. Ama bu derste model hep tek bir tahmin üretti: en olası belirteç, tek adımda. Gerçek bir yanıt tek belirteç değildir; adım adım üretilir ve her adım bir seçimdir. Sonraki ders o seçimi ölçer: çıktı uzunluğu ile üretilen belirteç sayısı, en olası seçim ile örneklemeli seçimin aynı istemde iki koşumda verdiği ve dağılım sıcaklığının bu ikisi arasında nerede durduğu. ### Çıkarım Source: https://academia.sh/tr/kurslar/yz-muhendisligine-giris/cikarim Bir yanıtın adım adım üretilmesinin bedeli ve seçim kuralının sayısı: 200 kurgu talepte en olası seçim yanıt başına 6,43 belirteç ve 211,1 karşılaştırma tutuyor, isabeti 1,0000. En büyük çıktı uzunluğu 4'e çekildiğinde bütün yanıtlar sınıra takılıyor ve isabet 0,0000'a, 6'da 0,5450'ye, 7'de 0,8100'e iniyor. Aynı istemde örnekleme dağılım sıcaklığı 0,2'den 2,0'a çıktıkça isabeti 0,9900'den 0,5600'e düşürüyor, iki koşum arasında değişen yanıt oranı 0,5550'den 0,8600'e yükseliyor; en olası seçimde bu oran 0,0000. Giriş 30 belirteç sabitken çıktı 512 belirtece uzadığında karşılaştırmanın 0,8953'ünü çıktının kendisi tutuyor. Bir önceki ders modelin nereden ne öğrendiğini ayırdı, ama her yerde tek bir tahmin üretti: en olası belirteç, tek adımda. Gerçek bir yanıt tek belirteç değildir. Model bir belirteç üretir, onu kendi girdisinin sonuna ekler, bir sonrakini üretir ve durdurma koşulu gelene kadar bunu sürdürür. **Çıkarım** dediğimiz şey bu döngüdür; bedeli de, belirsizliği de burada doğar. İki soru ölçülür. Birincisi bedel: bir yanıt uzadıkça ne kadar iş yapılıyor. İkincisi seçim kuralı: her adımda dağılımın en büyüğü mü alınıyor, yoksa dağılımdan **örnekleniyor** mu — ve bu karar aynı istemde iki koşumda ne veriyor. Bu ders müfredatın üçüncü iddiasını doğrudan sayar: model belirsiz bir bileşendir ve belirsizliğin miktarı bir ayardır. - **DL26.** Talepler ve yanıt örnekleri **kurgudur**: ders içinde üretilir, tohum 20260218. Örnek kümesi 600 yanıt, sınama kümesi 200 taleptir. - **DL27.** Model bir **benzeticidir**: her adımda koşul ve son iki belirteç için bir dağılım kurar, bir belirteç seçer ve seçtiğini geçmişe ekler. - **DL28.** **Durdurma koşulu** noktadır. **En büyük çıktı uzunluğu** ayrı bir sınırdır ve aşıldığında yanıt yarıda kesilir. - **DL29.** Yanıt örneklerinin 0,15'i alanla ilgisiz genel bir kalıptır. Model bu yüzden her koşulda tek bir doğru yola sahip değildir. - **DL30.** **İsabet** yalnız tamamlanmış yanıtlar için sayılır: yanıt noktayla bitmeli, doğru nesneyi ve doğru eylemi taşımalıdır. Yarıda kesilen yanıt yanlış sayılır. - **DL31.** **Bedel** iki birimle yazılır: üretilen belirteç sayısı ve karşılaştırma sayısı. Her adım giriş uzunluğu artı o ana kadar üretilen belirteç kadar karşılaştırma tutar. - **DL32.** Giriş uzunluğu bütün ölçümlerde 30 belirteçtir; değişen tek şey çıktıdır. - **DL33.** **Dağılım sıcaklığı** olasılıkları üsse taşır: sıfır en olası seçimdir, büyüdükçe dağılım düzleşir. - **DL34.** Belirsizlik ölçüsü **aynı istemin iki koşumudur**: ikinci koşum tohum değiştirilerek alınır ve iki koşumda farklı çıkan yanıtların oranı basılır. #### Bir Yanıtın Üretilmesi Benzetici bir yanıtı bir defada yazmaz. Başlangıç imiyle işe başlar, her adımda bir dağılım kurar, bir belirteç seçer ve seçtiğini geçmişin sonuna ekler. ```python # BENZETICI — model ders icinde standart kitaplikla yazilmis bir benzeticidir; # gercek bir uc nokta cagrilmaz. Talepler ve yanit ornekleri KURGUDUR, tohum 20260218. TOHUM, M32, ORNEK, SINAMA = 20260218, 0xFFFFFFFF, 600, 200 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 NESNE = ["fatura", "tarife", "sayac", "vana"] DURUM = ["yuksek", "eksik", "bozuk"] EYLEM = {"yuksek": "itiraz kaydi acildi", "eksik": "bilgi gonderildi", "bozuk": "saha ekibi yonlendirildi"} KALIP = ["{n} icin {e} .", "{n} kaydi incelendi ve {e} .", "{n} durumu icin {e} ."] GENEL = ["kayit incelendi ve sonuc gonderildi .", "talep alindi ve kayit acildi ."] def ornek_uret(tohum, sayi): v = [] for i in range(sayi): r = uretec(tohum + i) n, d = NESNE[int(r() * 4)], DURUM[int(r() * 3)] if r() < 0.15: y = GENEL[int(r() * 2)] else: y = KALIP[int(r() * 3)].format(n=n, e=EYLEM[d]) v.append({"kosul": (n, d), "yanit": [""] + y.split()}) return v EGT = ornek_uret(TOHUM, ORNEK) SIN = ornek_uret(TOHUM + 500000, SINAMA) TABLO = {} for x in EGT: y = x["yanit"] for i in range(1, len(y)): for a in ((x["kosul"], tuple(y[max(0, i - 2):i])), (x["kosul"], (y[i - 1],))): TABLO.setdefault(a, {}) TABLO[a][y[i]] = TABLO[a].get(y[i], 0) + 1 def dagilim(kosul, gecmis): d = TABLO.get((kosul, tuple(gecmis[-2:]))) or TABLO.get( (kosul, (gecmis[-1],))) or {".": 1} t = sum(d.values()) return sorted((b, s / t) for b, s in d.items()) def uret(kosul, giris, sicaklik=0.0, tohum=TOHUM, en_buyuk=12): """Adim adim uretim: her adimda dagilim kurulur, bir belirtec secilir ve gecmise eklenir. Durdurma kosulu nokta, ust sinir en_buyuk belirtectir.""" r, gecmis, karsi = uretec(tohum + giris), [""], 0 while len(gecmis) - 1 < en_buyuk: d = dagilim(kosul, gecmis) karsi += giris + len(gecmis) - 1 if sicaklik <= 0: sec = max(d, key=lambda bp: (bp[1], bp[0]))[0] else: a = [(b, p ** (1 / sicaklik)) for b, p in d] u, s = r() * sum(p for _, p in a), 0.0 sec = a[-1][0] for b, p in a: s += p if u < s: sec = b break gecmis.append(sec) if sec == ".": return gecmis[1:], karsi, "kosul" return gecmis[1:], karsi, "sinir" x = SIN[0] print(f"kurgu ornek {ORNEK} yanit, sinama {SINAMA} talep") print(f"talep kosulu {x['kosul']}, dogru eylem: {EYLEM[x['kosul'][1]]}") for ad, sic, th in (("en olasi secim", 0.0, TOHUM), ("en olasi secim", 0.0, TOHUM + 1), ("ornekleme 1,0", 1.0, TOHUM), ("ornekleme 1,0", 1.0, TOHUM + 1)): y, k, dur = uret(x["kosul"], 30, sic, th, 12) print(f"{ad:<16} tohum {th} {len(y):>2} belirtec {dur:<5} {' '.join(y)}") ``` ``` kurgu ornek 600 yanit, sinama 200 talep talep kosulu ('sayac', 'yuksek'), dogru eylem: itiraz kaydi acildi en olasi secim tohum 20260218 8 belirtec kosul sayac kaydi incelendi ve itiraz kaydi acildi . en olasi secim tohum 20260219 8 belirtec kosul sayac kaydi incelendi ve itiraz kaydi acildi . ornekleme 1,0 tohum 20260218 8 belirtec kosul sayac kaydi incelendi ve itiraz kaydi acildi . ornekleme 1,0 tohum 20260219 7 belirtec kosul sayac durumu icin itiraz kaydi acildi . ``` Dört satır iki şey söylüyor. En olası seçim iki tohumda **birebir aynı** yanıtı veriyor: tohum hiçbir yere girmez, çünkü hiçbir adımda kura çekilmez. Örnekleme ise ikinci tohumda 8 belirteç yerine 7 belirteçlik başka bir cümle veriyor. İkisi de doğru; **değişmek ile yanılmak aynı şey değildir** ve bu ayrım dersin geri kalanının ölçtüğü şeydir. Döngünün bir başka sonucu gecikmede görünür. Yanıtın ilk belirteci tek bir adım sonra hazırdır, sonuncusu ise ancak m adım sonra. Bu yüzden bir dil modeli çağrısının gecikmesi tek bir sayı değildir: ilk belirtece kadar geçen süre ile yanıtın tamamlanmasına kadar geçen süre ayrı ayrı davranır ve ikincisi çıktı uzunluğuyla birlikte büyür. Bu müfredat süreyi ham birimle yazmaz ama ayrımı korur; sekiz belirteçlik bir yanıt ile seksen belirteçlik bir yanıt aynı gecikme sınıfında değildir. Adım adım seçimin bir de yapısal sınırı var: her adım kendi başına en iyisini seçer, ileriye bakmaz. Yukarıdaki yanıtta ikinci belirteç `kaydi` seçildiği anda cümle uzun kalıba bağlanmıştır; o adımda `icin` seçilse cümle iki belirteç kısa bitecekti. **En olası seçim adım başına en olasıdır, cümle başına değil.** Bu, çıktı uzunluğunun da tam olarak denetlenemediği anlamına gelir ve bir sonraki bölümün ölçtüğü sınır sorunu buradan doğar. #### Adım Adım Üretimin Bedeli Her adım kendinden öncekilerin hepsini yeniden okur. Bir yanıt m belirteç uzunluğundaysa ve giriş n belirteçse, toplam karşılaştırma m·n artı m(m+1)/2 olur: birinci terim girişin tekrar tekrar okunması, ikincisi çıktının kendi kuyruğudur. ```python GIRIS = 30 def dogru(y, kosul): """Yanit ancak tamamlanmissa ve dogru nesne ile dogru eylemi tasiyorsa sayilir.""" return y[-1] == "." and kosul[0] in y and EYLEM[kosul[1]].split()[0] in y def kosum(sicaklik, tohum, en_buyuk): bel = kar = isa = sinir = 0 yanitlar = [] for i, x in enumerate(SIN): y, k, dur = uret(x["kosul"], GIRIS, sicaklik, tohum + i, en_buyuk) bel += len(y) kar += k isa += dogru(y, x["kosul"]) sinir += dur == "sinir" yanitlar.append(tuple(y)) n = len(SIN) return bel / n, kar / n, isa / n, sinir / n, yanitlar print(f"{'en buyuk cikti':>15} {'belirtec':>9} {'karsilastirma':>14}" f" {'sinira takilan':>15} {'isabet':>7}") for eb in (4, 6, 7, 8, 12): b, k, i, s, _ = kosum(0.0, TOHUM, eb) print(f"{eb:>15} {b:>9.2f} {k:>14.1f} {s:>15.4f} {i:>7.4f}") print(f"\n{'cikti m':>8} {'karsilastirma':>14} {'ciktinin payi':>14}") for m in (8, 32, 128, 512): k = m * GIRIS + m * (m + 1) // 2 print(f"{m:>8} {k:>14} {m * (m + 1) // 2 / k:>14.4f}") ``` ``` en buyuk cikti belirtec karsilastirma sinira takilan isabet 4 4.00 126.0 1.0000 0.0000 6 5.79 187.7 0.4550 0.5450 7 6.25 204.0 0.1900 0.8100 8 6.43 211.1 0.0000 1.0000 12 6.43 211.1 0.0000 1.0000 cikti m karsilastirma ciktinin payi 8 276 0.1304 32 1488 0.3548 128 12096 0.6825 512 146688 0.8953 ``` Üçlü buradan okunur. **Çıplak çağrı** en dar ayardır: en büyük çıktı 4 belirteç, yanıt başına 126 karşılaştırma, isabet **0,0000**. Ucuzdur ve hiçbir işe yaramaz, çünkü yanıtların tamamı sınıra takılıp yarıda kesilmiştir. **Düzenek** sınırı yanıtın gerçek uzunluğuna açmaktır: 8 belirteçte sınıra takılan kalmaz, isabet 1,0000 olur. **Bedel** 4,00'dan 6,43 belirtece, 126,0'dan 211,1 karşılaştırmaya çıkmaktır — yaklaşık 1,68 kat. Ara satırlar sınırın nasıl bir başarısızlık ürettiğini gösteriyor. Altı belirteçte yanıtların 0,4550'si kesiliyor ve isabet 0,5450'de kalıyor; yedide oran 0,1900 ve isabet 0,8100. **Bu başarısızlık sessizdir:** kesik yanıt hata döndürmez, düzgün bir cümlenin başlangıcı gibi görünür. Sınıra takılma oranı, ölçülmesi gereken ayrı bir sayıdır. Sekizden on ikiye çıkmak hiçbir şey değiştirmiyor: 6,43 ve 211,1 aynı kalıyor. En büyük çıktı uzunluğu bir **tavan**dır, bir hedef değil; durdurma koşulu daha önce geldiğinde tavanın büyüklüğü bedel doğurmaz. Bu, sınırın nasıl seçileceğini de söyler: tavanı dar tutmak tasarruf getirmez, yalnız kesilme riski yaratır. Tasarruf edilecek yer istemin ve beklenen yanıtın uzunluğudur, tavan değil. İkinci tablo bedelin uzun çıktılarda nereye kaydığını veriyor. Giriş 30 belirteçte sabitken çıktı 8 belirteçse karşılaştırmanın yalnız 0,1304'ünü çıktı tutuyor; 512 belirteçte bu pay 0,8953'e çıkıyor. **Uzun yanıtın bedeli istemin uzunluğuna değil, kendi uzunluğuna bağlıdır.** #### Seçim Kuralı ve Sıcaklık Her adımda dağılımın en büyüğü alınabilir ya da dağılımdan örneklenebilir. Sıcaklık ikisi arasındaki sürekli ayardır: küçük sıcaklık dağılımı sivriltir, büyük sıcaklık düzleştirir. Sıfır sıcaklık örneklemenin sınır durumudur ve kura tümüyle ortadan kalkar. Aşağıdaki süpürme aynı 200 talebi yedi ayarda ikişer koşumla çağırır; değişen tek şey seçim kuralıdır, model de istem de her satırda aynıdır. ```python print(f"{'sicaklik':>9} {'isabet 1':>9} {'isabet 2':>9} {'degisen':>8}" f" {'belirtec':>9} {'karsilastirma':>14}") for sic in (0.0, 0.2, 0.5, 0.8, 1.0, 1.5, 2.0): b, k, i1, _, y1 = kosum(sic, TOHUM, 16) _, _, i2, _, y2 = kosum(sic, TOHUM + 1000, 16) d = sum(a != b2 for a, b2 in zip(y1, y2)) / len(y1) ad = "0,0" if sic == 0 else f"{sic:.1f}".replace(".", ",") print(f"{ad:>9} {i1:>9.4f} {i2:>9.4f} {d:>8.4f} {b:>9.2f} {k:>14.1f}") ``` ``` sicaklik isabet 1 isabet 2 degisen belirtec karsilastirma 0,0 1.0000 1.0000 0.0000 6.43 211.1 0,2 0.9900 0.9900 0.5550 6.47 212.5 0,5 0.9500 0.9400 0.6650 6.53 214.3 0,8 0.8800 0.8750 0.7200 6.50 213.5 1,0 0.7900 0.8200 0.7650 6.47 212.2 1,5 0.6250 0.6700 0.8550 6.47 212.1 2,0 0.5600 0.5600 0.8600 6.46 211.5 ``` En olası seçim satırı bu müfredatın en sade belirsizlik ölçüsüdür: iki koşumda değişen yanıt oranı **0,0000**. Model burada belirsiz değildir; belirsizlik seçim kuralından gelir, modelin kendisinden değil. İkinci satır asıl uyarıyı taşıyor. Sıcaklık 0,2'de isabet 0,9900 ile neredeyse bozulmamıştır, ama iki koşumda yanıtların **0,5550'si değişir**. Aynı talebe iki ayrı zamanda iki ayrı cümle döner ve ikisi de doğrudur. Bir ürün için bu sayı bağımsız bir tasarım verisidir: yanıtın metni bir yere kaydediliyorsa, karşılaştırılıyorsa ya da bir sınamada beklenen çıktıyla eşleştiriliyorsa 0,5550 her koşumda kırılan bir sınamadır. Sıcaklık büyüdükçe iki sütun ayrışır. İki koşumda değişme 0,8600'e doğru doyar, isabet ise 0,9900'den 0,5600'e düşer. **Düzeneğin bedeli burada isabetle ödenir ve karşılığında alınan şey yalnız çeşitliliktir.** Belirteç ve karşılaştırma sütunları neredeyse sabittir: sıcaklığın bedeli belirteç değil, doğruluktur. Üç sıcaklığın üç ayrı işe yaradığı da tablodan okunur. Bir sınıflandırma ya da kod atama görevinde 0,0 doğru ayardır: tekrarlanabilir ve en yüksek isabetli. Bir yanıt metninde 0,2 ile 0,5 arası isabeti çok az düşürüp metni tekdüzelikten çıkarır. 1,0'ın üstü ise ancak çeşitliliğin kendisi ürünün amacıysa savunulabilir ve bu tabloda 0,2100'lük bir isabet kaybına mal olur. Tablonun sessiz kalan bir sütunu daha var: yanlış yanıtın bedeli. Sıcaklık 1,0'da yanıtların 0,2100'ü yanlıştır ve bu yanlışlar rastgele dağıldığı için aynı istem tekrar çağrılarak düzeltilebilir. Ama tekrar çağırmak bedava değildir — her yeniden deneme yeni bir 211,1 karşılaştırma ve 6,47 belirteçtir. Beş talepten birinin ikinci kez çağrıldığı bir düzenekte ortalama bedel 1,21 çağrıya çıkar ve bunun karşılığında elde edilen isabet 0,0 sıcaklığın zaten 1,0000 olan sayısının altındadır. **Belirsizliği önce açıp sonra yeniden denemeyle kapatmak, aynı sayıya daha pahalı ulaşmanın yoludur.** Bu, müfredatın ikinci iddiasının bu dersteki biçimidir: eklenen düzeneğin bedeli kesin, kazancı belirsizdir. #### Özet - Çıkarım tek bir işlem değil, bir döngüdür: her adım bir dağılım kurar, bir belirteç seçer ve seçtiğini girdinin sonuna ekler. Talepler ve yanıt örnekleri kurgudur, tohum 20260218. - Bedel iki birimle yazılır. En olası seçimde yanıt başına 6,43 belirteç ve 211,1 karşılaştırma; giriş 30 belirteçte sabitken çıktı 512 belirtece uzadığında karşılaştırmanın 0,8953'ünü çıktının kendisi tutar. - En büyük çıktı uzunluğu sessiz bir başarısızlık kaynağıdır: 4 belirteçte bütün yanıtlar kesilir ve isabet 0,0000 olur, 6'da 0,5450, 7'de 0,8100, 8'de 1,0000. - En olası seçim iki koşumda birebir aynı yanıtı verir (değişen oranı 0,0000). Belirsizlik modelden değil, seçim kuralından gelir. - Sıcaklık 0,2'de isabet 0,9900 kalırken iki koşumda değişen yanıt oranı 0,5550'dir; 2,0'da isabet 0,5600, değişen oranı 0,8600'dür. Belirteç bedeli bu süpürme boyunca neredeyse sabittir. #### Sonraki Adım Yanıtın nasıl üretildiği ve seçim kuralının ne ödettiği sayıldı. Ama bütün bu ölçümlerde giriş 30 belirteçte sabit tutuldu. Gerçek bir düzenekte giriş sabit değildir: talep akışı uzar, belgeler eklenir, önceki yanıtlar geri konur. Modelin bir de **penceresi** vardır ve o pencere sabittir. Sonraki ders pencere aşıldığında ne olduğunu ölçer: baştan atmak, ortadan atmak ve özetlemek aynı görevde kaç belirteç kazandırıyor ve isabeti ne kadar düşürüyor. ### Bağlam Penceresi Source: https://academia.sh/tr/kurslar/yz-muhendisligine-giris/baglam-penceresi Pencere aşıldığında ne olduğunun ve üç kırpma kararının kaç belirteç kazandırıp isabeti ne kadar düşürdüğünün ölçülmesi: 256 belirteçlik pencerede 300 kurgu istemin 0,5967'si sığmıyor ve çıplak çağrı 282,3 belirteçle 0,3833 tam yanıt veriyor. Baştan atmak 217,5 belirteçle 0,7433, ortadan atmak aynı belirteçle 0,7367, özetlemek 100,6 belirteçle kod isabetini 0,9667'ye çıkarıyor ama adım isabetini 0,0000'a düşürüyor. Kırpmanın hangi kararı verdiği kanıtın yerine bağlıdır: baştan atmak baş kovada 0,5351, ortadan atmak orta kovada 0,3627 veriyor. Pencere 128'den 384'e çıktığında tam yanıt 0,3767'den 0,9867'ye yükseliyor. Bir önceki ders yanıtın adım adım nasıl üretildiğini ve seçim kuralının ne ödettiğini saydı, ama girişi hep 30 belirteçte sabit tuttu. Gerçek bir düzenekte giriş sabit değildir. İstem büyür: bir yönerge, saha ekibinin belgelerinden birkaçı, talep akışı ve soru yan yana konur. Modelin ise sabit bir **bağlam penceresi** vardır ve o pencere aşıldığında bir şey olur. Bu ders o "bir şeyi" ölçer. Pencere bir sınırdır; sınırı aşan istemi neyin kırpacağı ise bir **karardır** ve karar mühendisindir. Üç karar aynı görevde yan yana konur — baştan atmak, ortadan atmak, özetlemek — ve her biri iki sayıyla yazılır: kaç belirteç kazandırdı, isabeti ne kadar düşürdü. - **DL35.** Belge dağarcığı ve talepler **kurgudur**: ders içinde üretilir, tohum 20260218. Dağarcık 24 belgedir, her biri 28 belirteç; kayıtlar hiçbir kaynak sistemden gelmez. - **DL36.** Bir belge bir başlık satırı (belge numarası, nesne, durum, arıza kodu) ve beş yordam adımı taşır. - **DL37.** İstem dört parçadır: yönerge, belgeler, talep, soru. Kırpma **belge bütünlüğünde** yapılır; yarım belge bırakılmaz. Yönerge, talep ve soru hiçbir kararda atılmaz. - **DL38.** Görev iki alanlıdır: doğru belgenin **arıza kodu** ve **ikinci adımı**. Tam yanıt ikisinin birden doğru olmasıdır. - **DL39.** Model bir **benzeticidir**. İstemi pencereye sığdığı sürece okur; sığmazsa çağrı **pencere hatasıyla** başarısız olur ve hiçbir yanıt dönmez. - **DL40.** Benzeticinin ikinci başarısızlığı **zaman aşımıdır** ve payı istem uzunluğuyla birlikte büyür. Bu pay tohuma bağlıdır; ikinci koşum tohum değiştirilerek alınır. - **DL41.** Özetleme yordamı burada kuralla yapılır: her belgeden yalnız başlık satırı bırakılır. Gerçek bir düzenekte özet bir model çağrısıdır ve **kendi bedeli** vardır. - **DL42.** Ölçüt her satırda aynıdır: istem başına belirteç (küçük iyi), başarısızlık payı (küçük iyi), kod ile adım isabeti ve tam yanıt oranı (büyük iyi). - **DL43.** Kanıtın istemdeki **yeri** kaydedilir: hedef belgenin belge listesindeki sırası. - **DL44.** Pencere süpürmesinde başarısızlık payı hesaba katılmaz; o tablo koşumdan bağımsızdır. - **DL45.** **Çıplak çağrı** bu derste istemin hiç kırpılmadan gönderilmesidir. #### Pencereyi Aşan İstem İstem yönergeyle başlar, dört ile on dört belge sürer, talep ve soruyla biter. Pencere 256 belirteçtir. ```python # BENZETICI — model ders icinde standart kitaplikla yazilmis bir benzeticidir; # gercek bir uc nokta cagrilmaz. Belge dagarcigi ve talepler KURGUDUR, tohum 20260218. TOHUM, M32, PENCERE, TALEP = 20260218, 0xFFFFFFFF, 256, 300 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 NESNE = ["fatura", "tarife", "sayac", "vana", "muhur", "hat"] DURUM = ["yuksek", "eksik", "bozuk", "eski"] EYLEM = ["kaydi ac", "ekip yonlendir", "olcum tekrarla", "bilgi gonder", "tarife karsilastir", "muhur degistir"] YONERGE = ("yonerge : asagidaki belgelere bak , talebin nesnesi ve durumu ile " "eslesen belgeyi bul , kodu ve ikinci adimi yaz .").split() SORU = "soru : bu talebin kodu ve ikinci adimi nedir ?".split() DAGARCIK = [] for i, n in enumerate(NESNE): for j, d in enumerate(DURUM): r = uretec(TOHUM + 900 + i * 4 + j) b = ["belge", str(101 + i * 4 + j), ":", n, d, "kod", f"{'ABCDEF'[i]}{j + 1}"] for a in range(1, 6): b += ["adim", str(a)] + EYLEM[int(r() * 6)].split() DAGARCIK.append({"dizi": b + ["son"], "nesne": n, "durum": d, "kod": b[6], "adim2": b[13:15]}) VERI = [] for i in range(TALEP): r = uretec(TOHUM + i) h = int(r() * 24) hedef = DAGARCIK[h] baska = [DAGARCIK[(h + 1 + int(r() * 23)) % 24] for _ in range(3 + int(r() * 11))] yer = int(r() * (len(baska) + 1)) belgeler = ([b["dizi"] for b in baska[:yer]] + [hedef["dizi"]] + [b["dizi"] for b in baska[yer:]]) kuyruk = ["talep", ":", hedef["nesne"], "durumu", hedef["durum"], ",", "cevap", "bekliyorum", "."] + SORU VERI.append({"belgeler": belgeler, "kuyruk": kuyruk, "yer": yer, "kod": hedef["kod"], "adim2": hedef["adim2"], "nesne": hedef["nesne"], "durum": hedef["durum"]}) def birlestir(belgeler, kuyruk): d = list(YONERGE) for b in belgeler: d += b return d + kuyruk uz = [len(birlestir(x["belgeler"], x["kuyruk"])) for x in VERI] print(f"kurgu belge dagarcigi {len(DAGARCIK)} belge, her biri" f" {len(DAGARCIK[0]['dizi'])} belirtec") print(f"{TALEP} istem: {min(uz)}-{max(uz)} belirtec, ortalama {sum(uz) / TALEP:.1f};" f" belge sayisi {min(len(x['belgeler']) for x in VERI)}" f"-{max(len(x['belgeler']) for x in VERI)}") print(f"pencere {PENCERE} belirtec; pencereyi asan istem" f" {sum(u > PENCERE for u in uz) / TALEP:.4f}") print("\n" + " ".join(DAGARCIK[9]["dizi"])) print(" ".join(VERI[0]["kuyruk"])) ``` ``` kurgu belge dagarcigi 24 belge, her biri 28 belirtec 300 istem: 152-432 belirtec, ortalama 282.3; belge sayisi 4-14 pencere 256 belirtec; pencereyi asan istem 0.5967 belge 110 : sayac eksik kod C2 adim 1 bilgi gonder adim 2 bilgi gonder adim 3 kaydi ac adim 4 muhur degistir adim 5 tarife karsilastir son talep : hat durumu eski , cevap bekliyorum . soru : bu talebin kodu ve ikinci adimi nedir ? ``` Ortalama istem 282,3 belirteçtir ve pencere 256'dır: **istemlerin 0,5967'si sığmaz.** Bu oran düzeneğin bir özelliğidir, modelin değil. Belge sayısı 4'ten 14'e çıkarken istem 152 belirteçten 432'ye uzuyor ve sınırın hangi tarafında kalınacağını istemi kuran yordam belirliyor. #### Üç Kırpma Kararı Kararlar belge bütünlüğünde çalışır. Baştan atmak en eski belgeyi, ortadan atmak listenin ortasındakini düşürür; özetlemek hiçbir belgeyi atmaz ama her birinden yalnız başlığı bırakır. Dördüncü bir karar ikisini birleştirir: hepsini özetle, sonra bütçe elverdiği kadar son belgeleri tam hâline geri koy. ```python def bastan_at(x, p): bl = list(x["belgeler"]) while len(bl) > 1 and len(birlestir(bl, x["kuyruk"])) > p: bl.pop(0) return birlestir(bl, x["kuyruk"]) def ortadan_at(x, p): bl = list(x["belgeler"]) while len(bl) > 1 and len(birlestir(bl, x["kuyruk"])) > p: bl.pop(len(bl) // 2) return birlestir(bl, x["kuyruk"]) def ozetle(x, p): return birlestir([b[:7] for b in x["belgeler"]], x["kuyruk"]) def ozetle_ve_koru(x, p): bl = [b[:7] for b in x["belgeler"]] for i in range(len(bl) - 1, -1, -1): deneme = bl[:i] + [x["belgeler"][i]] + bl[i + 1:] if len(birlestir(deneme, x["kuyruk"])) > p: break bl = deneme return birlestir(bl, x["kuyruk"]) def yanitla(dizi, nesne, durum): kod = adim = None for i in range(len(dizi) - 6): if (dizi[i] == "belge" and dizi[i + 3] == nesne and dizi[i + 4] == durum and dizi[i + 5] == "kod"): kod = dizi[i + 6] for j in range(i + 7, len(dizi) - 3): if dizi[j] == "son": break if dizi[j] == "adim" and dizi[j + 1] == "2": adim = dizi[j + 2:j + 4] break break return kod, adim def cagir(istem, tohum, i): """Benzeticinin basarisizliklari: pencere asimi kesin, zaman asimi istem uzunluguyla birlikte buyuyen bir paydir.""" if len(istem) > PENCERE: return "pencere" return "zaman" if uretec(tohum + i)() < 0.02 + 0.06 * len(istem) / PENCERE else None def olc(ad, kirp, tohum=TOHUM, yaz=True): bel = pen = zam = kd = ad2 = tam = 0 for i, x in enumerate(VERI): istem = kirp(x, PENCERE) if kirp else birlestir(x["belgeler"], x["kuyruk"]) bel += len(istem) h = cagir(istem, tohum, i) pen += h == "pencere" zam += h == "zaman" if h: continue k, a = yanitla(istem, x["nesne"], x["durum"]) kd += k == x["kod"] ad2 += a == x["adim2"] tam += k == x["kod"] and a == x["adim2"] n = len(VERI) if yaz: print(f"{ad:<22} {bel / n:>8.1f} {pen / n:>8.4f} {zam / n:>7.4f}" f" {kd / n:>7.4f} {ad2 / n:>7.4f} {tam / n:>7.4f}") return tam / n print(f"{'karar':<22} {'belirtec':>8} {'pencere':>8} {'zaman':>7}" f" {'kod':>7} {'adim':>7} {'tam':>7}") KARARLAR = [("ciplak cagri", None), ("bastan at", bastan_at), ("ortadan at", ortadan_at), ("ozetle", ozetle), ("ozetle ve kuyrugu koru", ozetle_ve_koru)] for ad, f in KARARLAR: olc(ad, f) ``` ``` karar belirtec pencere zaman kod adim tam ciplak cagri 282.3 0.5967 0.0200 0.3833 0.3833 0.3833 bastan at 217.5 0.0000 0.0600 0.7433 0.7433 0.7433 ortadan at 217.5 0.0000 0.0600 0.7367 0.7367 0.7367 ozetle 100.6 0.0000 0.0333 0.9667 0.0000 0.0000 ozetle ve kuyrugu koru 221.9 0.0000 0.0633 0.9367 0.7167 0.7167 ``` **Çıplak çağrı** 282,3 belirteç harcar ve tam yanıt oranı 0,3833'tür. Kaybın kaynağı isabet değil, **başarısızlıktır**: çağrıların 0,5967'si pencereye sığmadığı için hiç yanıt vermez. Sınıra çarpan bir çağrı yanlış cevap üretmez, hiçbir cevap üretmez. **Baştan atmak** en yalın kırpmadır: belirteci 217,5'e indirir, pencere hatasını sıfırlar ve tam yanıtı 0,7433'e çıkarır. **Bedel** üç kalemdir — atılan belgeler, ek bir kırpma adımı ve zaman aşımı payının 0,0200'den 0,0600'e çıkması. Bu son kalem sezgiye aykırıdır: kırpma ortalama istemi kısaltmadı, **uzattı**, çünkü daha önce hiç gönderilemeyen uzun istemler artık gönderiliyor. **Özetlemek** en ucuz karardır: 100,6 belirteç, çıplak çağrının 0,3564'ü. Kod isabetini 0,9667'ye çıkarır — bütün belge başlıkları durduğu için doğru kod her zaman bulunur. Adım isabeti ise **0,0000**'dır ve tam yanıt oranı da sıfırdır. Özet, sorulan şeyi atmıştır. **Bir özetin ne kadar kaybettirdiği özetin kendisinden değil, sorudan okunur.** Dördüncü karar iki ölçütte iki ayrı cevap veriyor: kod isabetinde 0,9367 ile baştan atmanın 0,7433'ünü açık ara geçiyor, tam yanıtta 0,7167 ile onun altında kalıyor ve 4,4 belirteç daha pahalı. **Hangisinin kazandığı hangi sütunun okunduğuna bağlıdır** ve sütun seçimi ürün kararıdır. #### Kırpma Nereyi Kesiyor Kırpmanın isabeti tek bir sayıya sığmaz: kararın hangi belgeyi attığı, aranan kanıtın nerede durduğuna göre isabetli ya da yıkıcıdır. ```python KARARLAR = [("bastan at", bastan_at), ("ortadan at", ortadan_at), ("ozetle", ozetle), ("ozetle ve kuyrugu koru", ozetle_ve_koru)] def kova(x): n = len(x["belgeler"]) return 0 if x["yer"] < n / 3 else (1 if x["yer"] < 2 * n / 3 else 2) print(f"{'karar':<22} {'bas':>7} {'orta':>7} {'son':>7} {'kosum 2':>9}") for ad, f in KARARLAR: d, t = [0, 0, 0], [0, 0, 0] for i, x in enumerate(VERI): istem = f(x, PENCERE) j = kova(x) t[j] += 1 if cagir(istem, TOHUM, i): continue k, a = yanitla(istem, x["nesne"], x["durum"]) d[j] += k == x["kod"] and a == x["adim2"] ik = olc(ad, f, TOHUM + 7000, False) print(f"{ad:<22} " + " ".join(f"{a / b:>7.4f}" for a, b in zip(d, t)) + f" {ik:>9.4f}") print("kova basina talep" + "".join(f"{t[j]:>8}" for j in range(3)).rjust(28)) print(f"\n{'pencere':>8} {'bastan at':>11} {'ozetle ve koru':>15} {'ozetle':>8}") for p in (128, 192, 256, 384): s = [] for f in (bastan_at, ozetle_ve_koru, ozetle): dog = 0 for i, x in enumerate(VERI): istem = f(x, p) if len(istem) > p: continue k, a = yanitla(istem, x["nesne"], x["durum"]) dog += k == x["kod"] and a == x["adim2"] s.append(dog / len(VERI)) print(f"{p:>8} {s[0]:>11.4f} {s[1]:>15.4f} {s[2]:>8.4f}") ``` ``` karar bas orta son kosum 2 bastan at 0.5351 0.8235 0.9286 0.7367 ortadan at 0.9474 0.3627 0.9048 0.7000 ozetle 0.0000 0.0000 0.0000 0.0000 ozetle ve kuyrugu koru 0.5439 0.7353 0.9286 0.7000 kova basina talep 114 102 84 pencere bastan at ozetle ve koru ozetle 128 0.3767 0.2400 0.0000 192 0.6367 0.6100 0.0000 256 0.8000 0.7667 0.0000 384 0.9867 0.9833 0.0000 ``` İlk üç sütun kararların birbirine yakın toplam sayılarının içini açıyor. Baştan atmak baş kovada 0,5351, son kovada 0,9286 verir; ortadan atmak baş kovada 0,9474'e çıkar ama orta kovada 0,3627'ye düşer. **İki kararın toplam isabeti neredeyse aynıdır (0,7433 ve 0,7367) ve hata dağılımları birbirinin tersidir.** Bir ürün için bunlar aynı karar değildir: kanıt eski kayıtlarda duruyorsa baştan atmak sistematik olarak yanılır, akışın ortasında duruyorsa ortadan atmak. Son sütun aynı düzeneğin ikinci koşumudur. Yalnız zaman aşımı kurası değişti ve baştan atmak 0,7433 yerine 0,7367, ortadan atmak 0,7367 yerine 0,7000 verdi. **Aynı kırpma kararı, aynı veri, iki koşum, iki sayı.** Kararlar arasındaki 0,0066'lık fark bu değişkenliğin altında kalır: tek koşumla okunan bu tablo baştan atmayı kazandırırdı, ikinci koşum ikisini eşitler. Alt tablo başarısızlık payını dışarıda bırakır ve koşumdan bağımsızdır. Pencere 128'den 384'e çıktıkça baştan atmanın tam yanıtı 0,3767'den 0,9867'ye yükselir: kırpma kararının tamamı, penceredeki eksikliği kapatma çabasıdır ve pencere yeterince büyükse hiçbir karar gerekmez. Özetlemenin sütunu her pencerede 0,0000'dır — **pencereden kaynaklanmayan bir kayıp pencere büyütülerek kapanmaz.** Kaybedilen bilgi istemin dışında kaldığı sürece sınır ne olursa olsun geri gelmez ve bu iki tabloyu ayıran soru şudur: kayıp sınırdan mı, yoksa sınırı karşılamak için verilen karardan mı doğuyor. #### Özet - Bağlam penceresi sabit bir sınırdır; aşıldığında bu benzetici hiç yanıt vermez. Çıplak çağrıda istemlerin 0,5967'si sığmaz ve tam yanıt oranı 0,3833'te kalır. Belgeler ve talepler kurgudur, tohum 20260218. - Baştan atmak istemi 282,3'ten 217,5 belirtece indirir ve tam yanıtı 0,7433'e çıkarır. Bedeli atılan belgeler, ek bir adım ve zaman aşımı payının 0,0200'den 0,0600'e çıkmasıdır. - Özetlemek en ucuz karardır (100,6 belirteç) ve kod isabetini 0,9667'ye çıkarır, ama sorulan adımı attığı için tam yanıt oranı 0,0000'dır. - Kırpmanın isabeti kanıtın yerine bağlıdır: baştan atmak baş kovada 0,5351, ortadan atmak orta kovada 0,3627 verir. Toplam sayıları neredeyse aynıdır, hata dağılımları terstir. - Aynı düzenek ikinci koşumda 0,7433 yerine 0,7367 verir; kararlar arasındaki fark bu değişkenliğin altındadır. Pencere 128'den 384'e çıktığında tam yanıt 0,3767'den 0,9867'ye yükselir. #### Sonraki Adım Beş derste modelin yüzeyi ölçüldü: hangi birimle çalıştığı, uzak bağlamı niçin kullanabildiği, neyi nereden öğrendiği, yanıtı nasıl ürettiği ve sınırının nerede olduğu. Pencere bir sınırdır ve nasıl doldurulacağı bir karardır — bu ders o kararın üç biçimini sayıyla karşılaştırdı. Ama şimdiye kadar hep aynı varsayım altında çalışıldı: doğru bilgi isteme konursa modelin onu doğru kullanacağı. Modelin **neyi iyi yaptığı** hiç sorulmadı. Sonraki ders bir görev kümesini görev sınıflarına ayırır ve düzeneksiz çağrının hangi sınıfta çöktüğünü sayar. ### Yetenekler ve Sınırlar Source: https://academia.sh/tr/kurslar/yz-muhendisligine-giris/yetenekler-ve-sinirlar Yirmi dört kurgu destek talebinde beş görev sınıfının düzeneksiz çağrıyla ölçülmesi: özetleme 0,7500, sınıflandırma 0,8750, sıralama 0,6250, sayma 0,4167 ve kesin hesap 0,2917. Tohum değiştirildiğinde ilk üç sınıfın sayısı oynuyor, son ikisi hiç oynamıyor ve yanıtı değişen istek sayısı 0/24 çıkıyor. Sayma isabeti çekimli biçim taşımayan 10/24 isteğe, kesin hesap isabeti öbek sınırını aşan taşıma taşımayan 7/24 isteğe birebir eşit. Üç koşumlu çoğunluk düzeneği üç kat belirteçle bu iki sınıfta hiçbir şey değiştirmiyor, hesabı belirteç dışına çıkaran yordam düzeneği ikisini de 1,0000'a taşıyor. Önceki ders bağlam penceresini bir sınır olarak ölçtü ve pencerenin nasıl doldurulacağının bir karar olduğunu gösterdi. Kırpma kararları kaç belirteç kazandırıyor ve isabeti ne kadar düşürüyor sorusu yanıtlandı. Sorulmayan şey daha önce gelir: pencereye ne konulursa konulsun, modelin **neyi iyi yaptığı** hiç ölçülmedi. Bir görev iyi gitmiyorsa suç istemde mi, pencerede mi, yoksa görevin kendisinde mi. Bu ders beş görev sınıfını aynı veriyle, aynı düzeneksiz çağrıyla koşturur ve isabeti sınıf başına yazar. İki sınıfta sayı çöker ve çöküşün kaynağı istemde değil **belirteç düzeyindedir**. - **DL46. Kurgu talep kümesi 24 kısa Türkçe destek talebidir.** Talepler beş ana tümce ile altı ek tümcenin birleşiminden üretilir ve her talebin sonunda iki sayaç okuması durur. Metinler, sınıflar ve okumalar **kurgudur**. - **DL47. Model bir benzeticidir**; gerçek bir uç nokta çağrılmaz. Benzetici standart kitaplıkla yazılmıştır, tohumu **20260218**'dir ve yanıtını yalnız belirteç dizisinden üretir. - **DL48. Belirteçleyici kurgudur** ve bu konunun ilk dersinde kurulan ölçüyü sürdürür: harf öbekleri dörder, rakam öbekleri ikişer bölünür. - **DL49. Beş görev sınıfı ölçülür:** özetleme, sınıflandırma, sıralama, sayma ve kesin hesap. Her sınıfın ölçüsü **isabettir**: yirmi dört istekte kaçında yanıt doğru. - **DL50. Bedel üç birimle yazılır:** istek başına giriş belirteci, çağrı sayısı ve gecikme sınıfı. Ham süre yazılmaz. - **DL51. Belirsizlik iki koşumla ölçülür.** Aynı görev kümesi tohum 20260218 ve tohum 20260219 ile koşturulur; ayrıca iki koşumda **yanıtı değişen istek sayısı** basılır. #### Beş Görev Sınıfında Çıplak Çağrı ```python # ORTAK -- KURGUDUR. Asagidaki benzetici gercek bir uc nokta cagirmaz; standart # kitaplikla yazilmistir ve bir dil modelinin olculebilir yuzeyini tasir. TOHUM, M32 = 20260218, 0xFFFFFFFF 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): """Kurgu belirtecleyici: harf obekleri dorder, rakam obekleri ikiser bolunur.""" cikti, tampon = [], "" for ch in metin + " ": if ch.isalnum(): tampon += ch continue if tampon: n = 2 if tampon.isdigit() else 4 cikti += [tampon[i:i + n] for i in range(0, len(tampon), n)] tampon = "" if ch.strip(): cikti.append(ch) return cikti BAS = [ # (ana tumce, gercek sinif) ("sayac okunmadi tahmini fatura cikti", "olcum"), ("fatura tutari gecen aya gore iki kat cikti", "odeme"), ("gece boyunca su basinci dustu", "tesisat"), ("planli kesinti bildirimi ulasmadi", "kesinti"), ("abonelik devri sayaca islenmedi", "sozlesme"), ] EK = ["sayacin numarasi degistirilmis olabilir", "adres bilgisi eski gorunuyor", "onceki ay ayni sorun yasanmadi", "sayaca ulasilamiyor kapi kapali", "kesinti suresi beklenenden uzun surdu", "otomatik talimat sayacta yok"] SOZLUK = { # sinif -> benzeticinin tanidigi obekler ve kurgu oncelik "kesinti": ({"kesi", "bild"}, 1), "olcum": ({"okun", "olcu", "tahm"}, 2), "tesisat": ({"basi", "vana", "tesi", "dust"}, 3), "odeme": ({"fatu", "odem", "tuta", "tali"}, 4), "sozlesme": ({"abon", "devr", "sozl", "adre"}, 5), } SINIFLAR = list(SOZLUK) GOREV = {"ozetleme": 11, "siniflandirma": 23, "siralama": 41, "sayma": 59, "kesin_hesap": 71} ORN = {} TALEP = [] for i in range(24): r = uretec(TOHUM + 31 * i) a, b = 100000 + int(r() * 380000), 100000 + int(r() * 380000) TALEP.append({"no": 4100 + i, "sinif": BAS[i % 5][1], "a": a, "b": b, "ana": BAS[i % 5][0], "ek": EK[(5 * i + 2) % 6], "metin": f"{BAS[i % 5][0]}, {EK[(5 * i + 2) % 6]}." f" ana sayac {a} ara sayac {b}."}) def ornek(gorev, tohum, t): """Ornekleme cizelgesi: gorev ve tohum basina tek akis, istek basina tek deger.""" if (gorev, tohum) not in ORN: r = uretec(tohum + 1009 * GOREV[gorev]) ORN[(gorev, tohum)] = [r() for _ in range(24)] return ORN[(gorev, tohum)][t["no"] - 4100] def cagir(gorev, t, tohum, ornekleme=True): """Benzetici: yaniti yalniz belirtec dizisinden uretir. Aday arasindan secim yapilan gorevlerde ornekleme ikinci adayi getirebilir; sayma ile kesin hesap aday uretmez, belirtec dizisi uzerinde tek yol izler.""" bel = belirtecle(t["metin"]) if gorev == "sayma": return bel.count("saya") if gorev == "kesin_hesap": p = [(str(t["a"])[k:k + 2], str(t["b"])[k:k + 2]) for k in range(0, 6, 2)] return int("".join(f"{(int(x) + int(y)) % 100:02d}" for x, y in p)) r = ornek(gorev, tohum, t) if gorev == "ozetleme": # ozete hangi tumce girecek tumce = sorted([t["ana"], t["ek"]], key=lambda c: -len(belirtecle(c))) return tumce[1] if ornekleme and r < 0.14 else tumce[0] puan = sorted(SINIFLAR, key=lambda s: (-sum(b in SOZLUK[s][0] for b in bel), s)) return puan[1] if ornekleme and r < 0.14 else puan[0] def olc(tohum, ornekleme=True): d, dizi = {}, 0 d["ozetleme"] = sum(cagir("ozetleme", t, tohum, ornekleme) == t["ana"] for t in TALEP) / 24 d["siniflandirma"] = sum(cagir("siniflandirma", t, tohum, ornekleme) == t["sinif"] for t in TALEP) / 24 for g in range(24): uc = [TALEP[g], TALEP[(g + 7) % 24], TALEP[(g + 13) % 24]] gercek = [t["no"] for t in sorted(uc, key=lambda t: (SOZLUK[t["sinif"]][1], t["no"]))] tahmin = [t["no"] for t in sorted(uc, key=lambda t: ( SOZLUK[cagir("siralama", t, tohum, ornekleme)][1], t["no"]))] dizi += gercek == tahmin d["siralama"] = dizi / 24 d["sayma"] = sum(cagir("sayma", t, tohum) == t["metin"].replace(",", " ") .replace(".", " ").split().count("sayac") for t in TALEP) / 24 d["kesin_hesap"] = sum(cagir("kesin_hesap", t, tohum) == t["a"] + t["b"] for t in TALEP) / 24 return d A, B = olc(TOHUM), olc(TOHUM + 1) ORT = sum(len(belirtecle(t["metin"])) for t in TALEP) / 24 print(f"kurgu gorev kumesi: {len(TALEP)} destek talebi, bes gorev sinifi") print(f"istek basina giris belirteci {ORT:.1f}, cagri 1, gecikme sinifi tek cagri") print("gorev tohum 20260218 tohum 20260219 yaniti degisen istek") for g in GOREV: fark = sum(str(cagir(g, t, TOHUM)) != str(cagir(g, t, TOHUM + 1)) for t in TALEP) print(f"{g:<14} {A[g]:.4f} {B[g]:.4f} {fark:>2}/24") ``` ``` kurgu gorev kumesi: 24 destek talebi, bes gorev sinifi istek basina giris belirteci 33.3, cagri 1, gecikme sinifi tek cagri gorev tohum 20260218 tohum 20260219 yaniti degisen istek ozetleme 0.7500 0.6667 4/24 siniflandirma 0.8750 0.8750 2/24 siralama 0.6250 0.4583 11/24 sayma 0.4167 0.4167 0/24 kesin_hesap 0.2917 0.2917 0/24 ``` Sayı sınıftan sınıfa düşüyor: sınıflandırma **0,8750**, özetleme **0,7500**, sıralama **0,6250**, sayma **0,4167**, kesin hesap **0,2917**. Aynı model, aynı istek, aynı belirteç sayısı. Değişen tek şey görevin ne istediği. Sıralamanın üstteki üçlü içinde en düşük sayıyı vermesinin kendi nedeni var. Sıralama tek bir karar değil, üç kararın birleşimidir: benzetici her talebi ayrı ayrı sınıflandırır ve üçlüyü sınıfların önceliğine göre dizer. Tek bir talepte yapılan hata bütün diziyi bozduğu için, sınıf başına 0,8750 olan isabet üçlü başına 0,6250'ye iniyor. Bileşik görevlerin sayısı bileşenlerinin sayısından her zaman düşüktür ve bu ders boyunca sürecek bir kuraldır. Üstteki üç sınıfın ortak yanı da görülüyor: hepsi bir **seçim** görevidir. Özetleme iki tümceden birini, sınıflandırma beş etiketten birini, sıralama üç talebin dizilişini seçiyor. Seçim görevlerinde belirteç yüzeyi yeterli bilgiyi taşıyor, çünkü doğru yanıt zaten metnin içinde bir yerde duruyor. Alttaki iki sınıf ise **üretim** görevidir: doğru yanıt metnin içinde bulunmuyor, metinden hesaplanması gerekiyor. Ayrımı gösteren şey ise ölçünün kendisi değil, ölçünün nasıl alındığıdır. Son sütun bunu tek başına söylüyor. İlk üç sınıfta tohum değişince yanıtı değişen istek var: sıralamada **11/24**, özetlemede **4/24**, sınıflandırmada **2/24**. Sınıflandırmanın iki koşumdaki isabeti aynı çıkıyor ama **aynı isteklerde değil**: iki istek yanıt değiştirdi, biri düzeldi biri bozuldu. Son iki sınıfta ise fark **0/24**. Sayma ve kesin hesap iki koşumda **birebir aynı yanlış yanıtı** veriyor. Bu, örneklemenin gürültüsü değil. #### Sayma ve Kesin Hesabın Belirteç Düzeyindeki Kaynağı ```python def cekimli(m): return [w for w in m.replace(",", " ").replace(".", " ").split() if w.startswith("sayac") and w != "sayac"] t = TALEP[4] print("talep:", t["ana"] + ",", t["ek"]) print("belirtec:", " ".join(belirtecle(t["ana"]))) gercek = t["metin"].replace(",", " ").replace(".", " ").split().count("sayac") print(f"sayac gecisi: gercek {gercek}, benzetici {cagir('sayma', t, TOHUM)}," f" cekimli bicim {cekimli(t['metin'])}") print(f"toplama: {t['a']} + {t['b']} = {t['a'] + t['b']}," f" benzetici {cagir('kesin_hesap', t, TOHUM)}") tasima = sum(any(int(str(x["a"])[k:k + 2]) + int(str(x["b"])[k:k + 2]) > 99 for k in (2, 4)) for x in TALEP) cekim = sum(bool(cekimli(x["metin"])) for x in TALEP) print(f"obek sinirini asan tasima tasiyan istek {tasima}/24 -> kalan {24 - tasima}/24") print(f"cekimli sayac bicimi tasiyan istek {cekim}/24 -> kalan {24 - cekim}/24") ``` ``` talep: abonelik devri sayaca islenmedi, kesinti suresi beklenenden uzun surdu belirtec: abon elik devr i saya ca isle nmed i sayac gecisi: gercek 2, benzetici 3, cekimli bicim ['sayaca'] toplama: 139039 + 302204 = 441243, benzetici 431243 obek sinirini asan tasima tasiyan istek 17/24 -> kalan 7/24 cekimli sayac bicimi tasiyan istek 14/24 -> kalan 10/24 ``` Sayma önce. Model, metinde sözcük görmüyor; öbek görüyor. `sayaca` sözcüğü `saya` ve `ca` öbeklerine bölünüyor, `sayac` sözcüğü de `saya` ile başlıyor. Belirteç dizisinde ikisi aynı başlangıcı paylaştığı için model çekimli biçimi de sayıyor ve **2** yerine **3** yazıyor. Türkçenin eklemeli yapısı bunu istisna değil kural yapıyor: çekimli bir sayaç biçimi taşıyan istek **14/24**, taşımayan **10/24**. Sayma isabeti **0,4167**, yani tam olarak **10/24**. Model sayamadığı için değil, **sayacağı birimi göremediği için** yanılıyor. Kesin hesap aynı kusurun sayı tarafı. `139039` okuması `13`, `90`, `39` öbeklerine bölünüyor. Model öbekleri karşılıklı topluyor ve her öbeği iki basamakta tutuyor: `90 + 22` sonucu `112` olduğunda üçüncü basamak, yani **taşıma**, bir sonraki öbeğe geçemiyor çünkü o öbek zaten yazılmış durumda. Çıkan sayı **431243**, doğrusu **441243**: fark tam olarak kaybolan taşımadır. Öbek sınırını aşan taşıma taşıyan istek **17/24**, taşımayan **7/24**. Kesin hesap isabeti **0,2917**, yani tam olarak **7/24**. İki sayı da veriden değil **belirteçlemeden** geliyor; tohum değiştirmek onları oynatmıyor. #### Çöken Sınıfa Düzenek Eklemek ```python DOGRU = {"siniflandirma": lambda t: t["sinif"], "kesin_hesap": lambda t: t["a"] + t["b"], "sayma": lambda t: t["metin"].replace(",", " ").replace(".", " ") .split().count("sayac")} def cogunluk(gorev): # duzenek 1: uc kosum, cogunluk yaniti s = 0 for t in TALEP: y = [cagir(gorev, t, th) for th in (TOHUM, TOHUM + 1, TOHUM + 2)] s += max(y, key=y.count) == DOGRU[gorev](t) return s / 24 def yordamla(gorev, t): """Duzenek 2: model degeri ayiklar, hesabi belirtec disinda bir yordam yapar.""" if gorev == "kesin_hesap": sayi, o, bel = [], 0, belirtecle(t["metin"]) while o < len(bel): # bitisik rakam obekleri tek sayi p = "" while o < len(bel) and bel[o].isdigit(): p, o = p + bel[o], o + 1 o += 1 if not p else 0 if p: sayi.append(int(p)) return sum(sayi[:2]) return sum(w == "sayac" for w in t["metin"].replace(",", " ").replace(".", " ").split()) print("gorev ciplak cogunluk yordam") for g in ("siniflandirma", "sayma", "kesin_hesap"): y = (" - " if g == "siniflandirma" else f"{sum(yordamla(g, t) == DOGRU[g](t) for t in TALEP) / 24:.4f}") print(f"{g:<14} {olc(TOHUM)[g]:.4f} {cogunluk(g):.4f} {y}") ek = sum(len(belirtecle(str(DOGRU['kesin_hesap'](t)))) for t in TALEP) / 24 print(f"bedel -- ciplak cagri: {ORT:.1f} belirtec, 1 cagri, gecikme sinifi tek cagri") print(f"bedel -- cogunluk: {3 * ORT:.1f} belirtec, 3 cagri, gecikme sinifi paralel") print(f"bedel -- yordam: {2 * ORT + ek:.1f} belirtec, 2 cagri, gecikme sinifi zincir") ``` ``` gorev ciplak cogunluk yordam siniflandirma 0.8750 0.9167 - sayma 0.4167 0.4167 1.0000 kesin_hesap 0.2917 0.2917 1.0000 bedel -- ciplak cagri: 33.3 belirtec, 1 cagri, gecikme sinifi tek cagri bedel -- cogunluk: 99.9 belirtec, 3 cagri, gecikme sinifi paralel bedel -- yordam: 69.6 belirtec, 2 cagri, gecikme sinifi zincir ``` Çoğunluk düzeneği aynı isteği üç tohumla çağırıp en sık gelen yanıtı alıyor. Sınıflandırmada işe yarıyor: **0,8750** sayısı **0,9167**'ye çıkıyor, çünkü oradaki hata örneklemeden geliyor ve üç koşumun ikisi doğruyu tutuyor. Sayma ve kesin hesapta ise sayı **kılını kıpırdatmıyor**: 0,4167 ve 0,2917 aynen kalıyor. Bedel gerçek ve peşin, çağrı sayısı üçe, belirteç **99,9**'a çıkıyor. Yapısal bir hatanın üstüne konan istatistiksel düzenek, hatayı üç kez tekrarlamaktan başka bir şey yapmıyor. İkinci düzenek işi belirteç katmanının dışına taşıyor: model yalnız sayıları ayıklıyor, toplamayı ve saymayı bir yordam yapıyor. İsabet iki sınıfta da **1,0000**. Bedel iki çağrı, **69,6** belirteç ve **zincir** gecikme sınıfıdır — çünkü ikinci çağrı birincinin sonucunu beklemek zorundadır, çoğunluk düzeneğinin üç çağrısı ise paralel gidebilir. Daha ucuz olan düzenek kazandıran düzenektir: çoğunluk 99,9 belirteçle hiçbir şey vermiyor, yordam 69,6 belirteçle sınıfı tamamen düzeltiyor. Bedeli yazmadan bu iki düzenek birbirinden ayrılamazdı. #### Özet - Beş görev sınıfı aynı kurgu talep kümesinde düzeneksiz çağrıyla ölçülünce isabet 0,8750'den 0,2917'ye iniyor: sınıflandırma 0,8750, özetleme 0,7500, sıralama 0,6250, sayma 0,4167, kesin hesap 0,2917. - Tohum değiştiğinde ilk üç sınıfta yanıtı değişen istek var (11/24, 4/24, 2/24), son iki sınıfta 0/24; sayma ve kesin hesabın hatası örnekleme gürültüsü değil. - Sayma isabeti çekimli biçim taşımayan 10/24 isteğe, kesin hesap isabeti öbek sınırını aşan taşıma taşımayan 7/24 isteğe birebir eşittir; iki sayı da belirteçlemeden gelir. - Üç koşumlu çoğunluk düzeneği sınıflandırmayı 0,9167'ye taşıyor ama sayma ile kesin hesapta hiçbir şey değiştirmiyor; bedeli 99,9 belirteç ve üç çağrıdır. - Hesabı belirteç katmanının dışına çıkaran yordam düzeneği iki sınıfı da 1,0000'a taşıyor; bedeli 69,6 belirteç, iki çağrı ve zincir gecikme sınıfıdır. #### Sonraki Adım Bu derste ölçülen yanlışlar bir bakıma dürüsttü: model sayamadığında yanlış bir sayı yazdı ve yanlış olduğu tek satırda görüldü. Sonraki ders daha zor bir yanlış türünü ele alır. Model bir soruya, elinde hiçbir dayanak yokken de **akıcı ve kendinden emin** bir yanıt üretir; yanıtın biçimi doğru olanla aynıdır ve yanlışlığı yanıtın kendisine bakarak anlaşılmaz. Bunun ölçüsü isabet değil **uydurma oranıdır**: yanıttaki kaç iddia bir belgeye dayanıyor. Aynı ders, müfredatın ikinci iddiasını ilk kez gösterir: uydurmayı azaltmak için eklenen üç düzenekten biri, uydurmayı gerçekten düşürürken **isabeti de düşürür** ve bu saklanmaz. ### Halüsinasyon Source: https://academia.sh/tr/kurslar/yz-muhendisligine-giris/halusinasyon Yirmi yedi olguluk kurgu belge dağarcığında yirmi dört soru sorulunca kaynaksız yanıtın isabeti 0,2917, uydurma oranı 0,6667 çıkıyor ve iki koşumda 16/24 istekte yanıt değişiyor. Üç azaltma yan yana ölçülüyor: kaynağa bağlama isabeti +0,3750 artırıp uydurmayı 0,3333'e indiriyor, iddia doğrulama uydurmayı 0,0857'ye indiriyor ama bedeli iki çağrı ve 55,5 belirteç, bilmiyorum seçeneği ise isabeti tabanın 0,0417 altına düşürüyor ve 10/24 isteği yanıtsız bırakıyor. Kaynağa bağlamadan sonra kalan dayanaksız iddianın tamamı belgede karşılığı olmayan sorulardan geliyor ve doğrulama düzeneği iki koşumda 0/24 fark veriyor. Önceki dersin yanlışları görünürdü: model bir toplamı yanlış yazdığında sonuç tek satırda denetlenebiliyordu. Bu dersin yanlışı görünmüyor. Model, elinde hiçbir dayanak yokken de akıcı ve kurallı bir yanıt üretir; yanlış yanıtın biçimi doğru yanıtınkiyle aynıdır, aynı kesinlikte yazılır ve yanıtın kendisine bakarak ayrılamaz. Buna **halüsinasyon** denir. Ölçüsü isabet değildir, çünkü isabet yalnız son değeri sorar ve bir yanıt tek bir değerden ibaret değildir: sorulanın yanına konulan gerekçeler, sayılar ve yan bilgiler de yanıtın parçasıdır ve kullanıcı onları da okur. Ölçü bu yüzden **uydurma oranıdır**: yanıtta geçen kaç iddia bir belgeye dayanıyor. Bu ders üç azaltma düzeneğini aynı veride yan yana koyar, her birinin bedelini belirteç ve çağrı olarak yazar ve müfredatın ikinci iddiasını ilk kez gösterir — üçünden biri sayıyı **düşürür** ve bu tabloda saklanmaz. - **DL52. Kurgu belge dağarcığı** tarife açıklamaları, sayaç bakım yordamları ve arıza kodlarından oluşur. Her olgu bir `(konu, alan, değer)` üçlüsüdür ve **kurgudur**. - **DL53. Yirmi dört soru sorulur.** Soruların bir kısmının karşılığı dağarcıkta vardır, bir kısmının yoktur; bu ayrım ölçünün merkezindedir. - **DL54. Benzeticinin iki ayrı bilgi kaynağı vardır:** istemin içine konan **belge** ve **önceden edinilmiş kurgu bilgi**. İkincisi dağarcıkla kısmen çelişir. - **DL55. Her yanıt iki iddia taşır:** sorulan alan ve yanına eklenen ikinci bir alan. Bir iddia, dağarcıkta birebir aynı üçlü varsa **dayanaklıdır**. - **DL56. İki sayı yan yana yazılır.** İsabet, sorulan alanın değerinin belgeyle uyuşan istek oranıdır; yanıtsız kalan istek isabetli sayılmaz. Uydurma oranı, üretilen bütün iddialar içinde dayanaksız olanların payıdır. - **DL57. Belirsizlik iki koşumla ölçülür.** Belgeden okunan değer kopyalanır, bellekten gelen değer **örneklemeye açıktır**; tohum 20260219 ile ikinci koşum alınır. #### Kaynaksız Yanıtta Uydurma Oranı ```python # ORTAK -- KURGUDUR. Benzetici gercek bir uc nokta cagirmaz; belge dagarcigi, sorular # ve modelin onceden edindigi bilgi standart kitaplikla, tohum 20260218 ile uretilir. TOHUM, M32 = 20260218, 0xFFFFFFFF 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): """Kurgu belirtecleyici: harf obekleri dorder, rakam obekleri ikiser bolunur.""" cikti, tampon = [], "" for ch in metin + " ": if ch.isalnum(): tampon += ch continue if tampon: n = 2 if tampon.isdigit() else 4 cikti += [tampon[i:i + n] for i in range(0, len(tampon), n)] tampon = "" if ch.strip(): cikti.append(ch) return cikti KONU = ["tarife ev", "tarife isyeri", "tarife bahce", "sayac bakim", "sayac degisim", "ariza e12", "ariza e31", "ariza e44", "kesinti planli", "kesinti acil", "abonelik devir", "abonelik iptal"] ALAN = ["esik", "sure", "adim", "belge"] BELGE, BELLEK, GUVEN, ORN = {}, {}, {}, {} r = uretec(TOHUM + 97) for k in KONU: # kurgu belge dagarcigi for a in ALAN: p, v = r(), 2 + int(r() * 40) if p < 0.55: BELGE[(k, a)] = v r = uretec(TOHUM + 8080) for k in KONU: # modelin onceden edindigi kurgu bilgi for a in ALAN: p, v = r(), 2 + int(r() * 40) d = BELGE.get((k, a)) BELLEK[(k, a)] = d if d is not None and p < 0.58 else v SORU = [(KONU[i % 12], ALAN[(3 * i + 1) % 4]) for i in range(24)] r = uretec(TOHUM + 4242) for i, (k, a) in enumerate(SORU): # kurgu guven: dogruyla kismen ortusur GUVEN[i] = (0.30 + 0.60 * r() if BELLEK[(k, a)] == BELGE.get((k, a)) else 0.10 + 0.60 * r()) ESIK = 0.55 def sapma(i, j, tohum): """Ornekleme cizelgesi: belgeden okunmayan her deger icin tek cekilis.""" if tohum not in ORN: r2 = uretec(tohum + 5551) ORN[tohum] = [r2() for _ in range(48)] return ORN[tohum][2 * i + j] def sor(i, duzenek, tohum): """Yanit bir iddia listesidir; her iddia (konu, alan, deger) uclusudur.""" k, a = SORU[i] yan = ALAN[(ALAN.index(a) + 2) % 4] if duzenek == "bilmiyorum" and GUVEN[i] < ESIK: return [] kaynak = BELGE if duzenek in ("baglama", "dogrulama") else {} iddia = [] for j, x in enumerate((a, yan)): if (k, x) in kaynak: # istemdeki belgeden okunur iddia.append((k, x, kaynak[(k, x)])) continue v = BELLEK[(k, x)] # bellekten gelen deger orneklemeye acik iddia.append((k, x, 2 + (v + 7) % 40 if sapma(i, j, tohum) < 0.25 else v)) if duzenek == "dogrulama": # ikinci cagri: her iddia belgede aranir r2 = uretec(TOHUM + 611 * i) iddia = [c for c in iddia if BELGE.get((c[0], c[1])) == c[2] or r2() < 0.10] return iddia def olc(duzenek, tohum=TOHUM): iddia_say = dayanaksiz = isabet = yanitsiz = 0 for i, (k, a) in enumerate(SORU): y = sor(i, duzenek, tohum) iddia_say += len(y) yanitsiz += not y dayanaksiz += sum(BELGE.get((c[0], c[1])) != c[2] for c in y) isabet += BELGE.get((k, a)) is not None and any( c[1] == a and c[2] == BELGE[(k, a)] for c in y) return isabet / 24, dayanaksiz / iddia_say if iddia_say else 0.0, iddia_say, yanitsiz KAPSANAN = sum((k, a) in BELGE for k, a in SORU) SB = sum(len(belirtecle(f"{k} icin {a} degeri nedir")) for k, a in SORU) / 24 BB = sum(len(belirtecle(f"{k} {a} degeri {v}")) for (k, a), v in BELGE.items()) / len(KONU) i1, u1, n1, _ = olc("ciplak") i2, u2, n2, _ = olc("ciplak", TOHUM + 1) print(f"kurgu belge dagarcigi {len(BELGE)} olgu, {len(SORU)} soru," f" belgede karsiligi olan {KAPSANAN}/24") print(f"ciplak cagri, tohum 20260218: isabet {i1:.4f}, uydurma {u1:.4f}, {n1} iddia") print(f"ciplak cagri, tohum 20260219: isabet {i2:.4f}, uydurma {u2:.4f}, {n2} iddia") degisen = sum(sor(i, "ciplak", TOHUM) != sor(i, "ciplak", TOHUM + 1) for i in range(24)) print(f"iki kosumda yaniti degisen istek {degisen}/24") print(f"bedel: istek basina {SB:.1f} belirtec, 1 cagri, gecikme sinifi tek cagri") ``` ``` kurgu belge dagarcigi 27 olgu, 24 soru, belgede karsiligi olan 16/24 ciplak cagri, tohum 20260218: isabet 0.2917, uydurma 0.6667, 48 iddia ciplak cagri, tohum 20260219: isabet 0.3333, uydurma 0.6667, 48 iddia iki kosumda yaniti degisen istek 16/24 bedel: istek basina 9.8 belirtec, 1 cagri, gecikme sinifi tek cagri ``` Çıplak çağrı yirmi dört isteğin hepsine yanıt veriyor ve **48 iddia** üretiyor. Bunların **0,6667**'si hiçbir belgeye dayanmıyor. İsabet **0,2917**. Dikkat edilecek şey iki sayının birbirinden bağımsız hareket edebilmesidir: ikinci koşumda isabet **0,3333**'e çıkarken uydurma oranı **0,6667**'de kalıyor. İsabet tek bir alanı, uydurma oranı yanıtın tamamını ölçer. Modelin yanıt vermeyi reddettiği tek bir istek yok. Yirmi dört sorunun **8**'inin dağarcıkta hiç karşılığı olmamasına rağmen sekizinin de yanıtı var. Bu, halüsinasyonun kaynağını doğrudan gösteriyor: benzetici, sorulan şeyi belgede aramıyor; **önceden edindiği kurgu bilgiden** en olası devamı üretiyor ve o bilgi hem eksik hem de dağarcıkla kısmen çelişik. Metnin akıcılığı, dayanağın varlığından bağımsızdır. Terimin kendisi burada bir uyarı gerektirir. Halüsinasyon bir **arıza adı değildir**: model bozulduğu için değil, tam da tasarlandığı işi yaptığı için uyduruyor. Yaptığı iş bir metnin olası devamını üretmektir ve olasılık dayanakla aynı şey değildir. Tabloda bunun karşılığı şudur: uydurma oranını düşüren hiçbir düzenek modelin içine dokunmuyor, hepsi yanıtın **çevresine** bir dayanak kaynağı ya da bir denetim adımı koyuyor. Bu ayrım tutulmazsa uydurma "bir gün düzelecek bir kusur" sanılır ve düzeneğin bedeli bütçeye hiç yazılmaz. #### Üç Azaltma Düzeneği ```python print("duzenek isabet uydurma iddia yanitsiz belirtec cagri gecikme") for d, bel, cg, gc in (("ciplak", SB, 1, "tek cagri"), ("baglama", SB + BB, 1, "tek cagri"), ("bilmiyorum", SB + 9, 1, "tek cagri"), ("dogrulama", 2 * (SB + BB), 2, "zincir ")): i, u, n, ys = olc(d) print(f"{d:<12} {i:.4f} {u:.4f} {n:>2} {ys:>2}/24 {bel:>5.1f} {cg}" f" {gc}") t1, t2 = olc("baglama")[0], olc("bilmiyorum")[0] print(f"taban ciplak cagri {i1:.4f}; baglama {t1 - i1:+.4f}, bilmiyorum {t2 - i1:+.4f}," f" dogrulama {olc('dogrulama')[0] - i1:+.4f}") ``` ``` duzenek isabet uydurma iddia yanitsiz belirtec cagri gecikme ciplak 0.2917 0.6667 48 0/24 9.8 1 tek cagri baglama 0.6667 0.3333 48 0/24 27.8 1 tek cagri bilmiyorum 0.2500 0.5714 28 10/24 18.8 1 tek cagri dogrulama 0.6667 0.0857 35 2/24 55.5 2 zincir taban ciplak cagri 0.2917; baglama +0.3750, bilmiyorum -0.0417, dogrulama +0.3750 ``` **Kaynağa bağlama** ilgili belgeyi istemin içine koyuyor. İsabet **+0,3750** artıyor, uydurma oranı yarıya iniyor. Bedel dürüsttür ve belirteçle ölçülür: istek başına 9,8 belirteç yerine **27,8** belirteç, yani üç katına yakın. Çağrı sayısı değişmiyor. **İddia doğrulama** yanıtı ikinci bir çağrıda tek tek dağarcığa soruyor ve karşılığı bulunamayan iddiayı düşürüyor. Uydurma oranı **0,0857**'ye iniyor, bu tablodaki en düşük sayı. Bedeli de en yüksek: **55,5** belirteç, **iki çağrı** ve **zincir** gecikme sınıfı, çünkü ikinci çağrı birincinin çıktısını beklemek zorundadır. İsabeti bağlamayla aynı kalıyor, yani ek bedel yalnız uydurmayı satın alıyor. **Bilmiyorum seçeneği** üçüncüsüdür ve tabloda sayıyı **düşüren satırdır**. İsabet **0,2500**'e iniyor: taban olan çıplak çağrının **0,0417 altında**. Sebep yanıtsız sütununda yazılı — düzenek on isteği yanıtsız bırakıyor ve bunların bir kısmı doğru yanıtlanacak isteklerdi. Uydurma oranı **0,5714**'e, yani ancak biraz iniyor, çünkü kurgu güven ölçüsü dayanağın varlığıyla yalnız kısmen örtüşüyor. Düzenek isabetten kesin bir şey götürüyor, uydurmadan belirsiz bir şey getiriyor. Sayısı yazılmasaydı üç azaltma da "iyileştirme" diye listelenirdi. Bu, düzeneğin kötü olduğu anlamına gelmez; **ölçütün seçilmediği** anlamına gelir. Yanlış bir tarife eşiği söylemenin bedeli, hiçbir şey söylememenin bedelinden ağırsa bilmiyorum seçeneği kazanır ve isabetteki 0,0417'lik kayıp ucuz bir sigortadır. Tersi durumda aynı düzenek on isteği karşılıksız bırakan bir gerileme olur. Tabloya bakan mühendisin işi, bu iki bedeli aynı birime çevirmektir; tablonun işi ise kararın hangi sayıya dayandığını görünür kılmaktır. Eşiğin kendisi de bir ayardır: 0,55 yerine daha düşük bir değer yanıtsız isteği azaltır ve uydurmayı büyütür. Yanıtsız sütunu bu yüzden tabloda durur — o sütun yazılmasa isabet düşüşünün nereden geldiği görünmezdi ve düzenek "işe yaramadı" diye kapatılırdı. #### Uydurma Nereden Geliyor ```python print("duzenek isabet A isabet B degisen istek dayanaksiz iddia kaynagi") for d in ("ciplak", "baglama", "bilmiyorum", "dogrulama"): a, b = olc(d)[0], olc(d, TOHUM + 1)[0] fark = sum(sor(i, d, TOHUM) != sor(i, d, TOHUM + 1) for i in range(24)) kapsanan = kapsanmayan = 0 for i in range(24): for c in sor(i, d, TOHUM): if BELGE.get((c[0], c[1])) != c[2]: kapsanan += (c[0], c[1]) in BELGE kapsanmayan += (c[0], c[1]) not in BELGE print(f"{d:<12} {a:.4f} {b:.4f} {fark:>2}/24 belgeli {kapsanan:>2}," f" belgesiz {kapsanmayan:>2}") ``` ``` duzenek isabet A isabet B degisen istek dayanaksiz iddia kaynagi ciplak 0.2917 0.3333 16/24 belgeli 16, belgesiz 16 baglama 0.6667 0.6667 8/24 belgeli 0, belgesiz 16 bilmiyorum 0.2500 0.3333 9/24 belgeli 7, belgesiz 9 dogrulama 0.6667 0.6667 0/24 belgeli 0, belgesiz 3 ``` Son sütun uydurmayı ikiye ayırıyor. Çıplak çağrının 32 dayanaksız iddiasının **16**'sı dağarcıkta karşılığı **olan** sorulardadır: belge elimizdeydi, model ona bakmadı. Diğer **16**'sı karşılığı **olmayan** sorulardadır. Kaynağa bağlama birinci yarıyı **sıfırlıyor** ve ikinci yarıya hiç dokunmuyor. Bu, kaynağa bağlamanın ne yapıp ne yapamayacağının tam tarifidir: dağarcıkta duran bilginin uydurulmasını bitirir, dağarcıkta durmayan bilginin uydurulmasını bitirmez. Kalan on altı iddia için tek çözüm dağarcığı büyütmek ya da yanıtsız bırakmaktır. Ortadaki sütun belirsizliği ölçüyor. Çıplak çağrı iki koşumda **16/24** istekte başka yanıt veriyor. Kaynağa bağlama bunu **8/24**'e indiriyor, çünkü belgeden okunan değer kopyalanır ve örneklemeye açık değildir. İddia doğrulama **0/24** veriyor: iki koşumda birebir aynı yanıt. Belirsizliği daraltan şey modelin ayarı değil, yanıtın **dayanağa bağlanmış olmasıdır**. Kaynağa bağlamanın ikinci ve az konuşulan kazancı budur. Buradan bir tasarım kuralı çıkıyor ve bu müfredatın ilerisine uzanıyor. Uydurmayı azaltmanın ucuz yolu modeli zorlamak değil, **yanıtın dayanağını isteme koymaktır**; pahalı yolu ise yanıtı ürettikten sonra denetlemektir. İkisinin bedeli aynı birimle, belirteçle ve çağrıyla yazıldığında seçim tartışmaya kalmaz. Ancak her ikisi de bir soruyu yanıtsız bırakır: dağarcıkta yüzlerce belge varsa isteme hangileri konulacak. Bu derste doğru belge her seferinde elle verildi, çünkü konu sayısı on ikiydi. Belge sayısı büyüdüğünde doğru belgeyi bulmanın kendisi ölçülmesi gereken bir düzenek olur ve kendi isabeti, kendi belirteç bedeli doğar. Bu müfredatın ilerideki bir kursu tam olarak o düzeneği kurar; bu ders yalnız niçin gerektiğini sayıyla gösterdi. #### Özet - Kaynaksız yanıtta 24 istek 48 iddia üretiyor, uydurma oranı 0,6667, isabet 0,2917; model dağarcıkta karşılığı olmayan 8 sorunun sekizine de yanıt veriyor. - Kaynağa bağlama isabeti +0,3750 artırıp uydurmayı 0,3333'e indiriyor, bedeli istek başına 9,8 belirteçten 27,8 belirtece çıkmaktır. - İddia doğrulama uydurmayı 0,0857 ile en aşağı çekiyor, bedeli 55,5 belirteç, iki çağrı ve zincir gecikme sınıfıdır; isabete bağlamanın üstüne bir şey eklemiyor. - Bilmiyorum seçeneği isabeti 0,2500'e, yani tabanın 0,0417 altına düşürüyor ve 10/24 isteği yanıtsız bırakıyor; eklenen her düzenek iyileştirmez. - Kaynağa bağlama, belgesi olan iddialarda uydurmayı 16'dan 0'a indiriyor ama belgesiz olanlarda 16'yı 16 bırakıyor; ayrıca koşumdan koşuma değişen isteği 16/24'ten 8/24'e çekiyor. #### Sonraki Adım Bu derste ölçülen her düzenek modelin **çevresine** kuruldu: istemin içine belge konuldu, ikinci bir çağrı eklendi, bir eşik tanımlandı. Hepsi modele erişimin verili olduğunu varsayıyordu. Oysa o erişimin kendisi bir karardır ve sayıları değiştirir. Bir modele yalnız uzaktaki bir uç nokta üzerinden ulaşmakla, ağırlıkları elde tutup kendi donanımında çalıştırmak arasında hangi ayarın kimde kaldığı, aynı işin kaç belirtece mal olduğu ve verinin nereye gittiği farklıdır. Sonraki ders bu iki erişim biçimini üç ölçütte sayıyla karşılaştırır ve seçimin hangi ölçütte değiştiğini yazar. ### Kapalı ve Açık Ağırlıklı Modeller Source: https://academia.sh/tr/kurslar/yz-muhendisligine-giris/kapali-ve-acik-agirlikli-modeller İki erişim biçimi üç ölçütte sayıyla karşılaştırılıyor ve ölçütler tek bir biçimde birleşmiyor. Elde tutulan ayar kapalı ağırlıklı biçimde 3/9, açık ağırlıklı biçimde 9/9. Birim bedelde kapalı biçim 0,7917 isabeti istek başına 38,3 belirteçle tutuyor, açık biçim aynı isabete altı örnek eklendikten sonra 176,3 belirteçle ulaşıyor ve oran 4,60 çıkıyor. Veri sınırında kapalı biçimde 24/24 istek, 919 belirteç ve 72 sayısal alan kurum sınırını aşıyor, açık biçimde hiçbiri aşmıyor. İki ölçüt açık, biri kapalı ağırlıklı biçimi seçiyor ve üç sayının ortak birimi yok. Önceki derste eklenen her düzenek modelin çevresine kuruldu ve modele erişimin verili olduğu varsayıldı. O erişimin kendisi bir karardır. Bir dil modeline yalnız uzaktaki bir **model uç noktası** üzerinden ulaşılabilir; ya da modelin **ağırlıkları** elde tutulur ve kendi donanımında çalıştırılır. İlkine **kapalı ağırlıklı**, ikincisine **açık ağırlıklı** erişim denir. Bu ayrım genelde bir tercih tartışması gibi konuşulur ve tartışma çoğu zaman iki tarafın da doğru olduğu yerde biter, çünkü taraflar farklı ölçütlerden konuşur. Bu ders onu üç ölçütte sayıya çevirir: elde kalan ayar sayısı, aynı işi bitirmenin belirteç bedeli ve kurum sınırını aşan veri. Üçü de bir mühendisin kendi tarafından, modelin içine hiç bakmadan sayabileceği büyüklüklerdir. Hiçbir model, sağlayıcı ya da lisans adı geçmez, çünkü ölçülen şey ürün değil **erişim biçiminin yapısıdır**; adlar beş yılda değişir, yapı değişmez. - **DL58. Görev kümesi ve benzetici öncekiyle aynıdır**: 24 kurgu destek talebi beş sınıfa ayrılır, ölçü isabettir. Talepler, sınıflar ve okumalar **kurgudur**. - **DL59. İki erişim biçimi tek bir farkla modellenir:** benzeticinin **tanıdık öbek kümesinin genişliği**. Kapalı biçimde geniş, açık biçimde dardır. Bu, kurgunun varsayımıdır ve gerçek modellerin yeteneği hakkında bir iddia değildir; ölçülen şey farkın **bedele nasıl döndüğüdür**. - **DL60. Açık biçimin düzeneği örnek eklemektir.** İsteme konan her kurgu örnek 23 belirteç tutar ve tanıdık öbek kümesini bir basamak genişletir. - **DL61. Elde tutulan denetim, dokuz ayarlık kurgu listede** her ayarın hangi biçimde kararlaştırılabildiği sayılarak ölçülür. - **DL62. Veri sınırı üç sayıyla ölçülür:** kurum sınırını aşan istek sayısı, belirteç sayısı ve sayısal alan sayısı. Sayısal alanlar kurgu abone numaraları ile sayaç okumalarıdır; bu ölçüt verinin niteliğini değil, sınırı aşan miktarını sayar. - **DL63. Belirsizlik iki koşumla ölçülür**; ikinci koşum tohum 20260219 ile alınır. İki biçim aynı benzeticiyi paylaştığı için, aynı genişlikte aynı sayıyı vermeleri beklenir ve bu tabloda bir denetim noktası olarak kullanılır. - **DL64. Ölçütler ayrı ayrı okunur, toplanmaz.** Ayar sayısı, belirteç sayısı ve sınırı aşan istek sayısı ortak bir birime çevrilmez; her ölçütün kazananı ayrı yazılır. #### Birim Bedel: Aynı İsabet Kaça Mal Oluyor ```python # ORTAK -- KURGUDUR. Iki erisim bicimi ayni benzetici uzerinde kurulur; hicbir model, # saglayici ya da lisans anilmaz. Kurgudaki tek fark tanidik obek kumesinin genisligidir. TOHUM, M32 = 20260218, 0xFFFFFFFF 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): """Kurgu belirtecleyici: harf obekleri dorder, rakam obekleri ikiser bolunur.""" cikti, tampon = [], "" for ch in metin + " ": if ch.isalnum(): tampon += ch continue if tampon: n = 2 if tampon.isdigit() else 4 cikti += [tampon[i:i + n] for i in range(0, len(tampon), n)] tampon = "" if ch.strip(): cikti.append(ch) return cikti BAS = [("sayac okunmadi tahmini fatura cikti", "olcum"), ("fatura tutari gecen aya gore iki kat cikti", "odeme"), ("gece boyunca su basinci dustu", "tesisat"), ("planli kesinti bildirimi ulasmadi", "kesinti"), ("abonelik devri sayaca islenmedi", "sozlesme")] EK = ["sayacin numarasi degistirilmis olabilir", "adres bilgisi eski gorunuyor", "onceki ay ayni sorun yasanmadi", "sayaca ulasilamiyor kapi kapali", "kesinti suresi beklenenden uzun surdu", "otomatik talimat sayacta yok"] SOZLUK = {"kesinti": ["kesi", "bild"], "olcum": ["okun", "olcu", "tahm"], "tesisat": ["basi", "dust", "tesi", "vana"], "odeme": ["fatu", "odem", "tali", "tuta"], "sozlesme": ["abon", "adre", "devr", "sozl"]} SINIFLAR = list(SOZLUK) ORNEK_BELIRTEC = 23 # isteme eklenen her kurgu ornegin bedeli TALEP = [] for i in range(24): r = uretec(TOHUM + 31 * i) a, b = 100000 + int(r() * 380000), 100000 + int(r() * 380000) TALEP.append({"no": 4100 + i, "sinif": BAS[i % 5][1], "metin": f"abone {4100 + i}: {BAS[i % 5][0]}, {EK[(5 * i + 2) % 6]}." f" ana sayac {a} ara sayac {b}."}) def cagir(t, genislik, tohum): """Benzetici: tanidigi obeklerle etiket secer; ilk iki aday esitse belirsiz doner.""" bel, sz = belirtecle(t["metin"]), {s: set(o[:genislik]) for s, o in SOZLUK.items()} p = sorted(((sum(b in sz[s] for b in bel), s) for s in SINIFLAR), key=lambda x: (-x[0], x[1])) if p[0][0] == 0 or p[0][0] == p[1][0]: return "belirsiz" # iki etiket birden yazilir, bicim denetimi gecmez r = uretec(tohum + 1009 * genislik + 7 * t["no"]) return p[1][1] if r() < 0.14 else p[0][1] def olc(genislik, ornek, tohum=TOHUM): dogru = belirtec = 0 for t in TALEP: dogru += cagir(t, genislik, tohum) == t["sinif"] belirtec += len(belirtecle(t["metin"])) + ornek * ORNEK_BELIRTEC return dogru / 24, belirtec / 24 print("erisim bicimi ornek isabet A isabet B cagri belirtec/istek") for ad, g, o in (("kapali agirlikli", 4, 0), ("acik agirlikli ", 1, 0), ("acik agirlikli ", 2, 2), ("acik agirlikli ", 3, 4), ("acik agirlikli ", 4, 6)): a, bel = olc(g, o) b = olc(g, o, TOHUM + 1)[0] print(f"{ad} {o} {a:.4f} {b:.4f} 1.0000 {bel:>5.1f}") ``` ``` erisim bicimi ornek isabet A isabet B cagri belirtec/istek kapali agirlikli 0 0.7917 0.7083 1.0000 38.3 acik agirlikli 0 0.1250 0.1667 1.0000 38.3 acik agirlikli 2 0.3750 0.3750 1.0000 84.3 acik agirlikli 4 0.5833 0.6667 1.0000 130.3 acik agirlikli 6 0.7917 0.7083 1.0000 176.3 ``` Çıplak çağrıda iki biçim aynı belirteci harcıyor ve aynı sayıyı vermiyor: kapalı **0,7917**, açık **0,1250**. Fark modelin kendisinden değil, açık biçimde koşan benzeticinin dar öbek kümesinden geliyor — kurgunun varsayımı budur. Önemli olan bundan sonrası: fark **kapatılabilir bir farktır** ve kapatmanın fiyatı belirteçle yazılıdır. İsteme iki örnek eklendikçe isabet **0,3750**, **0,5833** ve **0,7917** basamaklarını çıkıyor. Altıncı örnekte açık biçim kapalı biçimin sayısına tam olarak yetişiyor: **0,7917** karşısında **0,7917** ve ikinci koşumda da **0,7083** karşısında **0,7083**. İki biçim artık aynı işi yapıyor. Yapmadıkları tek şey aynı fiyata yapmak: istek başına **38,3** belirteç karşısında **176,3** belirteç. Çağrı sayısı ikisinde de bir, gecikme sınıfı ikisinde de tek çağrıdır; fark tamamen istemin uzunluğundadır. Merdivenin okunması gereken yeri şurası: **bedel modelden isteme taşındı**. Açık ağırlıklı biçimde modelin bilmediği şey, her istekte yeniden anlatılıyor. Bu, düzeneğin genel yasasının bu dersteki görünümüdür — bir yerde eksik olan şey başka bir yerde belirteçle ödenir ve o ödeme her istekte tekrarlanır. Yirmi dört isteklik bir kümede fark 3.312 belirteçtir; istek sayısı büyüdükçe fark doğru orantılı büyür, çünkü örnekler önbelleğe alınmadıkça her çağrıda yeniden gönderilir. Bir de tabloda görünmeyen bir sayı var. Benzetici, ilk iki adayın puanı eşit olduğunda tek bir etiket yerine iki etiketi birden yazıyor ve biçim denetiminden geçemiyor; bu yanıtlar isabetsiz sayılıyor. Dar öbek kümesiyle bu durum sık, geniş kümeyle seyrektir. Yani açık biçimin düşük sayısının bir kısmı yanlış etiketten değil, **kullanılamayan çıktıdan** geliyor. Ölçü tek sayıya indirgendiğinde bu ayrım kayboluyor, oysa iki başarısızlık türünün ürün tarafındaki karşılığı farklıdır: yanlış etiket sessizce yanlış bir işi başlatır, biçim bozukluğu ise duran bir istektir. #### Elde Tutulan Denetim ve Veri Sınırı ```python AYAR = [("agirliklarin kendisi", 0, 1), ("belirtecleyici", 0, 1), ("surum sabitleme", 0, 1), ("baglam penceresi siniri", 0, 1), ("hiz siniri", 0, 1), ("kesintide geri alma", 0, 1), ("dagilim sicakligi", 1, 1), ("durdurma kosulu", 1, 1), ("cikti uzunlugu siniri", 1, 1)] KAPALI, ACIK = sum(k for _, k, _ in AYAR), sum(a for _, _, a in AYAR) print("ayar kapali agirlikli acik agirlikli") for ad, k, a in AYAR: print(f"{ad:<25} {'elde' if k else ' - ':^4} {'elde' if a else ' - ':^4}") print(f"olcut 1 -- elde tutulan ayar: kapali {KAPALI}/{len(AYAR)}, acik {ACIK}/{len(AYAR)}") kimlik = sum(sum(w.isdigit() for w in t["metin"].replace(":", " ").replace(".", " ").split()) for t in TALEP) disari = sum(len(belirtecle(t["metin"])) for t in TALEP) print(f"olcut 3 -- kurum sinirini asan: kapali {len(TALEP)}/{len(TALEP)} istek," f" {disari} belirtec, {kimlik} sayisal alan") print(f" acik 0/{len(TALEP)} istek, 0 belirtec, 0 sayisal alan") ``` ``` ayar kapali agirlikli acik agirlikli agirliklarin kendisi - elde belirtecleyici - elde surum sabitleme - elde baglam penceresi siniri - elde hiz siniri - elde kesintide geri alma - elde dagilim sicakligi elde elde durdurma kosulu elde elde cikti uzunlugu siniri elde elde olcut 1 -- elde tutulan ayar: kapali 3/9, acik 9/9 olcut 3 -- kurum sinirini asan: kapali 24/24 istek, 919 belirtec, 72 sayisal alan acik 0/24 istek, 0 belirtec, 0 sayisal alan ``` Dokuz ayarın **üçü** kapalı ağırlıklı erişimde elde kalıyor: dağılım sıcaklığı, durdurma koşulu ve çıktı uzunluğu sınırı. Bunlar istekle birlikte gönderilen ayarlardır. Kalan **altısı** elde değildir ve hepsinin ortak yanı vardır: ağırlıklar, belirteçleyici, sürüm, pencere sınırı, hız sınırı ve kesinti anında eski davranışa dönme, **modelin çalıştığı yere ait** kararlardır. Model başkasının makinesinde çalışıyorsa o kararlar da başkasındadır. Açık ağırlıklı erişimde dokuzu da elde kalır, çünkü çalıştıran taraf ile karar veren taraf aynıdır. Bunun görünmeyen bir sonucu, sürümün sabitlenememesidir. Yedinci derste ölçülen uydurma oranı, altıncı derste ölçülen görev isabeti ve bu derste ölçülen 0,7917, hepsi belirli bir davranışa aittir. O davranış haber verilmeden değiştiğinde bütün ölçüler yeniden alınmalıdır ve eski sayıların hiçbiri geçerli değildir. Kapalı ağırlıklı erişimde ölçünün ömrü, elde olmayan bir kararın ömrüyle sınırlıdır. Üçüncü ölçüt aynı tabloda okunuyor. Kapalı biçimde yirmi dört isteğin **24**'ü, **919** belirteç ve **72** sayısal alan kurum sınırını aşıyor; bu sayısal alanlar kurgu abone numaraları ile sayaç okumalarıdır. Açık biçimde üç sayı da sıfırdır. Bu ölçüt ikisi arasında bir derece farkı değil, **bir eşik farkıdır**: sınırı aşan veri ya vardır ya yoktur. Tabloyu tek yönlü okumamak gerekir. Kapalı ağırlıklı erişimde elde olmayan altı ayarın karşılığında kuruma geçmeyen bir yük vardır: modelin çalıştırılması, donanımın ayrılması, sürümün taşınması ve kesintinin karşılanması. Açık ağırlıklı erişimde bu dokuz ayar elde kalır çünkü **dokuz sorumluluk da elde kalır**. Ölçüt "elde tutulan denetim" diye adlandırıldığında bu simetri görünmez olur; sayının yanına ne kazandırdığı kadar ne yüklediği de yazılmalıdır. Bu dersin ölçtüğü şey hangi biçimin iyi olduğu değil, iki biçimin **hangi ölçütte ayrıldığıdır**. #### Seçim Hangi Ölçütte Değişiyor ```python kb, ab = olc(4, 0), olc(4, 6) print("olcut kapali agirlikli acik agirlikli kazanan") print(f"denetim {KAPALI}/9 ayar {ACIK}/9 ayar acik") print(f"birim bedel {kb[1]:>6.1f} belirtec {ab[1]:>6.1f} belirtec kapali") print(f"veri siniri 24/24 istek 0/24 istek acik") print(f"ayni isabet {kb[0]:.4f} icin bedel orani {ab[1] / kb[1]:.2f}") print(f"iki olcut acik agirlikli bicimi, biri kapali agirlikli bicimi secer;" f" ortak birim yok") ``` ``` olcut kapali agirlikli acik agirlikli kazanan denetim 3/9 ayar 9/9 ayar acik birim bedel 38.3 belirtec 176.3 belirtec kapali veri siniri 24/24 istek 0/24 istek acik ayni isabet 0.7917 icin bedel orani 4.60 iki olcut acik agirlikli bicimi, biri kapali agirlikli bicimi secer; ortak birim yok ``` Seçim **birim bedel ölçütünde değişiyor**. Denetim ve veri sınırı açık ağırlıklı biçimi seçerken, birim bedel kapalı biçimi seçiyor ve farkı küçük değil: aynı isabet için **4,60 kat** belirteç. İki ölçüt bir tarafta, biri öbür tarafta olduğu için "çoğunluk açığı seçiyor" demek yanlış olur, çünkü üç sayının **ortak birimi yoktur**. Ayar sayısı ile belirteç sayısı toplanamaz; sınırı aşan istek sayısı ile ikisi de karşılaştırılamaz. Bu, bir eksiklik değil ölçünün doğru okunmasıdır. Karar, ölçütlerin **ağırlıklandırılmasıyla** verilir ve ağırlığı veren şey sistemin bağlamıdır. Yanıtın gecikmesinden çok verinin nereye gittiğine bakan bir kurumda üçüncü ölçüt tek başına kararı verir ve 4,60 katlık bedel kabul edilir. Belirteç bütçesi dar olan bir kurumda ikinci ölçüt baskındır. Aynı üç sayı, ağırlık değiştikçe iki farklı kararı da destekler; değişen şey ölçüm değil ağırlıktır. Kursun kuralı burada ikinci kez işliyor: verilmiş bir bileşen yüzeyinden ölçülür. Bu derste ölçülen hiçbir sayı modelin içinden gelmedi. Ayar sayısı arayüzün neye izin verdiğinden, belirteç sayısı isteme ne konulduğundan, sınırı aşan veri isteğin nereye gittiğinden okundu. Üçü de içine bakılamayan bir bileşenin dışarıya bıraktığı izlerdir ve üçü de bir mühendisin kendi kodundan sayabileceği şeylerdir. Bir erişim biçimini "daha güçlü" ya da "daha güvenli" diye nitelemek yerine bu üç sayıyı yazmanın kazancı budur: nitelemeler tartışılır, sayılar karşılaştırılır. Sayının yanında bedeli yazılmadığında ise karşılaştırma yine tartışmaya döner — 0,7917 iki satırda da aynı görünür, aralarındaki 4,60 kat yalnız bedel sütununda vardır. #### Özet - Kapalı ağırlıklı erişim dokuz ayarın 3'ünü, açık ağırlıklı erişim 9'unu elde bırakıyor; elde olmayan altı ayarın hepsi modelin çalıştığı yere ait kararlardır. - Çıplak çağrıda isabet 0,7917 karşısında 0,1250; isteme altı örnek eklendiğinde açık biçim iki koşumda da kapalı biçimin sayısına yetişiyor (0,7917 ve 0,7083). - Aynı isabetin bedeli istek başına 38,3 belirtece karşı 176,3 belirteç, oran 4,60 kattır; çağrı sayısı ve gecikme sınıfı ikisinde de aynıdır. - Veri sınırında kapalı biçimde 24/24 istek, 919 belirteç ve 72 sayısal alan kurum sınırını aşıyor, açık biçimde hiçbiri aşmıyor; bu bir derece değil eşik farkıdır. - Seçim birim bedel ölçütünde değişiyor ve üç sayının ortak birimi olmadığı için karar ağırlıklandırmayla verilir. #### Sonraki Adım Bu ders iki biçimi karşılaştırdı ve kararın ağırlığa kaldığı yerde durdu. Gerçek bir seçimde seçenek iki tane değildir ve ölçüt üç tane değildir: aynı erişim biçiminin içinde yetenek, gecikme ve belirteç bedeli eksenlerinde birbirinden ayrı adaylar vardır ve mahremiyet bunların üstünde ayrı bir ölçüt olarak durur. Sonraki ders üç adayı benzetici düzeyinde kurar, dört ölçütte sayar ve tek bir soruyu yanıtlar: ağırlıklar değiştiğinde kazanan değişiyor mu ve değişiyorsa hangi eşikte. Ağırlık taraması ve normalleştirme yordamı Python ile Veri Analizi kursundaki Ortam Seçimi dersinde ölçüldü; burada tekrarlanmayacak, yalnız sonucu kullanılacak. ### Model Seçimi Source: https://academia.sh/tr/kurslar/yz-muhendisligine-giris/model-secimi Üç aday benzetici düzeyinde kurulup dört ölçütte sayılıyor: küçük yetenek 0,5000 isabet / 84,5 denk belirteç / 7,29 adım / 0 istek dışarı, orta yetenek 0,5833 / 181,2 / 7,00 / 0, büyük yetenek 0,7917 / 627,5 / 14,00 / 24. Beş ağırlık setinde kazanan üç kez orta, bir kez büyük, bir kez küçük çıkıyor. Ağırlık taraması eşikleri veriyor: isabet ağırlığı 4 olduğunda seçim ortadan büyüğe, bedel ağırlığı 2 olduğunda ortadan küçüğe geçiyor, gecikme ve veri sınırı ağırlıkları on ikiye kadar seçimi değiştirmiyor. Tohum 20260219 ile aynı hesap tekrarlandığında isabet ağırlıklı setin kazananı büyükten ortaya dönüyor. Önceki ders iki erişim biçimini üç ölçütte karşılaştırdı ve kararın ağırlığa kaldığı yerde durdu. Gerçek bir seçimde seçenek iki değildir. Aynı işi yapabilecek birden çok model bulunur; bunlar yetenek, belirteç bedeli, gecikme ve verinin nereye gittiği eksenlerinde birbirinden ayrılır ve hiçbiri dört eksende birden en iyi değildir. Bu ders üç adayı **benzetici düzeyinde** kurar, dört ölçütte sayar ve tek bir soruyu yanıtlar: ağırlıklar değiştiğinde kazanan değişiyor mu ve değişiyorsa hangi eşikte. Ağırlık taramasının ve normalleştirme kuralı seçiminin sonucu nasıl çevirebildiği Python ile Veri Analizi kursundaki Ortam Seçimi dersinde ölçüldü; o yordam burada tekrarlanmaz, tek bir normalleştirme kuralı kullanılır ve sonucu okunur. - **DL65. Üç aday tek bir benzeticinin üç ayarıdır.** Ayrıldıkları yer tanıdık öbek kümesinin genişliği, birim çarpanı ve ürettikleri yanıtın uzunluğudur. Hiçbir model, sürüm ya da sağlayıcı anılmaz; adaylar **küçük**, **orta** ve **büyük yetenek** diye geçer ve **kurgudur**. - **DL66. Bedel birimi denk belirteçtir.** Bir adayın bir belirteci, en küçük adayın belirtecinin kaç katı hesap tuttuğunu veren kurgu bir çarpanla ölçeklenir: küçük 1, orta 4, büyük 12. Para birimi yazılmaz. - **DL67. Gecikme adım sayısıyla ölçülür:** istek başına ortalama çağrı çarpı üretilen çıktı belirteci. Ham süre yazılmaz, çünkü üretim sıralı yapılır ve adım sayısı koşumdan koşuma değişmez. - **DL68. Küçük ve orta aday açık ağırlıklı erişimle kendi donanımında koşar**, büyük aday yalnız bir model uç noktası üzerinden çağrılır; kurum sınırını aşan istek sayısı sırasıyla 0, 0 ve 24 olur. - **DL69. Küçük adayın bir düzeneği vardır:** biçim denetiminden geçmeyen yanıtlarda isteme iki kurgu örnek eklenip yeniden sorulur. Bu düzenek isabeti yükseltir, çağrı sayısını ve belirteci büyütür. - **DL70. Normalleştirme kuralı tektir:** her ölçütte en kötü aday 0, en iyi aday 1 alır, aradaki değer aralığa oranlanır. Ağırlıklar bu normalleştirilmiş sayılara uygulanır. #### Üç Aday ve Dört Ölçüt ```python # ORTAK -- KURGUDUR. Uc aday ayni benzetici uzerinde kurulur; hicbir model ya da # saglayici anilmaz. Adaylar tanidik obek genisligi, birim carpani ve cikti uzunlugu # ile ayrilir. Bedel birimi DENK BELIRTEC: belirtec sayisi carpi adayin birim carpani. TOHUM, M32 = 20260218, 0xFFFFFFFF 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): """Kurgu belirtecleyici: harf obekleri dorder, rakam obekleri ikiser bolunur.""" cikti, tampon = [], "" for ch in metin + " ": if ch.isalnum(): tampon += ch continue if tampon: n = 2 if tampon.isdigit() else 4 cikti += [tampon[i:i + n] for i in range(0, len(tampon), n)] tampon = "" if ch.strip(): cikti.append(ch) return cikti BAS = [("sayac okunmadi tahmini fatura cikti", "olcum"), ("fatura tutari gecen aya gore iki kat cikti", "odeme"), ("gece boyunca su basinci dustu", "tesisat"), ("planli kesinti bildirimi ulasmadi", "kesinti"), ("abonelik devri sayaca islenmedi", "sozlesme")] EK = ["sayacin numarasi degistirilmis olabilir", "adres bilgisi eski gorunuyor", "onceki ay ayni sorun yasanmadi", "sayaca ulasilamiyor kapi kapali", "kesinti suresi beklenenden uzun surdu", "otomatik talimat sayacta yok"] SOZLUK = {"kesinti": ["kesi", "bild"], "olcum": ["okun", "olcu", "tahm"], "tesisat": ["basi", "dust", "tesi", "vana"], "odeme": ["fatu", "odem", "tali", "tuta"], "sozlesme": ["abon", "adre", "devr", "sozl"]} SINIFLAR = list(SOZLUK) TALEP = [] for i in range(24): r = uretec(TOHUM + 31 * i) a, b = 100000 + int(r() * 380000), 100000 + int(r() * 380000) TALEP.append({"no": 4100 + i, "sinif": BAS[i % 5][1], "metin": f"abone {4100 + i}: {BAS[i % 5][0]}, {EK[(5 * i + 2) % 6]}." f" ana sayac {a} ara sayac {b}."}) # (ad, obek genisligi, birim carpani, cikti belirteci, ornek bedeli, disari cikan istek) ADAY = [("kucuk", 2, 1, 5, 46, 0), ("orta", 3, 4, 7, 0, 0), ("buyuk", 4, 12, 14, 0, 24)] def cagir(t, genislik, tohum): """Benzetici: tanidigi obeklerle etiket secer; ilk iki aday esitse belirsiz doner.""" bel, sz = belirtecle(t["metin"]), {s: set(o[:genislik]) for s, o in SOZLUK.items()} p = sorted(((sum(b in sz[s] for b in bel), s) for s in SINIFLAR), key=lambda x: (-x[0], x[1])) if p[0][0] == 0 or p[0][0] == p[1][0]: return "belirsiz" r = uretec(tohum + 1009 * genislik + 7 * t["no"]) return p[1][1] if r() < 0.14 else p[0][1] def olc(aday, tohum=TOHUM): ad, g, carpan, cikti, ornek, disari = aday dogru = cagri = giris = 0 for t in TALEP: n = len(belirtecle(t["metin"])) y, cagri, giris = cagir(t, g, tohum), cagri + 1, giris + n if y == "belirsiz" and ornek: # duzenek: isteme iki ornek eklenip yeniden sorulur y, cagri, giris = cagir(t, g + 1, tohum), cagri + 1, giris + n + ornek dogru += y == t["sinif"] cagri, giris = cagri / 24, giris / 24 return {"ad": ad, "isabet": dogru / 24, "denk": (giris + cagri * cikti) * carpan, "adim": cagri * cikti, "cagri": cagri, "disari": disari} S = [olc(a) for a in ADAY] print("aday isabet isabet B denk belirtec adim cagri/istek disari cikan") for a, s in zip(ADAY, S): b = olc(a, TOHUM + 1)["isabet"] print(f"{s['ad']:<6} {s['isabet']:.4f} {b:.4f} {s['denk']:>6.1f} {s['adim']:>5.2f}" f" {s['cagri']:.4f} {s['disari']:>2}/24") ``` ``` aday isabet isabet B denk belirtec adim cagri/istek disari cikan kucuk 0.5000 0.5833 84.5 7.29 1.4583 0/24 orta 0.5833 0.6667 181.2 7.00 1.0000 0/24 buyuk 0.7917 0.7083 627.5 14.00 1.0000 24/24 ``` Dört sütun dört ayrı kazanan gösteriyor. İsabette **büyük** aday önde: 0,7917. Denk belirteçte **küçük** aday önde: 84,5, yani büyüğün 627,5'inin yedide birinden az. Adımda **orta** aday önde, ama farkı incedir: 7,00 karşısında 7,29. Kurum sınırını aşan istekte küçük ve orta aday birlikte önde, çünkü ikisi de kendi donanımında koşuyor. Küçük adayın adım sayısındaki kaybının nereden geldiği çağrı sütununda yazılı: istek başına **1,4583** çağrı. Bu, düzeneğin bedelidir. Biçim denetiminden geçmeyen yanıtlarda isteme iki örnek eklenip yeniden soruluyor; isabet bu sayede 0,5000'e çıkıyor ama her yeniden sorulan istek bir adım daha ekliyor. Düzenek isabeti alıp gecikmeyi veriyor ve iki sayı da tabloda yan yana duruyor. Denk belirteç biriminin ne olduğuna dikkat etmek gerekir. Üç aday aynı isteği alıyor ve neredeyse aynı sayıda belirteç okuyor; ham belirteç sayısıyla bakıldığında üçü de birbirine yakındır. Fark belirtecin **sayısında** değil **tuttuğunda**: aynı belirteci işlemek büyük adayda küçük adayın on iki katı hesap yükü demektir. Birim çarpanı bu yükü tek bir sayıya indiriyor ve karşılaştırmayı mümkün kılıyor. Para birimi yazılmamasının nedeni de budur: çarpan yapısaldır ve beş yıl sonra da aynı biçimde okunur, bir fiyat listesi ise okunmaz. Çıktı belirteci ayrıca sayılır, çünkü çıktı sıralı üretilir ve hem bedele hem adıma girer; büyük adayın 14 belirteçlik yanıtı, aynı yanıtı 5 belirteçte veren küçük adaya göre iki kat gecikme demektir. #### Ağırlık Değişince Kazanan Değişiyor ```python OLCUT = [("isabet", "isabet", 1), ("denk belirtec", "denk", -1), ("adim", "adim", -1), ("disari cikan istek", "disari", -1)] def normal(sonuc, anahtar, yon): """Tek normallestirme kurali: aralikta en kotu 0, en iyi 1.""" v = [s[anahtar] for s in sonuc] lo, hi = min(v), max(v) if hi == lo: return [1.0] * len(v) return [((x - lo) if yon > 0 else (hi - x)) / (hi - lo) for x in v] N = {a: normal(S, a, y) for _, a, y in OLCUT} AGIRLIK = [("dengeli", (1, 1, 1, 1)), ("isabet agirlikli", (4, 1, 1, 1)), ("bedel agirlikli", (1, 4, 1, 1)), ("gecikme agirlikli", (1, 1, 4, 1)), ("veri siniri agirlikli", (1, 1, 1, 4))] print("olcut kucuk orta buyuk") for ad, a, _ in OLCUT: print(f"{ad:<18} {N[a][0]:.4f} {N[a][1]:.4f} {N[a][2]:.4f}") print("agirlik seti kucuk orta buyuk kazanan") for ad, w in AGIRLIK: p = [sum(w[j] * N[a][i] for j, (_, a, _) in enumerate(OLCUT)) for i in range(3)] print(f"{ad:<22} {p[0]:.4f} {p[1]:.4f} {p[2]:.4f} {S[p.index(max(p))]['ad']}") ``` ``` olcut kucuk orta buyuk isabet 0.0000 0.2857 1.0000 denk belirtec 1.0000 0.8220 0.0000 adim 0.9583 1.0000 0.0000 disari cikan istek 1.0000 1.0000 0.0000 agirlik seti kucuk orta buyuk kazanan dengeli 2.9583 3.1078 1.0000 orta isabet agirlikli 2.9583 3.9649 4.0000 buyuk bedel agirlikli 5.9583 5.5739 1.0000 kucuk gecikme agirlikli 5.8333 6.1078 1.0000 orta veri siniri agirlikli 5.9583 6.1078 1.0000 orta ``` Beş ağırlık setinde üç ayrı kazanan çıkıyor. Eşit ağırlıkta **orta** aday kazanıyor ve farkı küçüktür: 3,1078 karşısında 2,9583. İsabet ağırlığı dörde çıkınca **büyük** aday öne geçiyor, ama yine kıl payı: 4,0000 karşısında 3,9649. Bedel ağırlığı dörde çıkınca **küçük** aday kazanıyor. Gecikme ve veri sınırı ağırlıkları ortayı büyütmekten başka bir şey yapmıyor. Aynı üç aday, aynı dört sayı, üç ayrı karar. Değişen tek şey hangi ölçütün ne kadar saydığıdır. Bu yüzden "hangi model daha iyi" sorusunun ölçüsü yoktur; ölçüsü olan soru "bu dört sayı ve şu ağırlıklarla hangi aday kazanıyor" sorusudur. Bir seçim gerekçesi, ağırlığını yazmadığı sürece bir gerekçe değil bir tercihtir. Normalleştirme kuralının kendisi de bir karardır ve tabloda görünmez. Burada kullanılan kural aralığa oranlıyor: her ölçütte en kötü aday 0, en iyi aday 1 alıyor. Bu kural, aradaki farkın ne kadar büyük olduğuna bakmaz — isabette küçük ile orta arasındaki 0,0833'lük fark, aralığın 0,2917'lik genişliğine bölünüp 0,2857'ye çıkıyor, yani küçük bir mutlak fark büyük bir normalleştirilmiş farka dönüşüyor. Başka bir kural başka sayılar verirdi. Ortam Seçimi dersi bunun seçimi çevirebildiğini ölçtüğü için burada tek kural kullanılıyor ve kullanıldığı yazılıyor; yazılmadığında tablo, olmadığı kadar nesnel görünür. #### Eşik ve Seçimin Kendi Belirsizliği ```python def kazanan(N, w): p = [sum(w[j] * N[a][i] for j, (_, a, _) in enumerate(OLCUT)) for i in range(3)] return ADAY[p.index(max(p))][0] print("taranan olcut agirlik 1 ilk degisim yeni kazanan") for j, (ad, _, _) in enumerate(OLCUT): onceki, esik, yeni = kazanan(N, (1, 1, 1, 1)), "-", "-" for w in range(2, 13): k = kazanan(N, tuple(w if i == j else 1 for i in range(4))) if k != onceki and esik == "-": esik, yeni = w, k print(f"{ad:<18} {onceki:<9} {str(esik):<11} {yeni}") S2 = [olc(a, TOHUM + 1) for a in ADAY] N2 = {a: normal(S2, a, y) for _, a, y in OLCUT} print("agirlik seti tohum 20260218 tohum 20260219") for ad, w in AGIRLIK: print(f"{ad:<22} {kazanan(N, w):<14} {kazanan(N2, w)}") ``` ``` taranan olcut agirlik 1 ilk degisim yeni kazanan isabet orta 4 buyuk denk belirtec orta 2 kucuk adim orta - - disari cikan istek orta - - agirlik seti tohum 20260218 tohum 20260219 dengeli orta orta isabet agirlikli buyuk orta bedel agirlikli kucuk kucuk gecikme agirlikli orta orta veri siniri agirlikli orta orta ``` Eşikler asimetriktir. Bedel ağırlığı **2** olduğunda seçim ortadan küçüğe geçiyor; isabet ağırlığı ise **4**'e çıkmadan büyüğü öne getirmiyor. Gecikme ve veri sınırı ağırlıkları on ikiye kadar taransa da seçimi değiştirmiyor, çünkü bu iki ölçütte kazanan zaten ortadır ve ağırlık artırmak kazananı pekiştirmekten başka bir şey yapmaz. Bir ölçütün ağırlığını büyütmek, o ölçütte önde olmayan bir adayı asla öne getirmez. Son tablo bu dersin en rahatsız edici sayısıdır. Aynı hesap tohum 20260219 ile tekrarlandığında **isabet ağırlıklı setin kazananı büyükten ortaya dönüyor**. Hiçbir ölçüt değişmedi, hiçbir ağırlık değişmedi; yalnız benzeticinin örnekleme tohumu değişti ve büyük adayın isabeti 0,7917'den 0,7083'e indi. Kıl payı kazanılan bir karar, koşumdan koşuma değişen bir bileşenin üstüne kurulduğunda kendisi de koşuma bağlı olur. Dört ölçütün üçünde seçim sağlamdır; dördüncüsünde değildir ve bu, tek koşumla ölçen bir karşılaştırmanın hiç göremeyeceği bir şeydir. Buradan pratik bir kural çıkıyor. Bir seçim tablosu yalnız kazananı değil, **kazanma payını** da yazmalıdır. Payı geniş olan satırlar, ağırlıklar biraz oynasa ya da ölçüm biraz kaysa da ayakta kalır; payı ince olanlar kalmaz. Eşit ağırlıktaki 3,1078 ile 2,9583 arasındaki 0,1495'lik pay ile isabet ağırlıklı setteki 4,0000 ile 3,9649 arasındaki 0,0351'lik pay aynı tabloda durur ama aynı şeyi söylemez. İnce paylı bir satırda doğru davranış, kazananı ilan etmek değil, iki adayı da ölçüyü büyüterek yeniden koşturmak ya da kararı bir ölçüte daha bağlamaktır. #### Özet - Üç aday dört ölçütte sayılınca kazanan dörde bölünüyor: isabette büyük 0,7917, denk belirteçte küçük 84,5, adımda orta 7,00, kurum sınırını aşan istekte küçük ve orta 0/24. - Küçük adayın düzeneği isabeti 0,5000'e çıkarırken çağrı sayısını 1,4583'e ve adımı 7,29'a taşıyor; kazanç ile bedel aynı tabloda durur. - Beş ağırlık setinde kazanan üç kez orta, bir kez büyük, bir kez küçük çıkıyor; eşit ağırlıkta fark 3,1078 karşısında 2,9583 gibi incedir. - Eşikler asimetriktir: bedel ağırlığı 2'de seçimi ortadan küçüğe, isabet ağırlığı 4'te ortadan büyüğe çevirir; gecikme ve veri sınırı ağırlıkları on ikiye kadar seçimi değiştirmez. - Tohum 20260219 ile isabet ağırlıklı setin kazananı büyükten ortaya dönüyor; kıl payı verilen bir seçim koşuma bağlı hale gelir. #### Sonraki Adım Bu derste bedel bir ölçüt olarak sayıldı, ama bir sınır olarak hiç kullanılmadı. Kazanan aday her ağırlık setinde serbestçe seçildi; oysa gerçek bir sistemde belirteç bütçesi bir üst sınırdır ve seçimi değil **tasarımı** dayatır. Aynı görev, aynı model ve aynı isabetle bile, istemin nasıl yazıldığına göre istek başına kaç belirteç harcandığı büyük ölçüde değişir. Sonraki ders dört düzeneği belirteç ve isabet olarak karşılaştırır — uzun istem, kısa istem ile örnek, özetleyip gönderme ve önbellek — ve bütçe daraldığında hangi tasarımın zorunlu hale geldiğini gösterir. O ders aynı zamanda kursun kapanışıdır. ### Belirteç Temelli Maliyet Source: https://academia.sh/tr/kurslar/yz-muhendisligine-giris/belirtec-temelli-maliyet Doksan altı istekten oluşan kurgu akışta dört düzenek belirteç ve isabet olarak karşılaştırılıyor: uzun istem 0,7083 isabet ve istek başına 156,6 belirteç, kısa istem ile örnek aynı isabeti 100,6 belirteçle veriyor, özetleyip gönderme 0,8021 ile 74,0 belirtece iniyor, sert özet 68,0 belirteçte isabeti 0,0833'e düşürüyor ve önbellek 17,7 belirteçle 0,7500 veriyor. Toplam belirteç 15.034'ten 1.702'ye iniyor ve model çağrısı 96'dan 23'e düşüyor. Bütçe 7.000 belirtece indiğinde beş düzenekten yalnız ikisi sığıyor ve tasarım seçilmiş değil dayatılmış olur. Önbelleğin isabeti iki koşumda 0,7500 ve 0,9583 çıkıyor. Önceki derste belirteç bir ölçüt olarak sayıldı ama bir sınır olarak hiç kullanılmadı. Gerçek bir sistemde bütçe bir üst sınırdır ve seçimi değil **tasarımı** dayatır. Aynı görev, aynı model ve aynı isabetle bile, istemin nasıl yazıldığına göre istek başına harcanan belirteç birkaç kat değişir. Bu ders dört düzeneği aynı istek akışında belirteç ve isabet olarak karşılaştırır. Birim **belirteçtir**; para birimi yazılmaz, çünkü belirteç sayısı ölçülebilir ve kalıcıdır, fiyat ise ne ölçülebilir ne kalıcıdır. - **DL71. İstek akışı 96 kurgu destek talebidir** ve tekrar içerir: 24 talep, sıklıkları eşit olmayacak biçimde çekilir. Talepler ve sınıflar **kurgudur**, tohum **20260218**. - **DL72. Ölçü ikilidir:** istek başına belirteç (küçük iyi) ve isabet (büyük iyi). Model çağrısı sayısı ayrıca yazılır. - **DL73. Dört düzenek merdiven gibidir**, her satır bir öncekine bir şey ekler: uzun istem, kısa istem ile örnek, özetleyip gönderme, önbellek. Dördüncü satır olan sert özet, üçüncü satırın daha sert bir ayarıdır ve sınırı göstermek için ölçülür. - **DL74. Özetleyip gönderme, talebi isteme koymadan önce kırpar.** Kırpma modelden önce, kurumun kendi tarafında yapılır ve modele hiç belirteç ödetmez. - **DL75. Önbellek yanıtı isteğe göre saklar.** Aynı talep ikinci kez geldiğinde model hiç çağrılmaz; saklanan yanıt doğruysa doğru, yanlışsa yanlış tekrarlanır. - **DL76. Belirsizlik iki koşumla ölçülür**; ikinci koşum tohum 20260219 ile alınır. #### Dört Düzeneğin Belirteci ve İsabeti ```python # ORTAK -- KURGUDUR. Benzetici gercek bir uc nokta cagirmaz. Bedel birimi BELIRTECTIR; # para birimi yazilmaz. Istek akisi tekrar iceren 96 kurgu destek talebidir. TOHUM, M32 = 20260218, 0xFFFFFFFF 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): """Kurgu belirtecleyici: harf obekleri dorder, rakam obekleri ikiser bolunur.""" cikti, tampon = [], "" for ch in metin + " ": if ch.isalnum(): tampon += ch continue if tampon: n = 2 if tampon.isdigit() else 4 cikti += [tampon[i:i + n] for i in range(0, len(tampon), n)] tampon = "" if ch.strip(): cikti.append(ch) return cikti BAS = [("sayac okunmadi tahmini fatura cikti", "olcum"), ("fatura tutari gecen aya gore iki kat cikti", "odeme"), ("gece boyunca su basinci dustu", "tesisat"), ("planli kesinti bildirimi ulasmadi", "kesinti"), ("abonelik devri sayaca islenmedi", "sozlesme")] EK = ["sayacin numarasi degistirilmis olabilir", "adres bilgisi eski gorunuyor", "onceki ay ayni sorun yasanmadi", "sayaca ulasilamiyor kapi kapali", "kesinti suresi beklenenden uzun surdu", "otomatik talimat sayacta yok"] SOZLUK = {"kesinti": ["kesi", "bild"], "olcum": ["okun", "olcu", "tahm"], "tesisat": ["basi", "dust", "tesi", "vana"], "odeme": ["fatu", "odem", "tali", "tuta"], "sozlesme": ["abon", "adre", "devr", "sozl"]} SINIFLAR = list(SOZLUK) TALEP = [] for i in range(24): r = uretec(TOHUM + 31 * i) a, b = 100000 + int(r() * 380000), 100000 + int(r() * 380000) TALEP.append({"no": 4100 + i, "sinif": BAS[i % 5][1], "metin": f"abone {4100 + i}: {BAS[i % 5][0]}, {EK[(5 * i + 2) % 6]}." f" ana sayac {a} ara sayac {b}."}) r = uretec(TOHUM + 9091) AKIS = [int(r() ** 1.7 * 24) for _ in range(96)] # tekrar iceren kurgu istek akisi # (ad, yonerge belirteci, ornek belirteci, girdi kirpma, onbellek) DUZENEK = [("uzun istem", 118, 0, 0, False), ("kisa istem + ornek", 16, 46, 0, False), ("ozetleyip gonderme", 16, 46, 12, False), ("sert ozet", 16, 46, 6, False), ("onbellek", 16, 46, 12, True)] def cagir(t, kirpma, sira, tohum): """Benzetici: istemde gorunen belirtecleri kullanir; kirpma gorunen kismi kisaltir.""" bel = belirtecle(t["metin"]) bel = bel[:kirpma] if kirpma else bel sz = {s: set(o[:4]) for s, o in SOZLUK.items()} p = sorted(((sum(b in sz[s] for b in bel), s) for s in SINIFLAR), key=lambda x: (-x[0], x[1])) if p[0][0] == 0 or p[0][0] == p[1][0]: return "belirsiz" return p[1][1] if uretec(tohum + 37 * sira + 7 * t["no"])() < 0.14 else p[0][1] def olc(duzenek, tohum=TOHUM): ad, yonerge, ornek, kirpma, onbellek = duzenek bellek, dogru, belirtec, cagri = {}, 0, 0, 0 for sira, i in enumerate(AKIS): t = TALEP[i] if onbellek and i in bellek: dogru += bellek[i] == t["sinif"] continue # istek modele hic gitmez n = len(belirtecle(t["metin"])) y = cagir(t, kirpma, sira, tohum) belirtec += yonerge + ornek + (min(n, kirpma) if kirpma else n) cagri += 1 bellek[i] = y dogru += y == t["sinif"] return dogru / len(AKIS), belirtec / len(AKIS), cagri, belirtec print(f"kurgu istek akisi {len(AKIS)} istek, benzersiz talep {len(set(AKIS))}/24") print("duzenek isabet isabet B belirtec/istek model cagrisi toplam belirtec") for d in DUZENEK: i, b, c, top = olc(d) i2 = olc(d, TOHUM + 1)[0] print(f"{d[0]:<20} {i:.4f} {i2:.4f} {b:>6.1f} {c:>3}/96 {top:>6}") ``` ``` kurgu istek akisi 96 istek, benzersiz talep 23/24 duzenek isabet isabet B belirtec/istek model cagrisi toplam belirtec uzun istem 0.7083 0.7396 156.6 96/96 15034 kisa istem + ornek 0.7083 0.7396 100.6 96/96 9658 ozetleyip gonderme 0.8021 0.8438 74.0 96/96 7104 sert ozet 0.0833 0.0833 68.0 96/96 6528 onbellek 0.7500 0.9583 17.7 23/96 1702 ``` İlk iki satır aynı isabeti veriyor: **0,7083** ve ikinci koşumda **0,7396**. Aralarındaki tek fark uzun bir yönerge yerine kısa bir yönergeyle iki örnek konulmasıdır. Bedel farkı istek başına **56,0** belirteç, toplamda **5.376** belirteçtir. Bu, tablodaki en kolay kazançtır ve isabete hiçbir şey ödetmez. Uzun istem, ölçülmediği sürece iyi bir istem gibi görünür. Üçüncü satır beklenmedik yöne gidiyor: özetleyip göndermek belirteci **74,0**'a indirirken isabeti **0,8021**'e **çıkarıyor**. Sebep kurgudadır ve okunabilir — kırpma, talebin ek tümcesini düşürüyor, ek tümce ise sınıf kanıtını bulandıran öbekleri taşıyordu. Bu bir genel yasa değil, bu veri kümesinin bir özelliğidir. Nitekim dördüncü satır sınırı gösteriyor: kırpma altı belirtece sertleştirildiğinde isabet **0,0833**'e çöküyor ve karşılığında yalnız **6,0** belirteç kazanılıyor. Özet bir ayardır ve ayarın iyi tarafı ile uçurumu birbirine çok yakındır. Son satır tablodaki en büyük kazancı taşıyor: istek başına **17,7** belirteç, model çağrısı **23/96**. Doksan altı isteğin yetmiş üçü modele hiç gitmiyor. İsabet **0,7500** ile üçüncü satırın altında, ama iki koşum sütununa bakmak gerekiyor: aynı önbellek ikinci tohumda **0,9583** veriyor. Önbellek isabeti düşürmüyor da yükseltmiyor da; **donduruyor**. Bir talebin ilk yanıtı ne çıktıysa o talebin bütün tekrarları o yanıtı alıyor. Belirsiz bir bileşenin önüne konan önbellek, belirsizliği ortadan kaldırmaz; onu tek bir çekilişe indirger ve sonucu kalıcı yapar. #### Bütçenin Dayattığı Tasarım ```python SONUC = [(d[0],) + olc(d) for d in DUZENEK] print("butce istek basina sigan duzenek butcenin dayattigi tasarim isabet") for butce in (16000, 10000, 7000, 2000, 1500): sigan = [s for s in SONUC if s[4] <= butce] en = max(sigan, key=lambda s: s[1]) if sigan else None print(f"{butce:>6} {butce / 96:>6.1f} {len(sigan)}/5 " f"{(en[0] if en else 'hicbiri'):<26} {(f'{en[1]:.4f}' if en else ' - ')}") print("bedeli yazilmayan duzenek: uzun istem ile kisa istem + ornek ayni isabeti verir," " fark 5376 belirtec") ``` ``` butce istek basina sigan duzenek butcenin dayattigi tasarim isabet 16000 166.7 5/5 ozetleyip gonderme 0.8021 10000 104.2 4/5 ozetleyip gonderme 0.8021 7000 72.9 2/5 onbellek 0.7500 2000 20.8 1/5 onbellek 0.7500 1500 15.6 0/5 hicbiri - bedeli yazilmayan duzenek: uzun istem ile kisa istem + ornek ayni isabeti verir, fark 5376 belirtec ``` Bütçe geniş olduğunda tasarım **seçilir**: 16.000 belirteçte beş düzeneğin beşi de sığıyor ve en yüksek isabeti veren seçiliyor. Bütçe 7.000'e indiğinde tasarım **dayatılır**: yalnız iki düzenek sığıyor ve en iyisi 0,8021 değil **0,7500**'dür. Aradaki 0,0521 bir mühendislik hatası değil, bütçenin fiyatıdır. 1.500 belirteçte hiçbir düzenek sığmıyor; o noktada yapılacak şey daha iyi bir istem yazmak değil, ya bütçeyi büyütmek ya da isteklerin bir kısmını modelden hiç geçirmemektir. Bu tablonun okunma sırası da önemlidir. Bütçe daralırken ilk düşen düzenek en pahalı olan, en kötü olan değildir. Uzun istem 15.034 belirteçle listeden ilk çıkandır ve isabeti kısa istemle birebir aynıdır; yani bütçe önce **hiçbir şey kazandırmayan bedeli** kesiyor. Bir sistemi ucuzlatmanın ilk adımı da budur: kazancı ölçülmemiş düzenekleri bulup çıkarmak. Bedeli yazılmayan düzenek, ölçülmemiş olduğu için savunulamaz. #### Özet - Uzun istem ile kısa istem artı örnek aynı isabeti (0,7083) veriyor; fark istek başına 56,0, toplamda 5.376 belirteçtir ve isabete hiçbir şey ödetmez. - Özetleyip gönderme belirteci 74,0'a indirirken isabeti 0,8021'e çıkarıyor, ama kırpma altı belirtece sertleştirildiğinde isabet 0,0833'e çöküyor ve karşılığı yalnız 6,0 belirteçtir. - Önbellek istek başına 17,7 belirteçle en ucuzudur ve 96 isteğin 73'ünü modele hiç göndermez; isabeti düşürmez de yükseltmez, tek bir çekilişe indirger ve donduruyor (0,7500 ile 0,9583). - Bütçe 7.000 belirtece indiğinde beş düzenekten ikisi sığıyor ve tasarım seçilmiş değil dayatılmış olur; en iyi ulaşılabilir isabet 0,8021'den 0,7500'e iner. - Bütçe daralırken ilk çıkan düzenek en pahalı olandır ve isabete hiçbir katkısı yoktur; bir sistemi ucuzlatmanın ilk adımı kazancı ölçülmemiş düzenekleri çıkarmaktır. #### Kurs Kapanışı On dört dersin hesabı tek tabloda ve her sayı kendi dersinden okundu. Satırlar ortak birim taşımaz; ikinci sütun her satırın **hangi ölçütle** okunduğunu yazar. **Fark tek işaret düzeniyle verilir: düzeneğin sayısı eksi çıplak çağrının sayısı** ve üçüncü sütunda parantez içindedir. | Ders | Çıplak çağrı | Düzenekle | Bedel | |---|---|---|---| | Alan 01 mühendis | etiket isabeti 0,6000 | etiket kümesi ve biçim kısıtı 0,7750 (+0,1750) | toplam belirteç 1,54 kat, çağrı 120 → 123, doğru etiket başına 50,7 → 60,4 | | Alan 02 fark | biçim kısıtsız isabet 0,5000 | biçim kısıtı 0,8056 (+0,3056) | −634 belirteç, 0 etiketli örnek; yeniden deneme +1 çağrı, +51 belirteç, (+0,0000) | | Alan 03 ürün | düzeneksiz isabet 0,5556 | kaynağa bağlamak 0,8958 (+0,3402) | +4.986 belirteç, 144 erişim adımı, gecikme sınıfı zincir | | Alan 04 ayrım | genel iddiada sınanan 0/9 | ölçülebilir iddiada sınanan 5/5, geçen 3 (+5 sınama) | iddia başına dört bileşen: görev, ölçüt, küme, yönüyle eşik | | Dil 01 belirteçler | talep başına 27,78 belirteç, isabet 0,9722 | 0,50 eşiği 11,68 belirteç, 0,9722 (−16,10 belirteç) | ön işleme adımı ve sıklık tablosu; 0,30 eşiği isabeti 0,8611'e düşürür | | Dil 02 dönüştürücü | son 16 belirteç, isabet 0,0000 | uzaklıktan bağımsız ağırlık 1,0000 (+1,0000) | karşılaştırma 16 → 69,7; 1024 belirteçte sabit pencerenin 8,26 katı | | Dil 03 önceden eğitim | arıza kodu isabeti 0,0900 | 400 örnekle ince ayar 0,9400 (+0,8500) | 400 etiketli örnek; genel metin 0,4616 → 0,3998 (−0,0618) | | Dil 04 çıkarım | çıktı sınırı 4, isabet 0,0000 | sınır 8, isabet 1,0000 (+1,0000) | 4,00 → 6,43 belirteç, 126,0 → 211,1 karşılaştırma (1,68 kat) | | Dil 05 bağlam penceresi | tam yanıt 0,3833, istem 282,3 belirteç | baştan atmak 0,7433 (+0,3600) | −64,8 belirteç ama ek kırpma adımı; zaman aşımı payı 0,0200 → 0,0600 | | Dil 06 yetenekler | sayma 0,4167, kesin hesap 0,2917 | yordam düzeneği 1,0000 ve 1,0000 (+0,5833, +0,7083) | 33,3 → 69,6 belirteç, 1 → 2 çağrı, zincir; çoğunluk 99,9 belirteçle (+0,0000) | | Dil 07 halüsinasyon | uydurma oranı 0,6667, isabet 0,2917 | kaynağa bağlama 0,3333 ve 0,6667 (−0,3334, +0,3750) | 9,8 → 27,8 belirteç; bilmiyorum seçeneği isabeti (−0,0417) düşürür | | Dil 08 erişim biçimi | açık ağırlıklı çıplak isabet 0,1250 | altı örnekle 0,7917 (+0,6667) | 38,3 → 176,3 belirteç (4,60 kat); kapalı biçimde 24/24 istek dışarı | | Dil 09 model seçimi | dengeli ağırlıkta orta aday 3,1078 | isabet ağırlığı 4'te büyük aday 4,0000 (+0,8922) | denk belirteç 181,2 → 627,5 (3,46 kat), adım 7,00 → 14,00 | | Dil 10 maliyet | uzun istem 0,7083, istek başına 156,6 belirteç | önbellek 0,7500, 17,7 belirteç (+0,0417, −138,9) | model çağrısı 96 → 23; isabet iki koşumda 0,7500 ve 0,9583 | **Kursun kuralı budur: verilmiş bir bileşen yüzeyinden ölçülür; içine bakılamayan bir bileşenin sayısı yüzeyinde yazılıdır.** Tablodaki hiçbir sayı modelin içinden gelmedi. Hepsi bir isteğin girdiği, bir yanıtın çıktığı ve arada kaç belirteç, kaç çağrı, kaç adım harcandığı sayılarak alındı. Modelin mimarisi, ağırlıkları ve eğitildiği veri tabloda hiçbir yerde geçmiyor, çünkü bunlar bu kursta ölçülebilir büyüklükler değildi; ölçülebilir olan her şey yüzeydeydi. **Müfredatın kuralı da buradan okunur: bir yapay zekâ sisteminin sayısı, modelin sayısı değil düzeneğin sayısıdır; bedeli yazılmayan düzenek ölçülmemiş sayılır.** Dördüncü sütun bu yüzden tabloda durur ve hiçbir satırda boş değildir. Müfredatın ikinci iddiası da aynı tablodan adıyla okunur: **düzenek eklemek her zaman iyileştirmez.** Alan 02'de yeniden deneme sayıyı 0,0000 oynatıp bir çağrı ve 51 belirteç ekledi. Alan 03'te seçenek sunmak görünen değişimi 0,3889'dan 0,4583'e yükseltti. Dil 01'de 0,30 eşiği isabeti 0,9722'den 0,8611'e düşürdü. Dil 03'te ince ayar alan metnini düzeltirken genel metni 0,4616'dan 0,3998'e indirdi. Dil 05'te özetlemek istemi 100,6 belirtece indirdi ama sorulan adımı attığı için tam yanıt oranını 0,3833'ten 0,0000'a çökertti. Dil 06'da üç koşumlu çoğunluk 99,9 belirteç harcayıp sayma ile kesin hesapta hiçbir şey değiştirmedi. Dil 07'de bilmiyorum seçeneği isabeti tabanın 0,0417 altına düşürdü. Dil 10'da sert özet isabeti 0,8021'den 0,0833'e çökertti. Sekiz satır, tek bir kural: bir düzeneğin bedeli kesindir, kazancı değildir. On dört derste modelin yüzeyi ölçüldü ve her sayının yanına bedeli yazıldı. Sorulmayan tek şey modele **ne söylendiğidir**. Bütün tabloda istem ya sabit tutuldu ya da uzunluğuyla anıldı; içinde ne yazdığı, hangi sırayla yazdığı, örneğin nereye konduğu ve yönergenin nasıl kurulduğu hiç değişken olmadı. Aynı görevde aynı modele başka bir metin verildiğinde sayının ne kadar oynadığı ve o metnin kendisinin bir **tasarım nesnesi** olduğu ölçülmedi. Sonraki kurs, İstem Mühendisliği, tam olarak bu değişkeni açar.