--- title: 'Gömme Modelleri' source: 'https://academia.sh/tr/kurslar/rag/gomme-modelleri' course: 'Gömme Vektörleri ve Erişim Artırılmış Üretim' language: tr updated: '2026-08-17T18:06:35+00:00' license: 'CC BY-SA 4.0' --- # Gömme Modelleri Bir gömme modelinin üç ayarından ikisinin aynı iş yükünde yan yana ölçülmesi: boyut ve alan uyumu. Aynı otuz iki boyutta, aynı 6400 saklanan sayıda, aynı kırk sorguda alan içi gömme 0,4600 erişim kesinliği ve 0,5000 kavram isabeti verirken alan dışı gömme 0,0650 ve 0,0500'e düşüyor; kavram ve sınıf isabetinde anahtar sözcük tabanının sayısını birebir tekrarlıyor, getirilen kümede ise tabanın altına iniyor. Aynı aileden ikinci bir gömme modeliyle fark 0,0250 kavram isabetinde kalırken alan dışına düşmenin kaybı 0,4500; ilki ölçülmemiş, ikincisi ölçülmüştür. Boyut süpürmesinde iki model 64 ile 8 arasında hangi boyutun iyi olduğunda anlaşmıyor ve uçurum yalnız 8 ile 4 arasında ortaya çıkıyor. Ö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. ```python # 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. ```python 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. ```python 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.