Bağlam Kurma

Önceki iki ders neyin getirileceğini düzeltti: sorgu dizin diline çevrildi, adaylar ikinci bir aşamada yeniden sıralandı. İkisinde de getirilen parçalar isteme sıralandıkları gibi ve kaç tane isteniyorsa o kadar konuldu. Bu ders o adımı ölçer, çünkü bağlamı kurmak da bir düzenektir ve iki kısıtı vardır.

Birincisi sınırdır: bağlam penceresi sabittir ve parça sayısı onu aşınca istek yanıtsız döner. İkincisi sıradır: aynı parçalar aynı istemde farklı yerlere konduğunda modelin hangisine baktığı değişir. Bu derste ayrıca her yanıt kullandığı parçanın kodunu alıntılar; kaynağa bağlama, hatanın hangi yarıda olduğunu okunur kılar.

• EH54. Kod bir benzeticidir; gerçek bir gömme ya da model uç noktası çağrılmaz. Dağarcık, kavramlar ve sorgular kurgudur, tohum 20260218.
• EH55. Hedef tanımı ve hat erisim-hatti/05’ten sürer. Dönüştürme ve yeniden sıralama kapalıdır; ölçülen tek düzenek bağlamın kurulmasıdır.
• EH56. Bağlam penceresi 240 belirteçtir. Pencerenin tanımı M28/K01’de yapıldı ve tekrarlanmaz; burada bir kısıt olarak kullanılır.
• EH57. Her parça bağlama kodu ile girer ve yanıt kullandığı parçanın kodunu alıntılar. Benzetici yanıtı seçtiği parçadan kurduğu için kaynağa sadakat tanım gereği tamdır; ölçülen şey alıntının doğruluğudur.
• EH58. Pencereyi aşan istek yanıtsız döner ve o sorgu yanlış sayılır.
• EH59. Üretim benzeticisinin konum ağırlığı modellenmiştir: ilk parça 1,0, son parça 0,8, aradakiler 0,45. Bu dersin ölçtüğü şey bu ağırlığın sonucudur.
• EH60. Kontrollü deneyde bağlamda hep bir ilgili parça bulunur ve yanına j ilgisiz parça konur; böylece erişim sabitlenir ve yalnız bağlam ölçülür.
• EH61. Değişme payı, aynı parçalar farklı sırada verildiğinde alıntılanan parçanın değişme payıdır. Karşılaştırma tabanı, sıra sabitken tohumun değiştiği koşumdur.

Bağlam Bütçesi

Bir istemin bütçesi üç kalemden oluşur: yönerge, sorgu ve parçalar. İlk ikisi sabittir, üçüncüsü k ile büyür. Aşağıdaki blok hattı kurar, bütçeyi çıkarır ve k’yı birden on üçe kadar artırarak erişim ile üretimi yan yana basar.

# BENZETICI -- KURGUDUR. Gercek bir gomme ya da model uc noktasi cagrilmaz; dagarcik,
# kavramlar ve sorgular kurgudur, tohum 20260218.
import math
TOHUM, M32 = 20260218, 0xFFFFFFFF
BOYUT = 32


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


# ---- KURGU anlam ekseni: her kavramin belge dilinde ve sorgu dilinde ayri yuzeyi var
SINIF = ["tarife", "ariza", "sayac", "kesinti", "bakim"]
KOD = {"tarife": "TR", "ariza": "AR", "sayac": "SY", "kesinti": "KS", "bakim": "BK"}
KAVRAM = {                       # kavram: (sinif, belge yuzeyi, sorgu yuzeyi)
    "basamak":   ("tarife", "kademe esigi", "hangi dilimdeyim"),
    "birim":     ("tarife", "birim ucret", "metrekup fiyati"),
    "abonetip":  ("tarife", "abone tipi", "mesken mi isyeri mi"),
    "gecis":     ("tarife", "tarife gecisi", "plan degistirme"),
    "arizakod":  ("ariza", "ariza kodu", "hata numarasi"),
    "sizinti":   ("ariza", "hat sizintisi", "su kacagi"),
    "basinc":    ("ariza", "basinc dususu", "zayif akis"),
    "ekip":      ("ariza", "saha ekibi", "gorevli ne zaman gelir"),
    "endeks":    ("sayac", "endeks degeri", "sayac ustundeki rakam"),
    "okuma":     ("sayac", "okuma yordami", "nasil kaydediliyor"),
    "degisim":   ("sayac", "sayac degisimi", "cihaz yenileme"),
    "dogrula":   ("sayac", "okuma dogrulamasi", "yanlis girilmis mi"),
    "planli":    ("kesinti", "planli kesinti", "onceden duyurulan durma"),
    "duyuru":    ("kesinti", "duyuru kanali", "nereden ogrenirim"),
    "sure":      ("kesinti", "kesinti suresi", "ne kadar surer"),
    "geridonus": ("kesinti", "yeniden verme", "ne zaman gelir"),
    "periyot":   ("bakim", "periyodik bakim", "duzenli kontrol"),
    "vana":      ("bakim", "vana kontrolu", "musluk kapatma duzeni"),
    "filtre":    ("bakim", "filtre degisimi", "temizleme parcasi"),
    "kalib":     ("bakim", "kalibrasyon kaydi", "olcum ayari"),
}
ANAHTAR = list(KAVRAM)
ORTAK = ["kayit", "bolge", "donem", "islem", "form", "onay", "not"]

# ---- KURGU dagarcik
BELGE = []
for i in range(200):
    r = uretec(TOHUM + 7919 * i)
    s = SINIF[ayrik(r(), [0.22, 0.24, 0.20, 0.18, 0.16])]
    kav = [k for k in ANAHTAR if KAVRAM[k][0] == s]
    ana = kav[int(r() * len(kav))]
    n = 2 + int(r() * 4)
    par, kavlar = [], [ana]
    for _ in range(n):
        y = kav[int(r() * len(kav))]
        kavlar.append(y)
        o = ORTAK[int(r() * len(ORTAK))]
        par.append(f"{KAVRAM[y][1]} icin {o} tutulur ve {KAVRAM[ana][1]} ile birlikte yazilir")
    BELGE.append({"kod": f"{KOD[s]}{i + 1:03d}", "sinif": s, "ana": ana, "kavram": kavlar,
                  "baslik": f"{KAVRAM[ana][1]} yordami", "par": par})


def metin(d):
    return d["baslik"] + " " + " ".join(d["par"])


# ---- KURGU gomme: yuzey once kavrama, kavram sonra boyuta dusuruluyor
def _kavramla(m, alan=True):
    v = [0.0] * len(ANAHTAR)
    dm = " " + m.lower() + " "
    for i, k in enumerate(ANAHTAR):
        bel, sor = KAVRAM[k][1], KAVRAM[k][2]
        if bel in dm:
            v[i] += 1.0
        if sor in dm:
            v[i] += 1.0 if alan else 0.0      # alan disi gomme sorgu dilini tanimaz
    if not alan:
        for o in ORTAK:
            if " " + o + " " in dm:
                for i in range(len(ANAHTAR)):
                    v[i] += 0.05
    return v


IZDUS = []
for i in range(len(ANAHTAR)):
    r = uretec(TOHUM ^ (i + 1) * 2654435761)
    IZDUS.append([r() * 2 - 1 for _ in range(64)])


def gom(m, boyut=BOYUT, alan=True):
    k = _kavramla(m, alan)
    v = [0.0] * boyut
    for i, a in enumerate(k):
        if a:
            for j in range(boyut):
                v[j] += a * IZDUS[i][j % 64]
    n = sum(x * x for x in v) ** 0.5
    return [x / n for x in v] if n else v


def aci(a, b):
    return sum(x * y for x, y in zip(a, b))


# ---- KURGU sorgu kumesi: sorgu dili belge dilinden ayri
SORGU = []
for i in range(40):
    r = uretec(TOHUM + 104729 * i)
    d = BELGE[int(r() * len(BELGE))]
    SORGU.append({"metin": f"{KAVRAM[d['ana']][2]} {ORTAK[int(r() * len(ORTAK))]}",
                  "sinif": d["sinif"], "kavram": d["ana"]})

# ---- hat: parcalar, karma getirme, hedef tanimi ve uretim
PARCA = [{"kod": d["kod"], "ana": d["ana"], "metin": p} for d in BELGE for p in d["par"]]
for p in PARCA:
    p["vek"], p["bel"] = gom(p["metin"]), set(belirtecle(p["metin"]))
for s in SORGU:
    s["kayit"] = s["metin"].split()[-1]


def getir(q, k=5, w=0.5):
    qv, qb = gom(q), set(belirtecle(q))
    s = sorted(((aci(qv, p["vek"]) + w * len(qb & p["bel"]) / len(qb | p["bel"]), i)
                for i, p in enumerate(PARCA)), key=lambda t: (-t[0], t[1]))
    return [PARCA[i] for _, i in s[:k]]


def ilgili(s, p):
    return KAVRAM[s["kavram"]][1] in p["metin"] and s["kayit"] in p["bel"]


def izno(m):
    h = 2166136261
    for c in m:
        h = ((h ^ ord(c)) * 16777619) & M32
    return h


PENCERE = 240
SAYAC = [0]
YON_Y = "Asagidaki parcalara bakarak yanitla ve kullandigin parcanin kodunu yaz . "


def yanitla(sorgu, parcalar, tohum=TOHUM, sicaklik=0.12):
    """KURGU uretim: baglamdan bir parca secilir, parcanin YERI agirligi degistirir."""
    SAYAC[0] += 1
    istem = YON_Y + " ".join(f"[{p['kod']}] {p['metin']} ." for p in parcalar) + " Soru: " + sorgu
    bel = belirtecle(istem)
    if len(bel) > PENCERE:
        return {"durum": "baglam_asimi", "giris": len(bel), "cikis": 0, "parca": None}
    r, qb, n = uretec(tohum ^ izno(istem)), set(belirtecle(sorgu)), len(parcalar)
    p = [(1.0 if i == 0 else 0.8 if i == n - 1 else 0.45) * (0.3 + len(qb & x["bel"]) / len(qb))
         for i, x in enumerate(parcalar)]
    w = [math.exp(a / sicaklik) for a in p]
    se = parcalar[ayrik(r(), [a / sum(w) for a in w])]
    return {"durum": "tamam", "giris": len(bel), "parca": se,
            "cikis": len(belirtecle(f"{se['kod']} : {se['metin']}"))}


def kur(sorgu, parcalar):
    return (YON_Y + " ".join(f"[{p['kod']}] {p['metin']} ." for p in parcalar)
            + " Soru: " + sorgu)


op = sum(len(belirtecle(f"[{p['kod']}] {p['metin']} .")) for p in PARCA) / len(PARCA)
os_ = sum(len(belirtecle(s["metin"])) for s in SORGU) / 40
print("pencere %d ; yonerge %d + sorgu %.1f + parca basina %.1f belirtec -> sigan parca %.1f"
      % (PENCERE, len(belirtecle(YON_Y)), os_, op, (PENCERE - len(belirtecle(YON_Y)) - os_) / op))
print(" k  baglam ort  en buyuk  asan  anma@k  uretim  alinti kavram  alinti kayit")
for k in (1, 3, 5, 8, 10, 11, 12, 13):
    bl, an, ur, asan, ak, ay = [], 0, 0, 0, 0, 0
    for s in SORGU:
        g = getir(s["metin"], k)
        bl.append(len(belirtecle(kur(s["metin"], g))))
        an += any(ilgili(s, p) for p in g)
        y = yanitla(s["metin"], g)
        if y["parca"] is None:
            asan += 1
            continue
        ak += KAVRAM[s["kavram"]][1] in y["parca"]["metin"]
        ay += s["kayit"] in y["parca"]["bel"]
        ur += ilgili(s, y["parca"])
    print("%2d  %9.1f  %8d  %4d  %.4f  %.4f  %12.4f  %12.4f"
          % (k, sum(bl) / 40, max(bl), asan, an / 40, ur / 40, ak / 40, ay / 40))

pencere 240 ; yonerge 18 + sorgu 4.8 + parca basina 19.3 belirtec -> sigan parca 11.3
 k  baglam ort  en buyuk  asan  anma@k  uretim  alinti kavram  alinti kayit
 1       43.1        46     0  0.7750  0.7750        1.0000        0.7750
 3       81.8        88     0  0.7750  0.7500        1.0000        0.7500
 5      120.5       130     0  0.8000  0.7000        0.9500        0.7000
 8      178.4       193     0  0.8500  0.6500        1.0000        0.6500
10      217.0       235     0  0.9750  0.4750        0.9500        0.4750
11      236.3       256    14  0.9750  0.4750        0.6500        0.4750
12      255.7       277    32  0.9750  0.0750        0.2000        0.0750
13      275.2       298    40  0.9750  0.0000        0.0000        0.0000

Anma Yükselirken Üretim Düşüyor

Bütçe hesabı 11,3 parça diyor ve tablo bunu doğruluyor: on parçaya kadar hiçbir istek sınırı aşmıyor, on birde kırk sorgunun on dördü, on ikide otuz ikisi, on üçte hepsi aşıyor. Ortalama bağlam on üçüncü parçada 275,2 belirteçtir, en büyüğü 298. Sınır ortalamaya değil en büyüğe çarpar; ortalama 236,3 iken bile on dört istek yanıtsız döner.

Asıl bulgu iki sütunun zıt yönlere gitmesidir. k birden ona çıktığında erişim anması 0,7750’den 0,9750’e yükseliyor, üretim ise 0,7750’den 0,4750’ye düşüyor. Erişim ölçüsüne bakan bir plan k’yı büyütür ve iyileştiğini sanır; üretim ölçüsü tersini söyler. Kursun kuralının neden iki sütun istediği bu satırlarda görünür.

Son iki sütun hatanın yerini söylüyor. Alıntı kavram payı k on olana kadar 0,9500 ile 1,0000 arasında kalıyor: model neredeyse her zaman doğru kavramı anlatan bir parçayı alıntılıyor. Alıntı kayıt payı ise üretimle birlikte 0,4750’ye iniyor. Yani hata kavramda değil, kayıt türünde. Sınır aşıldığında ikisi birden çöküyor, çünkü artık hiç yanıt yok. Bu ayrımı okunur kılan şey alıntının kendisidir; yanıt yalnız metin olsaydı iki hata türü tek sayının içinde kalırdı.

Sıranın Payı

k süpürmesi iki şeyi birlikte değiştiriyor: bağlamda kaç parça olduğunu ve ilgili parçanın nerede durduğunu. Aşağıdaki blok ikincisini yalıtır. Her sorguda bağlama bir ilgili parça konur, yanına j ilgisiz parça eklenir ve aynı küme üç ayrı sırada verilir. Son sütun, sıra sabitken yalnız tohumun değiştiği koşumu taban olarak basar.

def deney(j, tohum=TOHUM):
    """Baglamda hep bir ilgili parca var; yanina j ilgisiz parca uc ayri yerlesimle konuyor."""
    sk, dg, ks = {"bas": 0, "orta": 0, "son": 0}, {"orta": 0, "son": 0}, 0
    for s in SORGU:
        aday = getir(s["metin"], 40)
        iyi = next(p for p in aday if ilgili(s, p))
        kotu = [p for p in aday if not ilgili(s, p)][:j]
        yer = {"bas": [iyi] + kotu, "son": kotu + [iyi],
               "orta": kotu[:j // 2] + [iyi] + kotu[j // 2:]}
        se = {}
        for a in ("bas", "orta", "son"):
            se[a] = yanitla(s["metin"], yer[a], tohum)["parca"]
            sk[a] += se[a] is not None and ilgili(s, se[a])
        for a in ("orta", "son"):
            dg[a] += se[a] is not se["bas"]
        ks += yanitla(s["metin"], yer["bas"], tohum + 1)["parca"] is not se["bas"]
    return [sk[a] / 40 for a in ("bas", "orta", "son")], dg["orta"] / 40, dg["son"] / 40, ks / 40


print("ilgisiz  uretim: basta  ortada  sonda | yanit degisme payi: orta   son   iki kosum")
for j in (0, 2, 4, 8):
    u, do, ds, ks = deney(j)
    print("%7d          %.4f  %.4f  %.4f                      %.4f %.4f %.4f"
          % (j, u[0], u[1], u[2], do, ds, ks))
print("ikinci kosum (tohum 20260219), j=4: basta %.4f ortada %.4f sonda %.4f"
      % tuple(deney(4, TOHUM + 1)[0]))

ilgisiz  uretim: basta  ortada  sonda | yanit degisme payi: orta   son   iki kosum
      0          1.0000  1.0000  1.0000                      0.0000 0.0000 0.0000
      2          0.9000  0.2000  0.7000                      0.7750 0.3250 0.2000
      4          0.7500  0.1000  0.5250                      0.9250 0.4750 0.3750
      8          0.7250  0.1500  0.4750                      0.8250 0.6500 0.4750
ikinci kosum (tohum 20260219), j=4: basta 0.8750 ortada 0.2250 sonda 0.5750

İlgisiz Parçanın Bedeli

İlk satır kontrolü kuruyor: bağlamda yalnız ilgili parça varsa üretim 1,0000’dır ve sıra hiçbir şey değiştirmez. Bundan sonraki her satırdaki düşüş, eklenen ilgisiz parçaların bedelidir.

İlgili parça başta iken sekiz ilgisiz parça üretimi 1,0000’den 0,7250‘ye indiriyor, yani parça başına ortalama 0,0344. Aynı parça ortada iken 1,0000’den 0,1500’e iniyor, parça başına 0,1063. Düşüşün bir eşiği yok: ilk iki ilgisiz parça bile başta 0,1000, ortada 0,8000 götürüyor. Bu, yz-destekli-gelistirme/02’de ölçülen bulgunun erişim bağlamındaki karşılığıdır ve buradaki ek bilgi şudur: bedelin büyüklüğü ilgili parçanın nerede durduğuna bağlıdır.

Dört ilgisiz parçalı satır sırayı tek başına okutuyor. Aynı beş parça, aynı tohum, yalnız sıra farklı: üretim başta 0,7500, sonda 0,5250, ortada 0,1000. Baş ile orta arasındaki fark 0,6500’dür. Bu farkın gerçek olup olmadığı son sütunla sınanır: sıra sabitken yalnız tohumun değiştiği koşumda yanıtların 0,3750‘si değişiyor, sıra değiştiğinde ise 0,9250‘si. İkinci koşumun aynı satırdaki sayıları da (0,8750 / 0,2250 / 0,5750) aynı sıralamayı veriyor; başta ile ortada arasındaki fark her iki koşumda da tam 0,6500’dür ve iki koşum farkı en çok 0,1250’dir.

Buradan çıkan kural şudur: bağlamın sırası bir tasarım kararıdır ve yazılmadan ölçüm tekrarlanamaz. Aynı erişim, aynı parçalar ve aynı model, parçaların dizilişi değiştiğinde üretimde 0,7500 ile 0,1000 arasında salınıyor. Yeniden sıralamanın erisim-hatti/06’da 1000 çağrıya satın aldığı kesinlik, parçalar bağlama kötü bir sırada konursa harcanır.

Özet

• İki yüz kırk belirteçlik pencereye yönerge ve sorgudan sonra 11,3 parça sığar; on birinci parçada kırk sorgunun on dördü, on üçüncüde hepsi sınırı aşar ve yanıtsız döner.
• Sınır ortalama bağlama değil en büyüğüne çarpar: ortalama 236,3 belirteçken bile on dört istek pencereyi aşar.
• Parça sayısı birden ona çıktığında erişim anması 0,7750’den 0,9750’e yükselirken üretim 0,7750’den 0,4750’ye düşer; iki ölçü zıt yönlere gider.
• Alıntı kavram payı 0,9500 ile 1,0000 arasında kalırken alıntı kayıt payı 0,4750’ye iner: hata kavramda değil kayıt türündedir ve bu ayrımı okunur kılan şey kaynağa bağlamadır.
• İlgili parça başta iken her ilgisiz parça üretimden ortalama 0,0344, ortada iken 0,1063 götürür ve düşüşün eşiği yoktur.
• Aynı beş parça farklı sırada verildiğinde üretim 0,7500 ile 0,1000 arasında oynar ve yanıtların 0,9250’si değişir; sıra sabitken tohum değiştiğinde değişen pay 0,3750’dir.

Sonraki Adım

Yedi derste hat baştan sona kuruldu: dağarcık hazırlandı, parçalandı, dizinlendi, yenilendi, sorgu dönüştürüldü, adaylar yeniden sıralandı ve bağlam kuruldu. Her ders kendi düzeneğini kendi sayısıyla savundu, ama bu sayıların hepsi aynı kusuru taşıyor: bir kurulumun iyi olması, doğru parçanın gelmesi ile doğru yanıtın üretilmesinin aynı sorguda olması demek değildir. Bu dersin tablosunda alıntı kavram payı 1,0000 iken üretimin 0,6500 olduğu bir satır var; orada model doğru kaynağı gösterip yanlış kaydı okudu. Sonraki ders bu dört durumu ayrı ayrı sayar ve tek bir sayının hangisini gizlediğini gösterir.