---
title: 'Gömme Arayüzleri'
source: 'https://academia.sh/tr/kurslar/model-apileri/gomme-apileri'
course: "Model API'leri ile Uygulama Geliştirme"
language: tr
updated: '2026-08-17T18:06:37+00:00'
license: 'CC BY-SA 4.0'
---

# Gömme Arayüzleri

Yanıt olarak metin değil vektör döndüren bir uç noktanın ve tek bir kararın ölçülmesi: gömmenin kaç boyutlu isteneceği. Yetmiş iki kurgu kayıtta çağrı maliyeti boyuttan bağımsızdır ve 1814 giriş belirtecinde sabit kalır; değişen saklanan sayı (10368'den 648'e) ve karşılaştırma çarpması (368064'ten 23004'e) olur. Üç en yakın komşunun aynı konudan olma payı 144 boyutta 0,9259, 72'de 0,9028, 36'da 0,8102, 9'da 0,6389. Boyutu yarıya indirmenin kaybı 0,0231, aynı boyuttaki ikinci gömme modeliyle fark 0,0232: yarıya indirme ölçülemez bir kayıpla saklamayı yarıya düşürüyor. Boyut düştükçe iki model arasındaki fark 0,0232'den 0,1018'e büyüyor ve istemci tarafında katlamanın kazancı bu farkın altında kalıyor.

Önceki ders girdinin biçimini ölçtü ve her biçimin faturasını belirteçle yazdı. Sonunda kalan
soru şuydu: altmış kaydın hangisinin eldeki talebe benzediğini bulmak gerekse, hepsini isteme
koymak mümkün olmadığına göre benzerlik neyin üzerinden hesaplanır.

Arayüz bunun için ayrı bir yüzey sunar. **Gömme arayüzü** bir metin alır ve yanıt olarak metin
değil, sabit uzunlukta bir **sayı dizisi** döndürür. Bu yüzeyin ölçülecek bir tek ayarı vardır ve
bu ders onu ölçer: **vektörün kaç boyutlu olacağı**. Boyut düştükçe saklanan sayı ve karşılaştırma
maliyeti düşer, komşuluk isabeti de düşer. İkisinin hangi noktada ayrıştığı sayılır.

- **AK49.** Kod bir **benzeticidir**; gerçek bir gömme uç noktası çağrılmaz. Kayıtlar, parça
  dağarcığı ve gömme yordamının kendisi **kurgudur**, tohum **20260218**.
- **AK50.** Benzetici belirtecin izinden koordinat üretir ve **bilgiyi ilk koordinatlara ağırlıklı
  yerleştirir**. `boyut` parametresi baştan o kadar koordinat döndürmek demektir. Bu, boyut
  parametresi sunan bir uç noktanın yapısal karşılığıdır.
- **AK51.** Gömme arayüzü **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.
- **AK52.** Bu yüzden ikinci koşum ayrı bir tabandan okunur: **aynı aileden ikinci bir gömme
  modeli** (tohum 20260219 ile kurulan benzetici). Bir boyut kararının taşınabilir sayılması için
  kaybın **iki model arasındaki farkı aşması** gerekir.
- **AK53. Komşuluk isabeti**, her kaydın **üç en yakın komşusunun** aynı konudan olma payıdır.
  Ölçü tek komşu yerine üç komşu üzerinden alınır, çünkü tek komşu tek bir çiftin oynamasıyla
  değişir.
- **AK54. Erişim hattı bu derste kurulmaz.** Hangi belgenin isteme gireceği, kaç belge
  getirileceği ve yanlış getirmenin bedeli Gömme Vektörleri ve Erişim Artırılmış Üretim kursuna
  bırakılır. Burada yalnız vektörlerin **birbirine göre** durumu ölçülür.
- **AK55.** Gömme, açı benzerliği ve boyut azaltma Makine Öğrenmesi ve Veri Bilimi müfredatının
  Denetimsiz Öğrenme ile Doğal Dil İşleme ve Bilgisayarla Görme kurslarında ölçüldü; o yordamlar
  burada tekrarlanmaz. Eklenen tek şey **arayüz düzeyindeki boyut kararıdır**.
- **AK56.** Karşılaştırma maliyeti, yetmiş iki kaydın bütün çiftleri için gereken **çarpma
  sayısıyla** yazılır. Saklama maliyeti **tutulan sayı adedidir**.

## Vektör Döndüren Uç Nokta

Aşağıdaki blok yetmiş iki kurgu kaydı üretir, gömme arayüzünü kurar ve iki şey gösterir. Birincisi
uç noktanın belirlenmiş olduğu: aynı metin iki çağrıda aynı vektörü verir, yani bu dersin bütün
sayıları koşum farkı taşımaz. İkincisi mekanizma: aynı konudan bir kayda olan benzerlik ile başka
konudan bir kayda olan benzerlik arasındaki **aralık**, boyut düştükçe ne oluyor.

```python
# BENZETICI -- KURGUDUR. Gercek bir gomme uc noktasi cagrilmaz. Kayitlar,
# parca dagarcigi ve gomme yordami kurgudur.
TOHUM, M32 = 20260218, 0xFFFFFFFF
BOYUT = 144                             # uc noktanin en buyuk gomme boyutu


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 belirtecle(m):                      # KURGU belirtecleyici, parca en cok bes damga
    b = []
    for s in m.lower().replace(",", " , ").split():
        while len(s) > 5:
            b.append(s[:5])
            s = s[5:]
        b.append(s)
    return b


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


KONU = ["fatura", "ariza", "sayac", "tarife", "kesinti"]
PARCA = {
    "fatura": ["fatura tutari cok yuksek geldi", "odemeyi yaptim borc gorunuyor",
               "fatura ayrintisini goremiyorum", "son odeme tarihi gecmis",
               "gecmis donem dokumu lazim", "tutar gecen aya gore artmis"],
    "ariza": ["evde su akmiyor bir ariza var", "baglanti bozuk hic calismiyor",
              "ariza kaydi actim ekip gelmedi", "vana kapali kalmis",
              "boru patlamis sokak su icinde", "servis ekibi randevuyu kacirdi"],
    "sayac": ["sayac okumasi yanlis girilmis", "endeks tutmuyor gibi",
              "sayac degisimi randevusu istiyorum", "sayac cami buharlanmis",
              "muhur kopmus gorunuyor", "endeks fotografini gonderdim"],
    "tarife": ["hangi tarife basamagindayim", "tarife degisikligi nasil olur",
               "birim ucret abone tipine gore degisiyor", "indirimli tarife sarti nedir",
               "kademeli hesap anlasilmiyor", "abone tipim yanlis kayitli"],
    "kesinti": ["mahallede kesinti var", "planli kesinti duyurusu nerede",
                "aksamdan beri kesinti yasiyoruz", "kesinti suresi uzadi",
                "bakim calismasi ne zaman biter", "sokak boyunca su yok"]}
KUYRUK = ["abone numaram kayitli", "bolge merkez ilce", "daha once de yazdim",
          "acil degil ama takipteyim", "telefonla ulasilamiyor", "ek belge gonderdim"]
KAYIT = []
for i in range(72):                     # 72 KURGU kayit: 2-4 kendi parcasi , bazen bir yabanci
    r = uretec(TOHUM + 400 + i)
    k = KONU[int(r() * 5)]
    p = list(PARCA[k])
    sec = [p.pop(int(r() * len(p))) for _ in range(2 + int(r() * 3))]
    if r() < 0.35:
        y = KONU[(KONU.index(k) + 1 + int(r() * 4)) % 5]
        sec.append(PARCA[y][int(r() * 6)])
    sec.append(KUYRUK[int(r() * 6)])
    KAYIT.append({"no": 5001 + i, "konu": k, "metin": " ".join(sec)})
CAGRI = [0]


def gom(metin, boyut=BOYUT, tohum=TOHUM):
    """KURGU gomme uc noktasi. Bilgi ilk koordinatlara agirlikli yerlestirilir;
    boyut parametresi bastan bu kadar koordinat dondurmek demektir."""
    CAGRI[0] += 1
    bel = belirtecle(metin)
    v = [0.0] * BOYUT
    for t in bel:
        r = uretec(izno(t) ^ tohum)
        for _ in range(10):             # her belirtec on koordinata dokunur
            i = int(r() ** 2 * BOYUT)   # kare alma agirligi ilk koordinatlara toplar
            v[i] += 1.0 if r() < 0.5 else -1.0
    v = v[:boyut]
    n = sum(x * x for x in v) ** 0.5 or 1.0
    return [x / n for x in v], len(bel)


def katla(v, d):
    """Istemci tarafinda boyut dusurme: koordinatlar toplanarak katlanir."""
    k = [0.0] * d
    for i, x in enumerate(v):
        k[i % d] += x
    n = sum(x * x for x in k) ** 0.5 or 1.0
    return [x / n for x in k]


def benzerlik(u, v):
    return sum(a * b for a, b in zip(u, v))


x = KAYIT[0]
ayni = next(y for y in KAYIT[1:] if y["konu"] == x["konu"])
baska = next(y for y in KAYIT[1:] if y["konu"] != x["konu"])
tam, bel = gom(x["metin"])
print(f"kayit {x['no']} ({x['konu']}) : {x['metin'][:56]}")
print(f"giris belirteci {bel} , donen sayi {len(tam)} , ikinci cagri ayni vektor:"
      f" {gom(x['metin'])[0] == tam}")
print("ilk sekiz koordinat:", " ".join(f"{c:+.3f}" for c in tam[:8]))
print("son sekiz koordinat:", " ".join(f"{c:+.3f}" for c in tam[-8:]))
print(f"\nboyut  {x['no']}-{ayni['no']} ({ayni['konu']})  "
      f"{x['no']}-{baska['no']} ({baska['konu']})  aralik")
for d in (144, 36, 9):
    a, b = gom(x["metin"], d)[0], gom(ayni["metin"], d)[0]
    c = gom(baska["metin"], d)[0]
    ab, ac = benzerlik(a, b), benzerlik(a, c)
    print(f"{d:>5} {ab:>17.4f} {ac:>19.4f} {ab - ac:>8.4f}")
```

```
kayit 5001 (sayac) : muhur kopmus gorunuyor sayac cami buharlanmis endeks fot
giris belirteci 37 , donen sayi 144 , ikinci cagri ayni vektor: True
ilk sekiz koordinat: -0.329 +0.094 +0.094 +0.235 +0.047 +0.047 +0.141 -0.094
son sekiz koordinat: +0.000 +0.000 +0.000 +0.000 +0.000 +0.000 +0.000 +0.047

boyut  5001-5002 (sayac)  5001-5003 (tarife)  aralik
  144            0.5074              0.1790   0.3284
   36            0.3991              0.3544   0.0447
    9            0.4423              0.3922   0.0501
```

İlk çıktı satırı bu yüzeyin metin döndüren yüzeyden farkını gösteriyor: otuz yedi belirteçlik bir
girdi, yüz kırk dört sayılık bir çıktıya dönüşüyor ve ikinci çağrı **aynı vektörü** veriyor. Metin
üreten çağrıda aynı istem iki koşumda iki ayrı yanıt verebiliyordu; burada veremez. Bu dersin
bütün farkları bu yüzden gerçek farklardır, koşum oynaması değildir.

Koordinat satırları benzeticinin varsayımını görünür kılıyor. İlk sekiz koordinat dolu, son sekiz
koordinatın yedisi sıfır. Bilgi baştaki koordinatlara toplanmış durumda; boyut parametresi de bu
yüzden **baştan kesmek** anlamına geliyor.

Aralık tablosu asıl mekanizmadır. Yüz kırk dört boyutta aynı konudan komşuya benzerlik 0,5074,
başka konudan komşuya 0,1790 ve aralık **0,3284**. Otuz altı boyutta iki benzerlik de birbirine
yaklaşıyor ve aralık **0,0447**'ye iniyor. Boyut düşünce vektörler birbirinden uzaklaşmıyor,
**birbirine yaklaşıyor**; ayırt etmeyi zorlaştıran şey mesafenin kendisi değil, mesafeler
arasındaki aralığın kapanmasıdır. Dokuz boyuttaki 0,0501 aralığın yeniden açıldığını göstermez;
tek bir çift tek bir çekilişten fazlasını söylemez ve karar tablodan okunur.

## Beş Boyutun Bedel ve İsabet Tablosu

Yetmiş iki kayıt beş boyutta ayrı ayrı gömülür. Her satırda saklanan sayı adedi, bütün çiftleri
karşılaştırmak için gereken çarpma sayısı, komşuluk isabeti, aynı boyutta ikinci gömme modelinin
isabeti ve tam vektörü istemci tarafında katlayarak elde edilen isabet basılır.

```python
N, K = len(KAYIT), 3
CAGRI[0] = 0
TAM = [gom(y["metin"])[0] for y in KAYIT]
IKINCI = [gom(y["metin"], BOYUT, TOHUM + 1)[0] for y in KAYIT]
GIRIS = sum(gom(y["metin"])[1] for y in KAYIT)


def kirp(v, d):
    u = v[:d]
    n = sum(a * a for a in u) ** 0.5 or 1.0
    return [a / n for a in u]


def komsuluk(vek):
    """Uc en yakin komsunun ayni konudan olma payi. Erisim hatti kurulmaz."""
    en = [[] for _ in range(N)]
    for i in range(N):
        for j in range(i + 1, N):
            s = benzerlik(vek[i], vek[j])
            en[i].append((s, j))
            en[j].append((s, i))
    d = 0
    for i in range(N):
        for _, j in sorted(en[i], reverse=True)[:K]:
            d += KAYIT[j]["konu"] == KAYIT[i]["konu"]
    return d / (N * K)


print(f"{N} kayit , {CAGRI[0]} gomme cagrisi , toplam giris {GIRIS} belirtec"
      f" -- bu sayi boyuttan bagimsizdir")
print("boyut  saklanan  karsilastirma  uc nokta  ikinci model  istemci katlamasi")
for d in (144, 72, 36, 18, 9):
    u = komsuluk([kirp(v, d) for v in TAM])
    m = komsuluk([kirp(v, d) for v in IKINCI])
    kt = komsuluk([katla(v, d) for v in TAM])
    print(f"{d:>5} {N * d:>9} {N * (N - 1) // 2 * d:>14} {u:>9.4f}"
          f" {m:>13.4f} {kt:>18.4f}")
```

```
72 kayit , 216 gomme cagrisi , toplam giris 1814 belirtec -- bu sayi boyuttan bagimsizdir
boyut  saklanan  karsilastirma  uc nokta  ikinci model  istemci katlamasi
  144     10368         368064    0.9259        0.9491             0.9259
   72      5184         184032    0.9028        0.9259             0.9120
   36      2592          92016    0.8102        0.9120             0.9120
   18      1296          46008    0.7685        0.8611             0.8148
    9       648          23004    0.6389        0.7176             0.7315
```

Başlık satırı bu tablonun en kolay gözden kaçan sayısını taşıyor. Toplam giriş **1814 belirteç**
ve bu sayı beş boyutta da aynı. Boyut kararı **çağrı maliyetini değiştirmez**: aynı metinler,
aynı belirteçler, aynı çağrı sayısı. Değişen şey çağrıdan sonra başlar. Saklanan sayı 10368'den
648'e, karşılaştırma çarpması 368064'ten 23004'e iniyor. Bir uç noktanın faturası ile bir
sistemin maliyeti aynı yerde durmuyor ve boyut kararı ikincisine ait.

## Kaybın Hangi Tabana Karşı Okunacağı

Uç nokta sütunu tek başına okunursa karar kolay görünür: boyut düştükçe isabet düşüyor, o hâlde
en büyük boyut alınır. İkinci model sütunu bu okumayı bozar. Yüz kırk dört boyutta iki model
0,9259 ve 0,9491 veriyor; aradaki fark **0,0232**. Boyutu yarıya, yetmiş ikiye indirmenin
maliyeti ise 0,9259'dan 0,9028'e, yani **0,0231**. Kayıp, aynı boyuttaki iki gömme modeli
arasındaki farkla aynı büyüklüktedir. Bu kararın **ölçülmüş bir kaybı yoktur**, buna karşılık
saklamayı ve karşılaştırmayı tam yarıya düşürür. Tablodaki en açık kazanç budur ve sezgiye
aykırıdır.

Otuz altı boyuta inildiğinde durum değişir. Uç nokta 0,8102 veriyor; yüz kırk dörde göre kayıp
0,1157 ve bu, iki model arasındaki farkın beş katıdır. Dokuz boyutta kayıp 0,2870'e çıkıyor.
Kırılma yetmiş iki ile otuz altı arasındadır: saklamanın dörtte üçü kazanılıncaya kadar bedel
ölçülemez düzeyde kalıyor, sonra hızla ödeniyor.

İkinci model sütununun kendisi de bir şey söylüyor. İki model arasındaki fark yüz kırk dörtte
0,0232 iken otuz altıda **0,1018**'e çıkıyor. Boyut düştükçe **hangi modeli kullandığın daha çok
önemli hâle geliyor**: yüksek boyutta iki model neredeyse aynı komşulukları kuruyor, düşük boyutta
ayrışıyorlar. Düşük boyutlu bir kurulumda model değiştirmenin bedeli, yüksek boyutlu bir
kurulumdakinin dört katından fazladır.

Son sütun boyutu kimin indirdiğini soruyor. Tam vektörü alıp koordinatları katlamak, otuz altı
boyutta 0,9120 veriyor; uç noktadan otuz altı boyut istemenin 0,8102'sinden 0,1018 yüksek. Ne var
ki bu kazanç tam olarak iki model arasındaki farka eşittir ve on sekiz boyutta 0,0463'e, yani o
satırın model farkının yarısına iniyor. Bu tabana göre **ölçülmüş bir üstünlük değildir**.
Üstelik bedeli vardır: katlama tam vektörü gerektirir, yani her çağrıda yüz kırk dört sayı almak
ve taşımak gerekir. Saklama kazancı korunur, aktarım kazancı kaybedilir. Soyutlamanın hangi
tarafta durduğu burada da belirleyicidir: uç noktanın boyut parametresi bir kararı senin yerine
verir, ve o kararın bedelini ancak iki tabanı yan yana koyduğunda görebilirsin.

## Özet

- Gömme arayüzü metin yerine sabit uzunlukta bir sayı dizisi döndürür ve belirlenmiştir: aynı
  metin her çağrıda aynı vektörü verir, bu yüzden bu dersin farkları koşum oynaması değildir.
- Boyut kararı çağrı maliyetini değiştirmez; yetmiş iki kaydın toplam giriş belirteci beş boyutta
  da 1814'tür. Değişen saklanan sayı (10368'den 648'e) ve karşılaştırma çarpmasıdır (368064'ten
  23004'e).
- Boyut düştükçe aynı konu ile başka konu arasındaki benzerlik aralığı kapanır: tek bir çiftte
  0,3284'ten 0,0447'ye iner, komşuluk isabeti 0,9259'dan 0,6389'a düşer.
- Boyutu yarıya indirmenin kaybı 0,0231, aynı boyuttaki ikinci modelle fark 0,0232: saklama ve
  karşılaştırma yarıya inerken ölçülmüş bir kayıp yoktur. Kırılma yetmiş iki ile otuz altı
  arasındadır.
- İki model arasındaki fark boyut düştükçe 0,0232'den 0,1018'e büyür; düşük boyutta model seçimi
  daha ağır basar.
- Tam vektörü istemcide katlamak otuz altı boyutta 0,1018 kazandırır ama bu kazanç model farkının
  düzeyindedir ve her çağrıda yüz kırk dört sayı taşımayı gerektirir.

## Sonraki Adım

Bu dersteki gömme uç noktası ile önceki derslerdeki metin uç noktası aynı sağlayıcıdan gelmek
zorunda değil. Boyut parametresinin adı, dağılım sıcaklığının ölçeği, hata alanının biçimi ve
yanıtın hangi anahtarla döndüğü sağlayıcıdan sağlayıcıya değişir. Bir uygulama bu farkları her
çağrı yerine tek bir yerde ele almak ister ve ortak bir arayüz yazar. Sonraki ders iki sağlayıcıyı
benzetici düzeyinde kurar ve o ortak arayüzün ne yaptığını sayar: kaç alan taşınıyor, kaç alan
kayboluyor ve kaybolan alanların hangisi bir ölçüyü görünmez kılıyor.
