Gömme Nedir

Model API’leri ile Uygulama Geliştirme kursu yirmi altı derste çağrıyı bir ağ işlemi olarak ele aldı: belirteç bütçesi, akış, biçim doğrulama, önbellek, yedek model ve her düzeneğin bedeli yazıldı. Kapanışta duran soru şuydu — modele verilen bilgi hep istemin içine elle konuldu. Bin belgelik bir dağarcıktan hangi üçünün o isteme gireceği, o seçimin hangi tabana karşı ölçüleceği ve yanlış seçimin bedeli hiç sorulmadı.

Bu ders o seçimin ilk aracını kurar. Soru şudur: bir sorgunun dağarcıktaki hangi belgeye benzediğine karar verirken neye bakılır. En doğrudan yanıt sözcüklerdir. Gömme ikinci yanıttır: metin, komşuluğu anlamı yansıtan bir vektöre çevrilir ve benzerlik vektörler arasında hesaplanır. Gömmenin tanımı, açı benzerliği ve sözcük komşuluğu Doğal Dil İşleme ve Bilgisayarla Görme kursunda kuruldu; burada tekrarlanmaz. Bu derste gömme bir arama anahtarıdır ve ölçüsü tektir: getirilen belgenin doğruluğu.

• GM1. Bütün kod bir benzeticidir. Dağarcık, kavram ekseni, gömme yordamı ve sorgu kümesi kurgudur; hiçbir gerçek kurum, ürün ya da belge değildir. Tohum 20260218.
• GM2. Benzeticinin modellediği şey şudur: her kavramın iki yüzeyi vardır. Belgelerde geçen biçim (kademe esigi) ile sorguda geçen biçim (hangi dilimdeyim) hiçbir belirteç paylaşmaz. Anahtar sözcük araması yalnız yüzeyi görür; gömme önce yüzeyi kavrama çevirir.
• GM3. Gömme yordamı iki adımlıdır: yirmi kavramlık bir vektör kurulur, sonra bu vektör BOYUT boyuta izdüşürülür. İzdüşüm bir sıkıştırmadır; bu derste boyut sabit tutulur ve otuz ikidir.
• GM4. Gömme belirlenmiştir: aynı metin her çağrıda aynı vektörü verir. Bu dersin koşumdan bağımsız ölçüsü budur ve blokta gösterilir.
• GM5. Bu dersin tabanı anahtar sözcük aramasıdır: sorgunun ayrık belirteçlerinden kaçının belgede geçtiği sayılır, eşitlik durumunda belge sırası karar verir.
• GM6. Bir sorgu için ilgili belge, ana kavramı sorgunun hedef kavramıyla aynı olan belgedir. Getirilen parça sayısı beştir.
• GM7. Erişim kesinliği getirilen beş belgeden ilgili olanların payı, erişim anması ilgili belgelerin bu beşe giren payıdır. Kesinlik ile anma çifti Arama Motorları kursunda ölçüldü; yordamı tekrarlanmaz.
• GM8. Sınıf isabeti kolay ölçüttür, kavram isabeti zor olandır. İkisi iki ayrı sütun olarak basılır.
• GM9. Dağarcık bu konuda belge düzeyinde kullanılır; parçalama erişim hattına bırakılır.
• GM10. Erişimin bedeli getirilen parça, karşılaştırma sayısı, gömme çağrısı ve saklanan sayı adedi olarak yazılır; ham süre yazılmaz.

Kurgu Dağarcık ve Kavram Ekseni

Aşağıdaki blok dağarcığı, kavram eksenini, gömme benzeticisini ve sorgu kümesini kurar. Dağarcık iki yüz belgedir; her belge bir başlık ve iki ile beş arası paragraf taşır, beş sınıfa ve yirmi kavrama dağılır. Kavramlar bir ölçüm ağının saha ekibi için tutulan kurgu yordamlardır: tarife kademesi, arıza kodu, sayaç endeksi, kesinti süresi, vana kontrolü.

Eksen tek bir tasarım kararı üzerine kuruludur. Saha ekibinin yazdığı yordam kademe esigi der; aboneden gelen soru hangi dilimdeyim der. İkisi aynı kavramı gösterir ve tek bir belirteç bile paylaşmaz. Gerçek bir dağarcıkta bu ayrım kısmidir; benzetici onu uç noktaya taşır ki iki aramanın farkı bir gürültü payının içinde kaybolmasın.

# 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 , {sum(len(d['par']) for d in BELGE)} paragraf ,"
      f" {len(ANAHTAR)} kavram , {len(SINIF)} sinif")
print("sinif dagilimi:", " , ".join(
    f"{s} {sum(1 for d in BELGE if d['sinif'] == s)}" for s in SINIF))
ortak = sum(len(set(belirtecle(KAVRAM[k][1])) & set(belirtecle(KAVRAM[k][2])))
            for k in ANAHTAR)
print(f"belge dili ile sorgu dili arasinda ortak belirtec , 20 kavram : {ortak}")
d = BELGE[0]
print(f"\n{d['kod']} ({d['sinif']}) baslik : {d['baslik']}")
print(f"  paragraf 1  : {d['par'][1]}")
q = SORGU[0]
print(f"sorgu       : {q['metin']}  -> kavram {q['kavram']} , sinif {q['sinif']}")
print(f"  {q['kavram']} belge dilinde '{KAVRAM[q['kavram']][1]}' ,"
      f" sorgu dilinde '{KAVRAM[q['kavram']][2]}'")
u, v = gom(q["metin"]), gom(q["metin"])
print(f"\ngomme {len(u)} boyut , ikinci cagri ayni vektor : {u == v}")
print("ilk alti koordinat :", " ".join(f"{x:+.3f}" for x in u[:6]))

dagarcik: 200 belge , 693 paragraf , 20 kavram , 5 sinif
sinif dagilimi: tarife 52 , ariza 46 , sayac 39 , kesinti 32 , bakim 31
belge dili ile sorgu dili arasinda ortak belirtec , 20 kavram : 0

BK001 (bakim) baslik : filtre degisimi yordami
  paragraf 1  : kalibrasyon kaydi icin kayit tutulur ve filtre degisimi ile birlikte yazilir
sorgu       : nasil kaydediliyor form  -> kavram okuma , sinif sayac
  okuma belge dilinde 'okuma yordami' , sorgu dilinde 'nasil kaydediliyor'

gomme 32 boyut , ikinci cagri ayni vektor : True
ilk alti koordinat : -0.018 -0.155 -0.145 -0.101 +0.243 +0.028

Çıktının ilk üç satırı dağarcığın ölçüsünü veriyor: iki yüz belge, altı yüz doksan üç paragraf, yirmi kavram, beş sınıf. Sınıflar elli iki ile otuz bir arasında dağılmış, yani hiçbir sınıf tek başına çoğunluk değil. Üçüncü satır dersin mekanizmasıdır: yirmi kavramın tamamında belge dili ile sorgu dili arasındaki ortak belirteç sayısı sıfır.

Örnek satırlar bunu somutlaştırıyor. BK001 bakım sınıfından bir belge, paragrafları belge dilinde yazılmış; ilk sorgu nasil kaydediliyor form ve hedef kavramı okuma. Okuma kavramı belgelerde okuma yordami diye geçiyor, sorguda nasil kaydediliyor diye. Sorgu ile belge arasında sözcük köprüsü yok; köprü ancak kavram üzerinden kurulabilir. Kalan iki satır koşum sorusunu kapatıyor: aynı metnin iki çağrısı aynı vektörü veriyor. Metin üreten bir çağrıda aynı istem iki koşumda iki ayrı yanıt verebiliyordu; gömme yüzeyinde veremez.

İki Aramanın Aynı Sorgu Kümesindeki Sayısı

Kırk sorgunun her biri iki kurulumda koşturulur. Birincisi anahtar sözcük aramasıdır: sorgunun ayrık belirteçlerinden kaçının belgede geçtiği sayılır, en yüksek puanlı beş belge getirilir, eşitlikte belge sırası karar verir. İkincisi gömme aramasıdır: sorgu ve belgeler aynı benzeticiyle gömülür, açı benzerliği en yüksek beş belge getirilir. Her kurulum dört sayı üretir; kesinlik ile anma getirilen kümenin bütünü üzerinde, kavram ile sınıf isabeti yalnız ilk sonuç üzerinde okunur.

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


def ilk_k(puan):
    return sorted(range(len(BELGE)), key=lambda i: (-puan[i], i))[:K]


def anahtar_ara(q):
    qb = set(belirtecle(q["metin"]))
    return ilk_k([len(qb & BELIRTEC[i]) for i in range(len(BELGE))])


def gomme_ara(q):
    qv = gom(q["metin"])
    return ilk_k([aci(qv, VEKTOR[i]) for i in range(len(BELGE))])


def olc(getir):
    kesinlik = anma = kavram = sinif = 0.0
    for q in SORGU:
        ust = getir(q)
        d = sum(BELGE[i]["ana"] == q["kavram"] for i in ust)
        kesinlik += d / K
        anma += d / 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


ort = sum(ILGILI[q["kavram"]] for q in SORGU) / len(SORGU)
tavan = sum(min(K, ILGILI[q["kavram"]]) / ILGILI[q["kavram"]] for q in SORGU) / len(SORGU)
print(f"{len(SORGU)} sorgu , k={K} , sorgu basina ilgili belge {ort:.3f} ,"
      f" anma tavani {tavan:.4f}")
print(f"bedel: {len(SORGU) * K} getirilen parca , {len(SORGU) * len(BELGE)} karsilastirma ,"
      f" {len(BELGE) + len(SORGU)} gomme cagrisi , {len(BELGE) * BOYUT} saklanan sayi")
print("\nkurulum          kesinlik    anma  kavram   sinif")
for ad, getir in (("anahtar sozcuk", anahtar_ara), ("gomme", gomme_ara)):
    p, a, kv, sn = olc(getir)
    print(f"{ad:<16} {p:8.4f} {a:7.4f} {kv:7.4f} {sn:7.4f}")

esit = 0
for q in SORGU:
    qb = set(belirtecle(q["metin"]))
    puan = [len(qb & BELIRTEC[i]) for i in range(len(BELGE))]
    esit += puan.count(max(puan))
print(f"\nanahtar sozcukte en yuksek puani paylasan belge sayisi ortalamasi :"
      f" {esit / len(SORGU):.1f}")
q = SORGU[0]
print(f"sorgu : {q['metin']}  (kavram {q['kavram']})")
for ad, getir in (("anahtar sozcuk", anahtar_ara), ("gomme", gomme_ara)):
    print(f"  {ad:<14}", " ".join(
        f"{BELGE[i]['kod']}/{BELGE[i]['ana']}" for i in getir(q)[:3]))

40 sorgu , k=5 , sorgu basina ilgili belge 10.825 , anma tavani 0.4904
bedel: 200 getirilen parca , 8000 karsilastirma , 240 gomme cagrisi , 6400 saklanan sayi

kurulum          kesinlik    anma  kavram   sinif
anahtar sozcuk     0.1200  0.0616  0.0500  0.2500
gomme              0.4600  0.2223  0.5000  1.0000

anahtar sozcukte en yuksek puani paylasan belge sayisi ortalamasi : 59.5
sorgu : nasil kaydediliyor form  (kavram okuma)
  anahtar sozcuk BK001/filtre AR002/basinc SY003/okuma
  gomme          SY025/degisim SY031/okuma SY035/degisim

Tablonun Okunması

Anahtar sözcük satırı bir arama sonucu gibi görünüyor ama değil. Kesinlik 0,1200; sorgu başına ortalama 10,825 ilgili belge iki yüz belge içinde durduğuna göre rastgele beş belge seçmenin kesinliği 0,0541 olurdu. Aradaki farkın kaynağını son satırlar söylüyor: en yüksek anahtar sözcük puanını ortalama 59,5 belge paylaşıyor. İlk beşi belirleyen şey ilgililik değil, eşitliği bozan belge sırasıdır. Anma 0,0616’da kalıyor.

Gömme satırı aynı sorgularda 0,4600 kesinlik ve 0,2223 anma veriyor; kesinlik dört katına çıkıyor. Anmanın kendi tavanı var: her sorguda ortalama 10,825 ilgili belge varken beş belge getirilirse anma en çok 0,4904 olabilir. Gömme bu tavanın yarısına yakınını alıyor ve kalan boşluk düzeneğin değil, getirilen parça sayısının boşluğudur.

Örnek sorgunun ilk üç sonucu farkı somutlaştırıyor. Anahtar sözcük araması BK001, AR002 ve SY003 getiriyor: üç ayrı sınıftan üç belge, hedef kavramı taşıyan tek belge de eşitlik bozulduğu için üçüncü sıraya gelmiş. Gömme araması üçünü de sayaç sınıfından getiriyor ve ikincisi hedef kavramı taşıyor.

İki Sütunun Niçin Ayrı Durduğu

Tablonun son iki sütunu bu kursun kuralının ilk uygulamasıdır. Gömme aramasının sınıf isabeti 1,0000: kırk sorgunun kırkında ilk sonuç doğru sınıftan. Aynı satırın kavram isabeti 0,5000: yirmi sorguda ilk sonuç yanlış kavramın belgesi, doğru sınıfın içinden.

Tek bir ölçüte indirilseydi ne olurdu. Sınıf isabeti raporlansaydı sistem kusursuz görünür, iyileştirilecek bir şey kalmazdı. Kavram isabeti raporlansaydı yazı tura kadar iyi görünür, sınıf düzeyindeki tam isabet görünmezdi. İkisi yan yana durunca sorun adını alıyor: düzenek sınıfı buluyor, kavramı bulamıyor. Yanlış getirilen belge aynı sınıftan olduğu için ilgisiz değil, yalnız yanlış; bir yanıtın içine konduğunda konu dışı görünmez.

Anahtar sözcük satırında aynı ayrım tersinden okunuyor: sınıf isabeti 0,2500, kavram isabeti 0,0500. Sınıf sütunu buradaki başarısızlığı yumuşatıyor, çünkü beş sınıf varken dörtte bir isabet tek bir sınıfı her seferinde söylemenin payından uzak değil.

Bedel satırı düzeneğin fiyatını yazıyor: 8000 karşılaştırma, 240 gömme çağrısı, 6400 saklanan sayı, 200 getirilen parça. Anahtar sözcük araması gömme çağrısı harcamıyor; farkın tamamı bu 240 çağrının ve 6400 sayının karşılığıdır. Dağarcık büyüdükçe karşılaştırma sayısı doğru orantılı büyür, çünkü her sorgu bütün dağarcıkla karşılaştırılıyor.

Özet

• Bir kavramın belge dilindeki yüzeyi ile sorgu dilindeki yüzeyi ayrı olabilir; bu dağarcıkta yirmi kavramın tamamında ortak belirteç sayısı sıfırdır.
• Aynı kırk sorguda anahtar sözcük araması 0,1200 erişim kesinliği ve 0,0616 erişim anması, gömme araması 0,4600 ve 0,2223 veriyor.
• Anahtar sözcükte en yüksek puanı ortalama 59,5 belge paylaşıyor; ilk beşi ilgililik değil eşitliği bozan sıra belirliyor.
• Anmanın tavanı beş parça ve ortalama 10,825 ilgili belge için 0,4904’tür; ölçülen anma bu tavana göre okunur.
• Sınıf isabeti 1,0000 iken kavram isabeti 0,5000’dir; iki sütun sorunu adlandırır, tek sayı gizler.
• Erişimin bedeli 8000 karşılaştırma, 240 gömme çağrısı, 6400 saklanan sayı ve 200 getirilen parçadır.

Sonraki Adım

Bu derste tek bir gömme kullanıldı ve o gömme dağarcığın diliyle sorgunun dilini birlikte tanıyor. Bu bir varsayımdır: hazır bir gömme modeli başka bir alanın metinleriyle kurulmuşsa sorgu dilini tanımayabilir. Sonraki ders aynı boyutta iki gömme kurar — biri bu alanın diline uyumlu, öbürü değil — ve aynı kırk sorguda ikisinin getirdiği parçayı yan yana sayar. Boyut kararının bedeli Model API’leri ile Uygulama Geliştirme kursunda ölçülmüştü; üstüne eklenecek olan alan uyumunun payıdır.