Gömme Modelleri

Önceki ders tek bir gömme kullandı ve o gömme hem dağarcığın dilini hem sorgunun dilini tanıyordu. Anahtar sözcük tabanına karşı erişim kesinliği 0,1200’den 0,4600’e, kavram isabeti 0,0500’den 0,5000’e çıktı. Bu, bir gömme modelinin sayısı değildi; sorgu dilini tanıyan bir gömme modelinin sayısıydı. Hazır bir modelle bu varsayım kendiliğinden doğru olmaz.

Bir gömme modeli seçilirken üç ayar konuşulur: boyut, alan uyumu ve dil desteği. Boyut kararının bedeli Model API’leri ile Uygulama Geliştirme kursunda ölçüldü: üç en yakın komşunun aynı konudan olma payı yüz kırk dört boyutta 0,9259 iken yetmiş iki boyutta 0,9028 oldu, saklanan sayı 10368’den yarısına indi. O yordam tekrarlanmaz; bu dersin eklediği aynı boyutta alan uyumunun payıdır. Dil desteği üçüncü bir ayar gibi görünür ama bu ölçüde aynı yüzeydir: soru her iki durumda da modelin sorgu dilini tanıyıp tanımadığıdır.

• GM11. Bütün kod benzeticidir; dağarcık, kavram ekseni ve gömme yordamı kurgudur. Tohum 20260218. Gerçek bir gömme uç noktası çağrılmaz.
• GM12. Alan uyumu benzeticide açıkça modellenir. Alan içi gömme kavramın iki yüzeyini de tanır: belge dilindeki basinc dususu ile sorgu dilindeki zayif akis aynı kavrama gider. Alan dışı gömme yalnız belge yüzeyini tanır; sorgu yüzeyini görmez ve elinde kalan tek sinyal belgelerle paylaşılan ortak sözcüklerdir. Bu, başka bir alanın metinleriyle kurulmuş bir gömmenin yapısal karşılığıdır.
• GM13. Boyut sabit tutulur: otuz iki. İki kurulum aynı sayıda koordinat saklar ve aynı sayıda çarpma yapar; aradaki fark yalnız alan uyumundandır.
• GM14. Aynı aileden ikinci bir gömme modeli kurulur; yalnız izdüşüm tohumu farklıdır (20260219). Bir kaybın ölçülmüş sayılması için iki model arasındaki farkı aşması gerekir. Bu, dersin koşumdan bağımsız tabanıdır.
• GM15. Taban çizgisi yine anahtar sözcük aramasıdır; ölçü tanımları önceki dersle aynıdır: getirilen parça beş, ilgili belge ana kavramı sorgunun hedef kavramıyla aynı olan belge.
• GM16. Boyut süpürmesi iki modelle birlikte okunur; iki model aynı sıralamayı vermiyorsa o aralıkta ölçülmüş bir sıra yoktur.
• GM17. Saklama maliyeti belge sayısı çarpı boyut, yani saklanan sayı adedidir.

Alan Uyumu Neyin Modellenmesidir

İlk blok dağarcığı, kavram eksenini ve gömme benzeticisini kurar; sonunda tek bir sorgu üzerinde alan uyumunu gösterir. Alan içi gömme sorgu yüzeyini gördüğünde kavramın ağırlığını tam yazar; alan dışı gömme o kavramı göremez ve geriye ortak sözcüklerin dağıttığı ince bir ağırlık kalır.

# BENZETICI -- KURGUDUR. Gercek bir gomme uc noktasi cagrilmaz. Dagarcik,
# kavram ekseni, gomme yordami ve sorgu kumesi KURGUDUR; hicbir gercek
# kurum, urun ya da belge degildir.
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"]})

print(f"dagarcik: {len(BELGE)} belge , {len(ANAHTAR)} kavram , {len(SINIF)} sinif ,"
      f" {len(SORGU)} sorgu , gomme boyutu {BOYUT}")
q = SORGU[3]
k = q["kavram"]
print(f"sorgu : {q['metin']}  -> kavram {k} , sinif {q['sinif']}")
print(f"  {k} belge dilinde '{KAVRAM[k][1]}' , sorgu dilinde '{KAVRAM[k][2]}'")
print(f"  alan ici gomme kavram vektorunde {k} agirligi :"
      f" {_kavramla(q['metin'])[ANAHTAR.index(k)]:.2f}")
print(f"  alan disi gomme kavram vektorunde {k} agirligi :"
      f" {_kavramla(q['metin'], alan=False)[ANAHTAR.index(k)]:.2f}")

dagarcik: 200 belge , 20 kavram , 5 sinif , 40 sorgu , gomme boyutu 32
sorgu : zayif akis bolge  -> kavram basinc , sinif ariza
  basinc belge dilinde 'basinc dususu' , sorgu dilinde 'zayif akis'
  alan ici gomme kavram vektorunde basinc agirligi : 1.00
  alan disi gomme kavram vektorunde basinc agirligi : 0.05

Son iki satır ölçünün tamamını taşıyor. basinc kavramı için ağırlık alan içi gömmede 1,00, alan dışı gömmede 0,05. İkincisi bir kavram sinyali değil, ortak sözcüklerin bütün kavramlara eşit dağıttığı taban gürültüsüdür: alan dışı gömme sorguyu yirmi kavrama eşit uzaklıkta bir noktaya koyuyor.

Aynı Boyutta İki Gömme

Aşağıdaki blok beş kurulumu aynı kırk sorguda koşturur: anahtar sözcük tabanı, alan içi gömmenin iki modeli ve alan dışı gömmenin iki modeli. Hepsi otuz iki boyutta çalışır ve aynı sayıda koordinat saklar. Son sütun kırk sorgunun kaç farklı ilk-beş kümesi ürettiğini sayar; bir sıralayıcının sorgudan sorguya değişip değişmediği oradan okunur. Son iki satır aynı alanda kalan iki model arasındaki farkı ve alan dışına düşmenin kaybını ayrı yazar.

K = 5
ILGILI = {k: sum(1 for d in BELGE if d["ana"] == k) for k in ANAHTAR}
BELIRTEC = [set(belirtecle(metin(d))) for d in BELGE]

# Ayni aileden IKINCI gomme modeli: yalnizca izdusum tohumu farkli (20260219).
IZDUS2 = []
for i in range(len(ANAHTAR)):
    r = uretec((TOHUM + 1) ^ (i + 1) * 2654435761)
    IZDUS2.append([r() * 2 - 1 for _ in range(64)])


def gom2(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 * IZDUS2[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 olc(sirala):
    """Dort sayi ve kirk sorgunun urettigi FARKLI ilk-bes kumesi adedi."""
    kesinlik = anma = kavram = sinif = 0.0
    kume = set()
    for q in SORGU:
        ust = sirala(q)[:K]
        kume.add(tuple(sorted(ust)))
        t = sum(BELGE[i]["ana"] == q["kavram"] for i in ust)
        kesinlik += t / K
        anma += t / ILGILI[q["kavram"]]
        kavram += BELGE[ust[0]]["ana"] == q["kavram"]
        sinif += BELGE[ust[0]]["sinif"] == q["sinif"]
    n = len(SORGU)
    return kesinlik / n, anma / n, kavram / n, sinif / n, len(kume)


def anahtar_sirala(q):
    qb = set(belirtecle(q["metin"]))
    return sorted(range(len(BELGE)), key=lambda i: (-len(qb & BELIRTEC[i]), i))


def gomme_sirala(gomucu, alan, boyut=BOYUT):
    vek = [gomucu(metin(d), boyut, alan) for d in BELGE]

    def sirala(q):
        qv = gomucu(q["metin"], boyut, alan)
        return sorted(range(len(BELGE)), key=lambda i: (-aci(qv, vek[i]), i))
    return sirala


print("kurulum                kesinlik    anma  kavram   sinif  kume")
sonuc = {}
for ad, sirala in (("anahtar sozcuk", anahtar_sirala),
                   ("alan ici  , model 1", gomme_sirala(gom, True)),
                   ("alan ici  , model 2", gomme_sirala(gom2, True)),
                   ("alan disi , model 1", gomme_sirala(gom, False)),
                   ("alan disi , model 2", gomme_sirala(gom2, False))):
    sonuc[ad] = olc(sirala)
    print(f"{ad:<21} " + " ".join(f"{x:7.4f}" for x in sonuc[ad][:4])
          + f" {sonuc[ad][4]:5d}")

ic1, ic2 = sonuc["alan ici  , model 1"], sonuc["alan ici  , model 2"]
di1 = sonuc["alan disi , model 1"]
print("\niki model arasindaki fark (alan ici) :",
      " ".join(f"{abs(a - b):7.4f}" for a, b in zip(ic1[:4], ic2[:4])))
print("alan disina dusmenin kaybi (model 1) :",
      " ".join(f"{a - b:7.4f}" for a, b in zip(ic1[:4], di1[:4])))
print(f"saklanan sayi her kurulumda ayni : {len(BELGE) * BOYUT}")

kurulum                kesinlik    anma  kavram   sinif  kume
anahtar sozcuk         0.1200  0.0616  0.0500  0.2500    20
alan ici  , model 1    0.4600  0.2223  0.5000  1.0000    17
alan ici  , model 2    0.4050  0.2035  0.5250  1.0000    17
alan disi , model 1    0.0650  0.0316  0.0500  0.2500     1
alan disi , model 2    0.0450  0.0247  0.0250  0.2500     1

iki model arasindaki fark (alan ici) :  0.0550  0.0188  0.0250  0.0000
alan disina dusmenin kaybi (model 1) :  0.3950  0.1907  0.4500  0.7500
saklanan sayi her kurulumda ayni : 6400

Tablonun en dikkat çeken satırı alan dışı gömmenin kavram ve sınıf sütunlarıdır: 0,0500 ve 0,2500. Bu iki sayı anahtar sözcük tabanınınkilerle birebir aynı. Alan dışı gömme vektör üretiyor, açı benzerliği hesaplıyor, sıralama yapıyor ve ilk sonuçta sözcük eşleşmesinden fazlasını elde etmiyor. Boyut, saklama ve karşılaştırma aynı; düzeneğin tamamı silinmiş durumda.

Getirilen kümeye bakıldığında durum daha ağırdır. Alan dışı gömmenin erişim kesinliği 0,0650, anması 0,0316; anahtar sözcük tabanı ise 0,1200 ve 0,0616. Yani beş belgelik küme, hiç gömme kullanılmadığı duruma göre daha kötü. Eklenen düzenek sayıyı yükseltmedi, düşürdü. Nedeni son sütunda yazılı: alan dışı kurulum kırk sorguda tek bir ilk-beş kümesi üretiyor. Bütün sorgular aynı noktaya düştüğü için hepsine aynı beş belge gidiyor. Anahtar sözcük tabanı yirmi ayrı küme, alan içi gömme on yedi ayrı küme üretiyor.

Kaybın ölçülmüş sayılıp sayılmayacağına son iki satır karar veriyor. İki model arasındaki fark kesinlikte 0,0550, anmada 0,0188, kavram isabetinde 0,0250, sınıf isabetinde 0,0000. Alan dışına düşmenin kaybı ise 0,3950, 0,1907, 0,4500 ve 0,7500; kavram isabetinde model farkının on sekiz katı. Model API’leri kursunda boyutu yarıya indirmenin kaybı model farkıyla aynı büyüklükte çıkmış ve ölçülmemiş sayılmıştı. Buradaki kayıp o eşiğin çok üstündedir: alan uyumu, boyutla aynı kefeye konacak bir ayar değildir.

Bir gömme modelinin dil listesi bu ölçünün yerine geçmez. Listede bir dilin bulunması modelin o dildeki belge metinlerini gördüğü anlamına gelir, kullanıcının aynı kavramı hangi sözcüklerle sorduğunu gördüğü anlamına gelmez.

Boyutun Nerede Öldüğü

Alan uyumu sabitlenip boyut süpürülürse ne olur. Aşağıdaki blok alan içi kurulumu beş boyutta iki modelle koşturur.

print("boyut  saklanan  model 1 kavram / sinif  model 2 kavram / sinif")
for d in (64, 32, 16, 8, 4):
    a = olc(gomme_sirala(gom, True, d))
    b = olc(gomme_sirala(gom2, True, d))
    print(f"{d:>5} {len(BELGE) * d:>9} {a[2]:>16.4f} {a[3]:>7.4f}"
          f" {b[2]:>15.4f} {b[3]:>7.4f}")

boyut  saklanan  model 1 kavram / sinif  model 2 kavram / sinif
   64     12800           0.4250  1.0000          0.4500  1.0000
   32      6400           0.5000  1.0000          0.5250  1.0000
   16      3200           0.4500  1.0000          0.4000  0.9500
    8      1600           0.6000  0.9500          0.4750  0.8250
    4       800           0.2750  0.5500          0.3000  0.6500

Kavram sütunları 64 ile 8 arasında monoton değil. Birinci model 0,4250, 0,5000, 0,4500, 0,6000 veriyor ve en yükseği en küçük boyutta alıyor; ikinci model 0,4500, 0,5250, 0,4000, 0,4750 veriyor ve en yükseği otuz ikide alıyor. İki model hangi boyutun daha iyi olduğunda anlaşmıyor ve sekiz boyuttaki fark 0,1250, yani otuz ikideki model farkının beş katı. Bu aralıkta boyut sıralaması ölçülmemiştir; tek modelin süpürmesine bakarak sekize inmek bir çekilişe dayanmak olur.

Sınıf sütunu daha kararlıdır ve asıl bilgiyi o taşıyor. Birinci modelde sekiz boyuta kadar 0,9500 altına inmiyor; ikinci modelde on altıda 0,9500’e, sekizde 0,8250’ye iniyor. Dört boyutta ikisi birlikte çöküyor: 0,5500 ve 0,6500. Uçurum sekiz ile dört boyut arasındadır ve nedeni sayılabilir: yirmi kavram dört koordinata sıkıştırıldığında iki kavramın aynı yöne düşmesi kaçınılmazdır.

Saklama tarafı okumayı tamamlıyor. Altmış dört boyuttan sekize inmek saklanan sayıyı 12800’den 1600’e indiriyor ve sınıf isabetinde ölçülmüş bir kayıp bırakmıyor; dörde inmek saklamayı yalnız yarı yarıya daha azaltıp sınıf isabetini yarıya düşürüyor. Boyut kararının biçimi Model API’leri kursunda görülenle aynı yöndedir: uzun bir aralıkta bedelsiz, sonra bir anda pahalı.

Özet

• Alan uyumu, bir gömme modelinin sorgu dilindeki yüzeyi belge dilindeki yüzeyle aynı kavrama bağlayıp bağlamamasıdır; dil desteği aynı sorunun başka adıdır.
• Aynı otuz iki boyutta ve aynı 6400 saklanan sayıda alan içi gömme 0,4600 kesinlik ve 0,5000 kavram isabeti, alan dışı gömme 0,0650 ve 0,0500 veriyor.
• Alan dışı gömmenin kavram ve sınıf isabeti anahtar sözcük tabanıyla birebir aynıdır; getirilen kümede tabanın altına düşer, çünkü kırk sorguya tek bir ilk-beş kümesi verir.
• İki model arasındaki fark kavram isabetinde 0,0250, alan dışına düşmenin kaybı 0,4500; ilki ölçülmemiş, ikincisi ölçülmüş bir farktır.
• Boyut süpürmesinde iki model 64 ile 8 arasında anlaşmıyor; o aralıkta ölçülmüş bir sıra yoktur.
• Uçurum 8 ile 4 boyut arasındadır ve eşik kavram sayısından gelir: yirmi kavram dörde sığmaz.

Sonraki Adım

Bu iki derste benzerlik tek bir yordamla hesaplandı: karşılıklı koordinatlar çarpılıp toplandı ve vektörler bundan önce birim uzunluğa getirildi. İkinci adım sessiz bir karardır. Normalleştirme yapılmazsa aynı çarpım başka bir sıralama üretir ve uzun belgeler daha yüksek puan almaya başlar. Sonraki ders açı benzerliği ile iç çarpımı aynı kırk sorguda yan yana koyar: ilk üç sonuç kaç sorguda ayrışıyor, hangi ölçüt uzunluğa yanlı ve bu yanlılık getirilen parçanın doğruluğunu ne yönde oynatıyor.