---
title: 'Bağlam Penceresi'
source: 'https://academia.sh/tr/kurslar/yz-muhendisligine-giris/baglam-penceresi'
course: 'Yapay Zekâ Mühendisliğine Giriş'
language: tr
updated: '2026-08-17T18:06:36+00:00'
license: 'CC BY-SA 4.0'
---

# Bağlam Penceresi

Pencere aşıldığında ne olduğunun ve üç kırpma kararının kaç belirteç kazandırıp isabeti ne kadar düşürdüğünün ölçülmesi: 256 belirteçlik pencerede 300 kurgu istemin 0,5967'si sığmıyor ve çıplak çağrı 282,3 belirteçle 0,3833 tam yanıt veriyor. Baştan atmak 217,5 belirteçle 0,7433, ortadan atmak aynı belirteçle 0,7367, özetlemek 100,6 belirteçle kod isabetini 0,9667'ye çıkarıyor ama adım isabetini 0,0000'a düşürüyor. Kırpmanın hangi kararı verdiği kanıtın yerine bağlıdır: baştan atmak baş kovada 0,5351, ortadan atmak orta kovada 0,3627 veriyor. Pencere 128'den 384'e çıktığında tam yanıt 0,3767'den 0,9867'ye yükseliyor.

Bir önceki ders yanıtın adım adım nasıl üretildiğini ve seçim kuralının ne ödettiğini saydı, ama
girişi hep 30 belirteçte sabit tuttu. Gerçek bir düzenekte giriş sabit değildir. İstem büyür: bir
yönerge, saha ekibinin belgelerinden birkaçı, talep akışı ve soru yan yana konur. Modelin ise
sabit bir **bağlam penceresi** vardır ve o pencere aşıldığında bir şey olur.

Bu ders o "bir şeyi" ölçer. Pencere bir sınırdır; sınırı aşan istemi neyin kırpacağı ise bir
**karardır** ve karar mühendisindir. Üç karar aynı görevde yan yana konur — baştan atmak, ortadan
atmak, özetlemek — ve her biri iki sayıyla yazılır: kaç belirteç kazandırdı, isabeti ne kadar
düşürdü.

- **DL35.** Belge dağarcığı ve talepler **kurgudur**: ders içinde üretilir, tohum 20260218.
  Dağarcık 24 belgedir, her biri 28 belirteç; kayıtlar hiçbir kaynak sistemden gelmez.
- **DL36.** Bir belge bir başlık satırı (belge numarası, nesne, durum, arıza kodu) ve beş yordam
  adımı taşır.
- **DL37.** İstem dört parçadır: yönerge, belgeler, talep, soru. Kırpma **belge bütünlüğünde**
  yapılır; yarım belge bırakılmaz. Yönerge, talep ve soru hiçbir kararda atılmaz.
- **DL38.** Görev iki alanlıdır: doğru belgenin **arıza kodu** ve **ikinci adımı**. Tam yanıt
  ikisinin birden doğru olmasıdır.
- **DL39.** Model bir **benzeticidir**. İstemi pencereye sığdığı sürece okur; sığmazsa çağrı
  **pencere hatasıyla** başarısız olur ve hiçbir yanıt dönmez.
- **DL40.** Benzeticinin ikinci başarısızlığı **zaman aşımıdır** ve payı istem uzunluğuyla birlikte
  büyür. Bu pay tohuma bağlıdır; ikinci koşum tohum değiştirilerek alınır.
- **DL41.** Özetleme yordamı burada kuralla yapılır: her belgeden yalnız başlık satırı bırakılır.
  Gerçek bir düzenekte özet bir model çağrısıdır ve **kendi bedeli** vardır.
- **DL42.** Ölçüt her satırda aynıdır: istem başına belirteç (küçük iyi), başarısızlık payı (küçük
  iyi), kod ile adım isabeti ve tam yanıt oranı (büyük iyi).
- **DL43.** Kanıtın istemdeki **yeri** kaydedilir: hedef belgenin belge listesindeki sırası.
- **DL44.** Pencere süpürmesinde başarısızlık payı hesaba katılmaz; o tablo koşumdan bağımsızdır.
- **DL45.** **Çıplak çağrı** bu derste istemin hiç kırpılmadan gönderilmesidir.

## Pencereyi Aşan İstem

İstem yönergeyle başlar, dört ile on dört belge sürer, talep ve soruyla biter. Pencere 256
belirteçtir.

```python
# BENZETICI — model ders icinde standart kitaplikla yazilmis bir benzeticidir;
# gercek bir uc nokta cagrilmaz. Belge dagarcigi ve talepler KURGUDUR, tohum 20260218.
TOHUM, M32, PENCERE, TALEP = 20260218, 0xFFFFFFFF, 256, 300


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


NESNE = ["fatura", "tarife", "sayac", "vana", "muhur", "hat"]
DURUM = ["yuksek", "eksik", "bozuk", "eski"]
EYLEM = ["kaydi ac", "ekip yonlendir", "olcum tekrarla", "bilgi gonder",
         "tarife karsilastir", "muhur degistir"]
YONERGE = ("yonerge : asagidaki belgelere bak , talebin nesnesi ve durumu ile "
           "eslesen belgeyi bul , kodu ve ikinci adimi yaz .").split()
SORU = "soru : bu talebin kodu ve ikinci adimi nedir ?".split()

DAGARCIK = []
for i, n in enumerate(NESNE):
    for j, d in enumerate(DURUM):
        r = uretec(TOHUM + 900 + i * 4 + j)
        b = ["belge", str(101 + i * 4 + j), ":", n, d, "kod", f"{'ABCDEF'[i]}{j + 1}"]
        for a in range(1, 6):
            b += ["adim", str(a)] + EYLEM[int(r() * 6)].split()
        DAGARCIK.append({"dizi": b + ["son"], "nesne": n, "durum": d,
                         "kod": b[6], "adim2": b[13:15]})

VERI = []
for i in range(TALEP):
    r = uretec(TOHUM + i)
    h = int(r() * 24)
    hedef = DAGARCIK[h]
    baska = [DAGARCIK[(h + 1 + int(r() * 23)) % 24] for _ in range(3 + int(r() * 11))]
    yer = int(r() * (len(baska) + 1))
    belgeler = ([b["dizi"] for b in baska[:yer]] + [hedef["dizi"]]
                + [b["dizi"] for b in baska[yer:]])
    kuyruk = ["talep", ":", hedef["nesne"], "durumu", hedef["durum"], ",",
              "cevap", "bekliyorum", "."] + SORU
    VERI.append({"belgeler": belgeler, "kuyruk": kuyruk, "yer": yer,
                 "kod": hedef["kod"], "adim2": hedef["adim2"],
                 "nesne": hedef["nesne"], "durum": hedef["durum"]})


def birlestir(belgeler, kuyruk):
    d = list(YONERGE)
    for b in belgeler:
        d += b
    return d + kuyruk


uz = [len(birlestir(x["belgeler"], x["kuyruk"])) for x in VERI]
print(f"kurgu belge dagarcigi {len(DAGARCIK)} belge, her biri"
      f" {len(DAGARCIK[0]['dizi'])} belirtec")
print(f"{TALEP} istem: {min(uz)}-{max(uz)} belirtec, ortalama {sum(uz) / TALEP:.1f};"
      f" belge sayisi {min(len(x['belgeler']) for x in VERI)}"
      f"-{max(len(x['belgeler']) for x in VERI)}")
print(f"pencere {PENCERE} belirtec; pencereyi asan istem"
      f" {sum(u > PENCERE for u in uz) / TALEP:.4f}")
print("\n" + " ".join(DAGARCIK[9]["dizi"]))
print(" ".join(VERI[0]["kuyruk"]))
```

```
kurgu belge dagarcigi 24 belge, her biri 28 belirtec
300 istem: 152-432 belirtec, ortalama 282.3; belge sayisi 4-14
pencere 256 belirtec; pencereyi asan istem 0.5967

belge 110 : sayac eksik kod C2 adim 1 bilgi gonder adim 2 bilgi gonder adim 3 kaydi ac adim 4 muhur degistir adim 5 tarife karsilastir son
talep : hat durumu eski , cevap bekliyorum . soru : bu talebin kodu ve ikinci adimi nedir ?
```

Ortalama istem 282,3 belirteçtir ve pencere 256'dır: **istemlerin 0,5967'si sığmaz.** Bu oran
düzeneğin bir özelliğidir, modelin değil. Belge sayısı 4'ten 14'e çıkarken istem 152 belirteçten
432'ye uzuyor ve sınırın hangi tarafında kalınacağını istemi kuran yordam belirliyor.

## Üç Kırpma Kararı

Kararlar belge bütünlüğünde çalışır. Baştan atmak en eski belgeyi, ortadan atmak listenin
ortasındakini düşürür; özetlemek hiçbir belgeyi atmaz ama her birinden yalnız başlığı bırakır.
Dördüncü bir karar ikisini birleştirir: hepsini özetle, sonra bütçe elverdiği kadar son belgeleri
tam hâline geri koy.

```python
def bastan_at(x, p):
    bl = list(x["belgeler"])
    while len(bl) > 1 and len(birlestir(bl, x["kuyruk"])) > p:
        bl.pop(0)
    return birlestir(bl, x["kuyruk"])


def ortadan_at(x, p):
    bl = list(x["belgeler"])
    while len(bl) > 1 and len(birlestir(bl, x["kuyruk"])) > p:
        bl.pop(len(bl) // 2)
    return birlestir(bl, x["kuyruk"])


def ozetle(x, p):
    return birlestir([b[:7] for b in x["belgeler"]], x["kuyruk"])


def ozetle_ve_koru(x, p):
    bl = [b[:7] for b in x["belgeler"]]
    for i in range(len(bl) - 1, -1, -1):
        deneme = bl[:i] + [x["belgeler"][i]] + bl[i + 1:]
        if len(birlestir(deneme, x["kuyruk"])) > p:
            break
        bl = deneme
    return birlestir(bl, x["kuyruk"])


def yanitla(dizi, nesne, durum):
    kod = adim = None
    for i in range(len(dizi) - 6):
        if (dizi[i] == "belge" and dizi[i + 3] == nesne
                and dizi[i + 4] == durum and dizi[i + 5] == "kod"):
            kod = dizi[i + 6]
            for j in range(i + 7, len(dizi) - 3):
                if dizi[j] == "son":
                    break
                if dizi[j] == "adim" and dizi[j + 1] == "2":
                    adim = dizi[j + 2:j + 4]
                    break
            break
    return kod, adim


def cagir(istem, tohum, i):
    """Benzeticinin basarisizliklari: pencere asimi kesin, zaman asimi istem
    uzunluguyla birlikte buyuyen bir paydir."""
    if len(istem) > PENCERE:
        return "pencere"
    return "zaman" if uretec(tohum + i)() < 0.02 + 0.06 * len(istem) / PENCERE else None


def olc(ad, kirp, tohum=TOHUM, yaz=True):
    bel = pen = zam = kd = ad2 = tam = 0
    for i, x in enumerate(VERI):
        istem = kirp(x, PENCERE) if kirp else birlestir(x["belgeler"], x["kuyruk"])
        bel += len(istem)
        h = cagir(istem, tohum, i)
        pen += h == "pencere"
        zam += h == "zaman"
        if h:
            continue
        k, a = yanitla(istem, x["nesne"], x["durum"])
        kd += k == x["kod"]
        ad2 += a == x["adim2"]
        tam += k == x["kod"] and a == x["adim2"]
    n = len(VERI)
    if yaz:
        print(f"{ad:<22} {bel / n:>8.1f} {pen / n:>8.4f} {zam / n:>7.4f}"
              f" {kd / n:>7.4f} {ad2 / n:>7.4f} {tam / n:>7.4f}")
    return tam / n


print(f"{'karar':<22} {'belirtec':>8} {'pencere':>8} {'zaman':>7}"
      f" {'kod':>7} {'adim':>7} {'tam':>7}")
KARARLAR = [("ciplak cagri", None), ("bastan at", bastan_at),
            ("ortadan at", ortadan_at), ("ozetle", ozetle),
            ("ozetle ve kuyrugu koru", ozetle_ve_koru)]
for ad, f in KARARLAR:
    olc(ad, f)
```

```
karar                  belirtec  pencere   zaman     kod    adim     tam
ciplak cagri              282.3   0.5967  0.0200  0.3833  0.3833  0.3833
bastan at                 217.5   0.0000  0.0600  0.7433  0.7433  0.7433
ortadan at                217.5   0.0000  0.0600  0.7367  0.7367  0.7367
ozetle                    100.6   0.0000  0.0333  0.9667  0.0000  0.0000
ozetle ve kuyrugu koru    221.9   0.0000  0.0633  0.9367  0.7167  0.7167
```

**Çıplak çağrı** 282,3 belirteç harcar ve tam yanıt oranı 0,3833'tür. Kaybın kaynağı isabet değil,
**başarısızlıktır**: çağrıların 0,5967'si pencereye sığmadığı için hiç yanıt vermez. Sınıra çarpan
bir çağrı yanlış cevap üretmez, hiçbir cevap üretmez.

**Baştan atmak** en yalın kırpmadır: belirteci 217,5'e indirir, pencere hatasını sıfırlar ve tam
yanıtı 0,7433'e çıkarır. **Bedel** üç kalemdir — atılan belgeler, ek bir kırpma adımı ve zaman
aşımı payının 0,0200'den 0,0600'e çıkması. Bu son kalem sezgiye aykırıdır: kırpma ortalama istemi
kısaltmadı, **uzattı**, çünkü daha önce hiç gönderilemeyen uzun istemler artık gönderiliyor.

**Özetlemek** en ucuz karardır: 100,6 belirteç, çıplak çağrının 0,3564'ü. Kod isabetini 0,9667'ye
çıkarır — bütün belge başlıkları durduğu için doğru kod her zaman bulunur. Adım isabeti ise
**0,0000**'dır ve tam yanıt oranı da sıfırdır. Özet, sorulan şeyi atmıştır. **Bir özetin ne kadar
kaybettirdiği özetin kendisinden değil, sorudan okunur.**

Dördüncü karar iki ölçütte iki ayrı cevap veriyor: kod isabetinde 0,9367 ile baştan atmanın
0,7433'ünü açık ara geçiyor, tam yanıtta 0,7167 ile onun altında kalıyor ve 4,4 belirteç daha
pahalı. **Hangisinin kazandığı hangi sütunun okunduğuna bağlıdır** ve sütun seçimi ürün kararıdır.

## Kırpma Nereyi Kesiyor

Kırpmanın isabeti tek bir sayıya sığmaz: kararın hangi belgeyi attığı, aranan kanıtın nerede
durduğuna göre isabetli ya da yıkıcıdır.

```python
KARARLAR = [("bastan at", bastan_at), ("ortadan at", ortadan_at),
            ("ozetle", ozetle), ("ozetle ve kuyrugu koru", ozetle_ve_koru)]


def kova(x):
    n = len(x["belgeler"])
    return 0 if x["yer"] < n / 3 else (1 if x["yer"] < 2 * n / 3 else 2)


print(f"{'karar':<22} {'bas':>7} {'orta':>7} {'son':>7} {'kosum 2':>9}")
for ad, f in KARARLAR:
    d, t = [0, 0, 0], [0, 0, 0]
    for i, x in enumerate(VERI):
        istem = f(x, PENCERE)
        j = kova(x)
        t[j] += 1
        if cagir(istem, TOHUM, i):
            continue
        k, a = yanitla(istem, x["nesne"], x["durum"])
        d[j] += k == x["kod"] and a == x["adim2"]
    ik = olc(ad, f, TOHUM + 7000, False)
    print(f"{ad:<22} " + " ".join(f"{a / b:>7.4f}" for a, b in zip(d, t))
          + f" {ik:>9.4f}")
print("kova basina talep" + "".join(f"{t[j]:>8}" for j in range(3)).rjust(28))

print(f"\n{'pencere':>8} {'bastan at':>11} {'ozetle ve koru':>15} {'ozetle':>8}")
for p in (128, 192, 256, 384):
    s = []
    for f in (bastan_at, ozetle_ve_koru, ozetle):
        dog = 0
        for i, x in enumerate(VERI):
            istem = f(x, p)
            if len(istem) > p:
                continue
            k, a = yanitla(istem, x["nesne"], x["durum"])
            dog += k == x["kod"] and a == x["adim2"]
        s.append(dog / len(VERI))
    print(f"{p:>8} {s[0]:>11.4f} {s[1]:>15.4f} {s[2]:>8.4f}")
```

```
karar                      bas    orta     son   kosum 2
bastan at               0.5351  0.8235  0.9286    0.7367
ortadan at              0.9474  0.3627  0.9048    0.7000
ozetle                  0.0000  0.0000  0.0000    0.0000
ozetle ve kuyrugu koru  0.5439  0.7353  0.9286    0.7000
kova basina talep         114     102      84

 pencere   bastan at  ozetle ve koru   ozetle
     128      0.3767          0.2400   0.0000
     192      0.6367          0.6100   0.0000
     256      0.8000          0.7667   0.0000
     384      0.9867          0.9833   0.0000
```

İlk üç sütun kararların birbirine yakın toplam sayılarının içini açıyor. Baştan atmak baş kovada
0,5351, son kovada 0,9286 verir; ortadan atmak baş kovada 0,9474'e çıkar ama orta kovada 0,3627'ye
düşer. **İki kararın toplam isabeti neredeyse aynıdır (0,7433 ve 0,7367) ve hata dağılımları
birbirinin tersidir.** Bir ürün için bunlar aynı karar değildir: kanıt eski kayıtlarda duruyorsa
baştan atmak sistematik olarak yanılır, akışın ortasında duruyorsa ortadan atmak.

Son sütun aynı düzeneğin ikinci koşumudur. Yalnız zaman aşımı kurası değişti ve baştan atmak
0,7433 yerine 0,7367, ortadan atmak 0,7367 yerine 0,7000 verdi. **Aynı kırpma kararı, aynı veri,
iki koşum, iki sayı.** Kararlar arasındaki 0,0066'lık fark bu değişkenliğin altında kalır: tek
koşumla okunan bu tablo baştan atmayı kazandırırdı, ikinci koşum ikisini eşitler.

Alt tablo başarısızlık payını dışarıda bırakır ve koşumdan bağımsızdır. Pencere 128'den 384'e
çıktıkça baştan atmanın tam yanıtı 0,3767'den 0,9867'ye yükselir: kırpma kararının tamamı,
penceredeki eksikliği kapatma çabasıdır ve pencere yeterince büyükse hiçbir karar gerekmez.
Özetlemenin sütunu her pencerede 0,0000'dır — **pencereden kaynaklanmayan bir kayıp pencere
büyütülerek kapanmaz.** Kaybedilen bilgi istemin dışında kaldığı sürece sınır ne olursa olsun geri
gelmez, ve bu iki tabloyu ayıran soru şudur: kayıp sınırdan mı, yoksa sınırı karşılamak için
verilen karardan mı doğuyor.

## Özet

- Bağlam penceresi sabit bir sınırdır; aşıldığında bu benzetici hiç yanıt vermez. Çıplak çağrıda
  istemlerin 0,5967'si sığmaz ve tam yanıt oranı 0,3833'te kalır. Belgeler ve talepler kurgudur,
  tohum 20260218.
- Baştan atmak istemi 282,3'ten 217,5 belirtece indirir ve tam yanıtı 0,7433'e çıkarır. Bedeli
  atılan belgeler, ek bir adım ve zaman aşımı payının 0,0200'den 0,0600'e çıkmasıdır.
- Özetlemek en ucuz karardır (100,6 belirteç) ve kod isabetini 0,9667'ye çıkarır, ama sorulan
  adımı attığı için tam yanıt oranı 0,0000'dır.
- Kırpmanın isabeti kanıtın yerine bağlıdır: baştan atmak baş kovada 0,5351, ortadan atmak orta
  kovada 0,3627 verir. Toplam sayıları neredeyse aynıdır, hata dağılımları terstir.
- Aynı düzenek ikinci koşumda 0,7433 yerine 0,7367 verir; kararlar arasındaki fark bu
  değişkenliğin altındadır. Pencere 128'den 384'e çıktığında tam yanıt 0,3767'den 0,9867'ye
  yükselir.

## Sonraki Adım

Beş derste modelin yüzeyi ölçüldü: hangi birimle çalıştığı, uzak bağlamı niçin kullanabildiği,
neyi nereden öğrendiği, yanıtı nasıl ürettiği ve sınırının nerede olduğu. Pencere bir sınırdır ve
nasıl doldurulacağı bir karardır — bu ders o kararın üç biçimini sayıyla karşılaştırdı. Ama
şimdiye kadar hep aynı varsayım altında çalışıldı: doğru bilgi isteme konursa modelin onu doğru
kullanacağı. Modelin **neyi iyi yaptığı** hiç sorulmadı. Sonraki ders bir görev kümesini görev
sınıflarına ayırır ve düzeneksiz çağrının hangi sınıfta çöktüğünü sayar.
