Öz Tutarlılık

Önceki ders adım adım çözüm istemenin çok adımlı hesapta işe yaradığını gösterdi: isabet 0,3000’den 0,8833’e çıktı. Ama o sayı tek bir koşumdan geldi. Model belirsiz bir bileşendir; aynı istem ikinci bir koşumda başka bir zincir üretir ve zincirin bir yerinde kayarsa sonuç değişir. Elde tek bir zincir varken onun doğru olup olmadığını söyleyecek hiçbir şey yoktur.

Öz tutarlılık bu belirsizliği bir kaldıraca çevirir: aynı istem birden çok kez koşulur ve çıkan yanıtlar oylanır. Bu derste istemin metni hiç değişmez; değişen tek şey aynı istemin kaç kez koşulduğudur. Bu yüzden bedel belirtecin yanında çağrı sayısıyla da yazılır. Çoğunluk oyunun kendisi önceki müfredatın topluluk yöntemleri dersinde ölçüldü ve burada tekrarlanmaz; eklenen şey bedel ve uzlaşmanın kırıldığı yerdir.

• AY11. Kod gerçek bir uç nokta çağırmaz; standart kitaplıkla yazılmış bir dil modeli benzeticisini çağırır. Tohum 20260218. Bu ders yalnız hesap yolunu kullanır.
• AY12. Görev önceki dersinkidir: 60 kayıtlık kurgu tarife hesabı, basamaklar 10, 25 ve 40 m³, üstüne sabit bedel ve abone tipi indirimi. Ölçüt kesin eşitliktir.
• AY13. İstem önceki dersin adımlı istemidir ve harfi harfine aynı kalır.
• AY14. Gerçek bir uç noktada örnek çeşitliliği sıfırdan büyük dağılım sıcaklığından gelir; benzeticide tohum örnek başına bir artırılarak alınır.
• AY15. Örnek sayısı 1, 3, 5, 7 ve 9’dur; dokuzu aşmaz.
• AY16. Oylamada en çok oyu alan cevap seçilir, eşitlikte ilk ulaşan cevap kazanır. Hız sınırına takılan çağrı oy veremez ama çağrı sayısına ve belirteç bedeline girer.
• AY17. Uzlaşma: geçerli oyların yarısından fazlası aynı cevapta ise uzlaşma vardır. Tek örnekte uzlaşma her zaman kurulur ve hiçbir şey söylemez.
• AY18. Benzeticinin adım kayması iki türlüdür: her adımda 0,05 dağınık kayma, ve son basamağa düşen artık 5 m³ ve altındaysa 0,85 sistematik kayma. İkincisi bir modelleme varsayımıdır ve bu dersin ölçtüğü şeyin kaynağıdır.
• AY19. Bütün ölçüm iki tohum tabanıyla yinelenir: 20260218 ve 20260258.
• AY20. Bedel üç sayıdır: toplam belirteç, çağrı sayısı ve doğru yanıt başına düşen belirteç.

Aynı İstemin Dokuz Örneği

Önce tek bir kayıt üzerinde ne olduğuna bakılır. Aynı istem dokuz kez koşulur, her koşumda tohum bir artar, ve yanıttaki son sayı bir oy sayılır. İki kayıt seçildi: biri sıradan, öbürü 40 m³ sınırının hemen üstünde.

# BENZETICI. Bu kod gercek bir model uc noktasi cagirmaz; standart kitaplikla yazilmis
# bir dil modeli benzeticisidir. Destek talepleri ve tarife de KURGU'dur.
TOHUM, M32 = 20260218, 0xFFFFFFFF
PENCERE, EN_UZUN = 240, 96          # baglam penceresi ve adimli yanit icin cikti siniri


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


# KURGU tarife: basamak ust siniri (m3) ve birim, sabit bedel, abone tipi indirimi
BASAMAK, SABIT = [(10, 3), (25, 5), (40, 8), (10 ** 6, 12)], 20
TIP = {"konut": 0, "tarim": 20, "resmi": 10}
HESAP = []
for i in range(60):
    r = uretec(TOHUM + 900 + i)
    m3 = 6 + int(r() * 52)
    tp = sorted(TIP)[ayrik(r(), [0.40, 0.34, 0.26])]
    HESAP.append({"no": 7001 + i, "m3": m3, "tip": tp,
                  "metin": f"tuketim {m3} m3 abone tipi {tp} tutar ne kadar"})


def kademe(m3):                     # basamaklara bolunmus tuketimin toplami
    alt, kalan, t = 0, m3, 0
    for ust, birim in BASAMAK:
        pay = min(kalan, ust - alt)
        t, kalan, alt = t + pay * birim, kalan - pay, ust
        if kalan <= 0:
            break
    return t


def kesin(m3, tip):                 # gorevin dogru cevabi, benzeticinin disinda
    return ((kademe(m3) + SABIT) * (100 - TIP[tip])) // 100


SAYAC = [0]


def _gorev(bel):                    # istemin sonundaki talepten tuketim ve abone tipi
    return (next((int(u) for u in reversed(bel) if u.isdigit()), 0),
            next((t for t in reversed(bel) if t in TIP), "konut"))


def _adim_adim(m3, tip, r):         # her basamak ayri yazilir, adim basina kayma payi
    alt, kalan, t, s = 0, m3, 0, []
    for i, (ust, birim) in enumerate(BASAMAK):
        pay = min(kalan, ust - alt)
        # son basamakta kalan kucukse kayma sistematiktir: hep ayni yanlisa gider
        b = birim
        if r() < (0.85 if i == 3 and pay <= 5 else 0.05):
            b = BASAMAK[i - 1][1] if i + 1 == len(BASAMAK) else BASAMAK[i + 1][1]
        t, kalan, alt = t + pay * b, kalan - pay, ust
        s.append(f"basamak {i + 1} , {pay} m3 , birim {b} , ara toplam {t}")
        if kalan <= 0:
            break
    if r() < 0.05:
        s.append(f"sabit bedel atlandi ara toplam {t}")
    else:
        t += SABIT
        s.append(f"sabit bedel {SABIT} ara toplam {t}")
    ind = 0 if r() < 0.05 else TIP[tip]
    t = (t * (100 - ind)) // 100
    return " . ".join(s + [f"indirim {ind} sonuc {t}"])


def cagir(istem, tohum=TOHUM, 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:                      # hiz siniri cagri sayisina baglidir
        return {"durum": "hiz_siniri", "giris": len(bel), "cikis": 0, "yanit": ""}
    m3, tip = _gorev(bel)
    y = _adim_adim(m3, tip, uretec(tohum ^ izno(istem)))
    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_sayi(y):                                # yanittaki son sayi
    return next((int(x) for x in reversed(y.split()) if x.isdigit()), None)


ISTEM = ("Tarife: ilk 10 m3 birim 3 , sonraki 15 m3 birim 5 , sonraki 15 m3 birim 8 , "
         "40 ustu birim 12 . Sabit bedel 20 . Abone tipi indirimi yuzde konut 0 , "
         "tarim 20 , resmi 10 . Tutari hesapla . Once her basamagi ayri ayri adim adim "
         "yaz , sonra sonucu yaz . Talep: ")


def ornekle(x, n, taban):           # ayni istem n kez kosulur, yanitlar oylanir
    oy = {}
    for j in range(n):
        v = oku_sayi(cagir(ISTEM + x["metin"], tohum=taban + j)["yanit"])
        if v is not None:                       # hiz sinirina takilan cagri oy vermez
            oy[v] = oy.get(v, 0) + 1
    if not oy:
        return None, 0
    en = max(oy.values())
    return next(k for k in oy if oy[k] == en), en
SAYAC[0] = 0
for x in (HESAP[3], next(h for h in HESAP if 40 < h["m3"] <= 45)):
    oy, d = {}, kesin(x["m3"], x["tip"])
    for j in range(9):
        v = oku_sayi(cagir(ISTEM + x["metin"], tohum=TOHUM + j)["yanit"])
        oy[v] = oy.get(v, 0) + 1
    sec, en = ornekle(x, 9, TOHUM)
    print(f"kayit {x['no']}: {x['m3']} m3 , {x['tip']} , dogru cevap {d}")
    print(f"  dokuz ornek: {sorted(oy.items(), key=lambda p: -p[1])}")
    print(f"  uzlasma {sec} ({en}/9) -> {'dogru' if sec == d else 'YANLIS'}")

kayit 7004: 12 m3 , resmi , dogru cevap 54
  dokuz ornek: [(54, 6), (36, 2), (59, 1)]
  uzlasma 54 (6/9) -> dogru
kayit 7008: 45 m3 , tarim , dogru cevap 244
  dokuz ornek: [(228, 5), (276, 2), (264, 1), (244, 1)]
  uzlasma 228 (5/9) -> YANLIS

Birinci kayıtta oylama işe yarıyor. Dokuz örneğin altısı 54 diyor ve doğru cevap bu. Kalan üç oy iki ayrı yanlışa dağılmış: 36, sabit bedelin atlandığı yanıt; 59, ikinci basamağın biriminin kaydığı yanıt. Hatalar birbirinden farklı, doğru cevap ise hepsinde aynı. Dağınık hatanın oylamayla düzelmesinin nedeni budur — yanlış gitmenin birçok yolu vardır, doğru gitmenin bir tane.

İkinci kayıtta aynı düzenek ters çalışıyor. Doğru cevap 244 ve dokuz örnekten yalnız biri onu söylüyor. Çoğunluk 228 üzerinde toplanıyor: 45 m³’ün son 5 m³’ü en üst basamağın birimiyle değil bir alt basamağınkiyle hesaplanmış. Oylama bu kaydı düzeltmiyor, yanlışı pekiştiriyor. Aradaki fark hatanın türündedir: birincisi dağınık, ikincisi sistematik.

Örnek Sayısı, Kazanç ve Çağrı

Aynı ölçüm bütün kümede ve beş ayrı örnek sayısında yinelenir. Her satır iki tohum tabanıyla koşulur; ikinci sütun aynı düzeneğin ikinci koşumudur.

def olc(n, taban):
    SAYAC[0] = 0
    g = c = d = uz = bos = 0
    kirik = []
    for x in HESAP:
        oy, dogru = {}, kesin(x["m3"], x["tip"])
        for j in range(n):
            s = cagir(ISTEM + x["metin"], tohum=taban + j)
            g, c = g + s["giris"], c + s["cikis"]
            v = oku_sayi(s["yanit"])
            if v is None:
                bos += 1                        # hiz sinirina takilan cagri oy vermez
            else:
                oy[v] = oy.get(v, 0) + 1
        if not oy:
            continue                            # tek ornek hiz sinirina takildi
        en = max(oy.values())
        sec = next(k for k in oy if oy[k] == en)
        d += sec == dogru
        if en * 2 > sum(oy.values()):           # yarisindan fazlasi ayni cevapta
            uz += 1
            if sec != dogru:
                kirik.append(x["m3"])
    return {"isabet": d / len(HESAP), "cagri": SAYAC[0], "belirtec": g + c,
            "uzlasan": uz, "kirik": kirik, "bos": bos}


print(f"{'ornek':>5} {'isabet':>8} {'ikinci':>8} {'cagri':>6} {'belirtec':>9} "
      f"{'birim':>7} {'uzlasan':>8} {'yanlista':>9}")
for n in (1, 3, 5, 7, 9):
    A, B = olc(n, TOHUM), olc(n, TOHUM + 40)
    print(f"{n:>5} {A['isabet']:>8.4f} {B['isabet']:>8.4f} {A['cagri']:>6} "
          f"{A['belirtec']:>9} {A['belirtec'] / A['isabet'] / len(HESAP):>7.1f} "
          f"{A['uzlasan']:>8} {len(A['kirik']):>9}")
    if n == 9:
        print(f"\ndokuz ornekte yanlista uzlasan kayitlarin tuketimi: "
              f"{sorted(A['kirik'], reverse=True)} m3")
        print(f"hiz sinirina takilip oy veremeyen cagri: {A['bos']}")

ornek   isabet   ikinci  cagri  belirtec   birim  uzlasan  yanlista
    1   0.7667   0.6667     60      7954   172.9       59        13
    3   0.8500   0.8667    180     23785   466.4       56         6
    5   0.8667   0.8833    300     39552   760.6       55         4
    7   0.8833   0.9000    420     55389  1045.1       57         5
    9   0.8833   0.8833    540     71211  1343.6       58         5

dokuz ornekte yanlista uzlasan kayitlarin tuketimi: [45, 45, 44, 43, 41] m3
hiz sinirina takilip oy veremeyen cagri: 14

İlk sütun kazancı veriyor. Tek örnekte isabet 0,7667, dokuz örnekte 0,8833; kazanç +0,1167. Kazancın dağılımı düzgün değil: ilk üç örnek +0,0833 getiriyor, sonraki dört örnek yalnız +0,0333, ve yediden dokuza geçiş hiçbir şey getirmiyor. Kazanç yedinci örnekte doyuyor.

İkinci sütun bu dersin en önemli sayısıdır. Tek örnekte iki koşum 0,7667 ve 0,6667 veriyor; aradaki fark 0,1000. Dokuz örnekte iki koşum da 0,8833 veriyor; fark 0,0000. Tek örnekli kazanç (+0,1167) tek örneğin koşum farkının (0,1000) ancak biraz üstünde kalıyor, yani ilk koşuma bakarak ölçülmüş saymak zor olurdu. İkinci koşumda aynı kazanç +0,2166. Tekniğin en sağlam ölçülen etkisi isabeti yükseltmesi değil, koşumdan koşuma oynamayı sıfıra indirmesidir.

Üçüncü ve dördüncü sütunlar bedeldir ve tartışmasızdır. Çağrı sayısı 60’tan 540’a, toplam belirteç 7954’ten 71211’e çıkıyor — belirteç neredeyse tam dokuz kat. Doğru yanıt başına bedel 172,9’dan 1343,6 belirtece yükseliyor, yani 7,8 kat. Kazanç 0,1167’de kalırken bedelin dokuz katına çıkması, bu tekniğin niçin her görevde açılamayacağını tek satırda söylüyor. Üç örneğin sayısı (0,8500, 466,4 belirteç) çoğu durumda dokuz örnekten daha savunulabilir bir noktadır.

Uzlaşmanın Kırıldığı Yer

Son iki sütun oylamanın kendisine bakıyor. Tek örnekte 59 kayıtta uzlaşma var ve bunların 13’ü yanlış; çünkü tek oy her zaman çoğunluktur. Uzlaşmanın tek başına hiçbir şey söylemediği buradan görünür. Dokuz örnekte uzlaşan kayıt 58, yanlışta uzlaşan 5. Yanlışta uzlaşan kayıt sayısı örnek sayısı üçten dokuza çıkarken 6, 4, 5 ve 5’te takılıp kalıyor.

Bu beş kaydın tüketimi basılıyor: 45, 45, 44, 43 ve 41 m³. Hepsi 40 m³ sınırının hemen üstünde. Bu kayıtlarda son basamağa düşen artık küçüktür ve benzetici onu sistematik olarak bir alt basamağın biriminden hesaplar. Hata rastgele değil, bu yüzden dokuz örnek de aynı yanlışa gidiyor. Öz tutarlılık dağınık hatayı düzeltir, sistematik hatayı pekiştirir. Uzlaşma bir doğruluk kanıtı değildir; yalnız hatanın dağınık olmadığının işaretidir.

Bedelin kazanca dönüşmediği bir yer daha var: 540 çağrının 14’ü hız sınırına takıldı, oy veremedi ve yine de çağrı sayısına girdi. Çağrı sayısını dokuza katlayan her düzenek, yüzeyin başarısızlık payını da dokuza katlar.

Özet

• Öz tutarlılık, aynı istemi birden çok kez koşup yanıtları oylamaktır; istemin metni değişmez, değişen şey koşum sayısıdır.
• Örnek sayısı birden dokuza çıkarken isabet 0,7667’den 0,8833’e yükseliyor; kazancın +0,0833’ü ilk üç örnekten geliyor ve yedinci örnekten sonra kazanç duruyor.
• Bedel iki birimle yazılır: çağrı 60’tan 540’a, toplam belirteç 7954’ten 71211’e, doğru yanıt başına belirteç 172,9’dan 1343,6’ya. Belirteç dokuz kat, kazanç 0,1167.
• Tekniğin en sağlam ölçülen etkisi koşum farkını 0,1000’den 0,0000’a indirmesidir; tek örneğin kazancı, tek örneğin koşum farkının ancak biraz üstündedir.
• Dokuz örnekte 58 kayıtta uzlaşma kuruluyor, 5’inde uzlaşma yanlış bir cevapta. Bu beş kaydın tüketimi 41 ile 45 m³ arasındadır: hata sistematik olduğunda oylama onu düzeltmez, pekiştirir.

Sonraki Adım

Birden çok çözüm üretip oylamak işe yaradı, ama üretilen çözümlerin ortak bir yanı vardı: her biri baştan sona birbirinden bağımsız kuruldu. Dokuz örnek dokuz kez sıfırdan başladı, hiçbiri ötekinin nerede kaydığını görmedi ve hiçbiri bir başkasının iyi giden ilk yarısını devralmadı. Bir çözümün ortasından dallanmak hiç denenmedi. Sonraki ders bunu dener: çözüm tek parça bir zincir olmaktan çıkıp adım adım büyüyen ve her adımda birkaç yöne ayrılan bir yapıya dönüşür. Ölçülecek olan dallanma çarpanı ve derinlik arttıkça çağrı sayısının nasıl büyüdüğü ve kazancın nerede durduğudur.