Parçalama Stratejileri

Önceki ders hazırlığı sınıra kadar götürdü ve orada durdu: devam satırları birleştirildi, başlık ile altlık atıldı, kod ve sınıf alanı ayrıldı, ama paragrafın nerede biteceği kaynağın kararı olarak bırakıldı. Erişim hattında o sınır kaynağın değil, hattı kuranın kararıdır. Bir parça hem dizinlenen birim, hem de modele verilen metin parçasıdır; boyutu iki ucu birden belirler.

Bu dersin ölçtüğü şey sınırın bedelidir. Parça küçüldükçe saklanan vektör sayısı artar ve metnin içindeki ilişkiler kesilir; büyüdükçe bağlam penceresi dolar. Örtüşme kesilen ilişkiyi geri alır ve aldığını belirteçle öder. Bu üçünün nerede kesiştiği ölçülebilir bir sayıdır.

• EH14. Kod bir benzeticidir; dağarcık, gömme ve sorgular kurgudur, tohum 20260218. Gömme ile dil modeli önceki derslerin tanımlarıdır.
• EH15. Parça sınırları sözcük üzerinde çizilir, parça boyutu belirteç cinsinden verilir: pencere, belirteç bütçesi dolana kadar sözcük ekleyerek büyür. Belirteç ortasından bölme yapılmaz, çünkü bölünmüş bir belirteç aramada hiçbir yüzeyle eşleşmez.
• EH16. Örtüşme de belirteç cinsindendir: bir sonraki pencere, öncekinin son örtüşme kadar belirtecini yeniden alarak başlar.
• EH17. İlişki geçişi, bir paragrafın iki kavram yüzeyini birlikte taşıyan aralıktır ve kaynağın asıl bilgi birimidir: hangi kaydın hangi yordamla birlikte tutulduğu. Dağarcıkta 693 ilişki geçişi vardır.
• EH18. İlişki anması, bu geçişlerin tek bir parçanın içinde bütün kalma payıdır. Sorgu kümesinden ve koşumdan bağımsızdır; parçalama kararının kaynağa ne yaptığını sorgu koşturmadan söyler.
• EH19. Erişim anması, üretim isabeti ve bağlam aşımı payı önceki derslerin tanımlarıdır; ilk üç parça getirilir ve eşik 0,0750’dir.
• EH20. Saklanan belirteç, bütün parçaların belirteç toplamıdır. Örtüşmeyen bölmede bu sayı kaynağın kendi büyüklüğüne eşittir (11281); örtüşme onu kaçla çarptığı yazılır.

Sınırı Ele Almak

İlk blok dağarcığı kurar, üstüne belirteç bütçeli bir parçalayıcı koyar ve ilişki geçişlerini işaretler. Ardından dil modeli benzeticisi gelir ve ölçüm işlevi kurulur.

# KURGUDUR. Dagarcik, kavram ekseni, gomme ve dil modeli benzeticidir; gercek bir uc
# nokta cagrilmaz. Tohum 20260218.
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})


# ---- 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
    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"]})

# ---- parcalama: parca sinirlari sozcukte, boyut belirtecte olculur
GOVDE = [" ".join(d["par"]).split() for d in BELGE]
ILISKI = [(i, 11 * t, 11 * t + 8)              # paragrafin iki yuzeyini birlikte tasiyan aralik
          for i, d in enumerate(BELGE) for t in range(len(d["par"]))]


def pencereler(w, boy, ort):
    kt = [len(belirtecle(x)) for x in w]
    pen, i = [], 0
    while True:
        j, t = i, 0
        while j < len(w) and t + kt[j] <= boy:
            t += kt[j]
            j += 1
        j = max(j, i + 1)
        pen.append((i, j))
        if j >= len(w):
            return pen
        yeni, g = j, 0
        while yeni > i + 1 and g + kt[yeni - 1] <= ort:      # ortusme kadar geri sarilir
            yeni -= 1
            g += kt[yeni]
        i = yeni


def parcala(boy, ort, yapi=False):
    p, pen = [], {}
    for i, d in enumerate(BELGE):
        w = GOVDE[i]
        pen[i] = ([(11 * t, 11 * t + 11) for t in range(len(d["par"]))] if yapi
                  else pencereler(w, boy, ort))
        for a, b in pen[i]:
            m = " ".join(w[a:b])
            p.append({"kod": d["kod"], "sinif": d["sinif"], "metin": m,
                      "kavram": [k for k in ANAHTAR if KAVRAM[k][1] in m]})
    kalan = sum(any(a <= s and e <= b for a, b in pen[i]) for i, s, e in ILISKI)
    return p, kalan / len(ILISKI)


import math
# ---- KURGU dil modeli benzeticisi: onceki derslerin benzeticisi
PENCERE = 240
ON_BILGI = {"sizinti", "basinc", "sure", "degisim", "vana", "duyuru", "gecis"}
SAYAC = [0]


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


def cagir(istem, tohum=TOHUM, sicaklik=0.6):
    SAYAC[0] += 1
    b = belirtecle(istem)
    if len(b) > PENCERE:
        return {"durum": "baglam_asimi", "giris": len(b), "cikis": 0, "yanit": ""}
    if SAYAC[0] % 37 == 0:
        return {"durum": "hiz_siniri", "giris": len(b), "cikis": 0, "yanit": ""}
    r = uretec(tohum ^ izno(istem))
    dm = " " + istem.lower() + " "
    p = {k: 0.15 for k in ANAHTAR}
    for k in ANAHTAR:
        p[k] += 2.0 * dm.count(KAVRAM[k][1])
        if k in ON_BILGI and KAVRAM[k][2] in dm:
            p[k] += 2.0
    w = [math.exp(p[a] / sicaklik) for a in sorted(p)]
    y = sorted(p)[ayrik(r(), [x / sum(w) for x in w])]
    return {"durum": "tamam", "giris": len(b), "cikis": len(belirtecle(y)), "yanit": y}


YONERGE = ("Talebi su kavramlardan birine bagla: " + " , ".join(ANAHTAR) +
           " . Yanit olarak tek kavram yaz . ")


def olc(p, k=3):
    SAYAC[0] = 0
    v = [gom(x["metin"]) for x in p]
    a = [0] * 4
    for s in SORGU:
        q = gom(s["metin"])
        ug = sorted(range(len(p)), key=lambda i: -aci(q, v[i]))[:k]
        a[0] += any(s["kavram"] in p[i]["kavram"] for i in ug)
        y = cagir(YONERGE + "Kaynak: " + " . ".join(p[i]["metin"] for i in ug) +
                  " . Talep: " + s["metin"])
        a[1] += y["yanit"] == s["kavram"]
        a[2] += y["giris"] + y["cikis"]
        a[3] += y["durum"] == "baglam_asimi"
    return (sum(len(belirtecle(x["metin"])) for x in p), a[0] / 40, a[1] / 40, a[2],
            a[3] / 40)


print("boyut  parca saklanan  iliski    anma  uretim  istek belirteci  asim")
for boy in (8, 12, 20, 32, 48, 80):
    p, il = parcala(boy, 0)
    m = olc(p)
    print("%5d %6d %8d  %.4f  %.4f  %.4f %11d %8.2f"
          % (boy, len(p), m[0], il, m[1], m[2], m[3], m[4]))

boyut  parca saklanan  iliski    anma  uretim  istek belirteci  asim
    8   1538    11281  0.0000  0.9500  0.9250        4294     0.00
   12   1044    11281  0.3175  0.9500  0.9250        4733     0.00
   20    667    11281  0.4416  0.9500  0.9250        5360     0.00
   32    455    11281  0.8557  1.0000  0.9250        5999     0.00
   48    328    11281  0.9394  1.0000  0.8750        6839     0.00
   80    227    11281  0.9784  1.0000  0.4750        8484     0.25

Boyut süpürmesi iki ayrı bozulmayı iki ayrı uçta gösteriyor. Sekiz belirteçlik parçalar kaynağın 693 ilişki geçişinin hiçbirini bütün tutamıyor (0,0000), çünkü bir ilişki ortalama on iki belirteç yer kaplıyor ve pencereye sığmıyor. Bu parçalar kavram yüzeylerini korudukları için erişim anmasını düşürmüyor: 0,9500. Kesilen şey kavram değil, kavramlar arasındaki bağdır.

Öbür uç görünür biçimde bozuluyor. Seksen belirteçlik parçalar ilişkilerin 0,9784‘ünü tutuyor ve erişim anması 1,0000‘a çıkıyor, ama üç parça isteme konduğunda kırk isteğin 0,25‘i bağlam penceresini aşıyor. Üretim **0,9250’den 0,4750’ye** iniyor. Fark 0,4500, yani eşiğin altı katı: ölçülmüş bir bozulmadır. Erişim sütununun en iyi olduğu satır, üretim sütununun en kötüsüdür. Kırk sekiz belirteçte üretim 0,8750’dir ve tabandan farkı 0,0500, yani eşiğin altında: bu satırın isabeti düşürüp düşürmediği bu ölçümle bilinemez.

Kullanılabilir bant ortadadır: yirmi ile otuz iki belirteç arasında bağlam aşımı yok, erişim anması en yüksek düzeyde, ve ilişki anması 0,4416 ile 0,8557 arasında. Bu bandı yukarı çekmenin yolu boyutu büyütmek değildir; örtüşmedir.

Örtüşmenin Fiyatı

İkinci blok yirmi belirteçlik parçada örtüşmeyi sıfırdan on ikiye süpürür ve her adımda kaç ilişki kazanıldığını, karşılığında kaç belirteç saklandığını yazar. Son satır örtüşme yerine kaynağın kendi paragraf sınırını kullanır.

print("ortusme  parca saklanan   kat  iliski  kazanc  ek belirtec  iliski basi   anma  uretim")
onc = None
for ort in (0, 2, 4, 6, 8, 10, 12):
    p, il = parcala(20, ort)
    m = olc(p)
    e = ""
    if onc:
        k = round((il - onc[0]) * len(ILISKI))
        e = "%7d %12d %11d" % (k, m[0] - onc[1], (m[0] - onc[1]) // k)
    print("%7d %6d %8d %5.2f  %.4f%s %7.4f %7.4f"
          % (ort, len(p), m[0], m[0] / 11281, il, e or " " * 31, m[1], m[2]))
    onc = (il, m[0])
p, il = parcala(0, 0, yapi=True)
m = olc(p)
print("yapiya duyarli sinir: parca %d, saklanan %d, iliski %.4f, anma %.4f, uretim %.4f"
      % (len(p), m[0], il, m[1], m[2]))

ortusme  parca saklanan   kat  iliski  kazanc  ek belirtec  iliski basi   anma  uretim
      0    667    11281  1.00  0.4416                                 0.9500  0.9250
      2    683    12135  1.08  0.5729     91          854           9  0.9500  0.9250
      4    746    13265  1.18  0.8052    161         1130           7  1.0000  0.9250
      6    814    14743  1.31  0.9322     88         1478          16  0.9500  0.9250
      8    900    16682  1.48  0.9452      9         1939         215  0.9500  0.9250
     10   1029    19385  1.72  0.9899     31         2703          87  0.9500  0.9250
     12   1213    23145  2.05  1.0000      7         3760         537  0.9500  0.9250
yapiya duyarli sinir: parca 693, saklanan 11281, iliski 1.0000, anma 0.9500, uretim 0.9250

İlişki anması örtüşmeyle birlikte 0,4416’dan 1,0000’a düzenli biçimde yükseliyor. Bedel aynı düzenle yükselmiyor, katlanıyor: saklanan belirteç 11281’den 23145’e (2,05 kat), saklanan parça 667’den 1213’e. Her parça bir vektör tuttuğu için saklanan sayı adedi de aynı oranda büyüyor.

Kesişme noktası son sütunda okunur. İlk üç adım ucuzdur: kazanılan her ilişki için sırasıyla 9, 7 ve 16 belirteç saklanıyor. Dördüncü adımda, yani örtüşme altıdan sekize çıkarken, ilişki başına maliyet 215 belirtece sıçrıyor. Ondan sonrası da toparlanmıyor: 87 ve 537. Kaynağın ilişki uzunluğu ortalama on iki belirteç olduğu için örtüşme altıya kadar kesilen ilişkilerin büyük bölümünü kurtarıyor; kalanlar pencere sınırına en talihsiz biçimde denk gelen az sayıda geçiştir ve onları kurtarmak bütün dağarcığın yeniden saklanmasını gerektiriyor. Örtüşme altı belirteçtir; bu iş yükünde ondan sonrası ilişki değil, kopya satın alır.

Erişim anması ve üretim sütunlarına bakıldığında süpürmenin tamamı düzdür: anma bir satır dışında 0,9500, üretim yedi satırda da 0,9250. Örtüşmenin bu sorgu kümesinde isabete kattığı ölçülmemiştir; saklanan belirtece kattığı ölçülmüştür. Bedeli yazılmayan düzenek ölçülmemiş sayılır, ve bu satırlarda ölçülen tek şey bedeldir.

Son satır tartışmayı bitiriyor. Kaynağın kendi paragraf sınırına uyan bölme, ilişki anmasını 1,0000 yapıyor: örtüşme on ikinin ulaştığı yer. Karşılığında 693 parça ve 11281 belirteç saklıyor, yani örtüşmeli kurulumun yarısı kadar. Örtüşme, kaynağın yapısı bilinmediğinde ödenen sigortadır; yapı biliniyorsa fiyatı boşunadır.

Özet

• Parça sınırı kaynağın değil hattı kuranın kararıdır; boyut hem saklanan vektör sayısını hem de isteme giren metni belirler.
• İlişki anması, kaynağın bilgi birimlerinin kaç parçada bütün kaldığını sorgu koşturmadan ölçer ve parçalama kararının asıl ölçütüdür.
• Küçük parça ilişkiyi keser ama kavram yüzeyini korur: sekiz belirteçte ilişki anması 0,0000 iken erişim anması 0,9500’dür.
• Büyük parça ilişkiyi korur ama pencereyi doldurur: seksen belirteçte isteklerin 0,25’i bağlam aşımına uğrar ve üretim 0,9250’den 0,4750’ye iner.
• Örtüşme ilişki anmasını 0,4416’dan 1,0000’a çıkarır, saklanan belirteci 2,05 katına götürür ve ilişki başına maliyet altıdan sonra 16’dan 215’e sıçrar: kesişme noktası örtüşme altıdır.
• Yapıya duyarlı bölme aynı 1,0000 ilişki anmasını örtüşmenin yarısı kadar yerle verir.

Sonraki Adım

Üç derste dağarcık durağan kabul edildi. Belgeler bir kez hazırlandı, bir kez parçalandı, bir kez gömüldü ve dizin bir daha ele alınmadı. Saha kayıtları böyle davranmaz: bir yordam güncellenir, bir eşik değişir, bir kayıt yürürlükten kalkar. Dizin o anda değil, bir sonraki yenilemede haberdar olur ve arada geçen sürede modele doğru parçayı getirmeye devam eder, ama parçanın içindeki bilgi artık geçerli değildir. Sonraki ders yenileme aralığını süpürür: aralık uzadıkça bayat parça payının, yanlış yanıt payının ve yenilemede yeniden gömülen parça sayısının nasıl değiştiğini ölçer, ve erişim sütununun bu bozulmanın hiçbirini göstermediğini gösterir.