Kısa Süreli Bellek

Bir önceki ders yanlış bir kaydın duruma girdikten sonra ortalama üç ile dört adım taşındığını saydı. Taşıyan şeyin adı kısa süreli bellektir (short-term memory): ajanın o görev boyunca elinde tuttuğu alanlar ve bu alanları üreten adımların izi. Döngü uzadıkça bu yük büyür ve bir yerde bir sınıra çarpar.

Sınırın adı Yapay Zekâ Mühendisliğine Giriş kursunda kondu; konuşma durumunun her istekte yeniden gönderildiği ve bunun tur başına ne tuttuğu Model API’leri ile Uygulama Geliştirme kursunda ölçüldü. Erişim hattında da aynı sınır sayılmıştı: Gömme Vektörleri ve Erişim Artırılmış Üretim kursunda pencereye ortalama 11,3 parça sığıyordu. Üç yordam da tekrarlanmaz. Bu dersin sorduğu tek şey döngüye özgüdür: adım başına kaç belirteç taşınıyor, pencereye kaç adım sığıyor ve pencere dolduğunda durumdan hangi alan düşüyor.

• AB44. Kod bir benzeticidir; ortam, görevler ve belirteçleyici kurgudur, tohum 20260218. Pencere değerleri de kurgudur, ölçülen şey eşiğin değeri değil daralmanın etkisidir.
• AB45. Taşınan yük iki parçadır: durum yükü, ajanın elindeki alanların belirteci; adım izinin yükü, o ana kadarki adımların döngüde tuttuğu yer. İkincisi ortak döngünün kendi sayımıdır ve adım başına 22 belirteç büyür; metinde kısaca iz yükü denir.
• AB46. Pencere durum ile izin toplamına konur. Toplam eşiği aşarsa duruma ilk giren alan düşer ve düşme sürer; iz yükü düşürülemez.
• AB47. Düşen alan sessizdir. Ajan bir alanın gittiğini görmez; eksikliği ancak o alanı isteyen araç eksik alan döndürdüğünde ortaya çıkar.
• AB48. Sığan adım, ilk düşme gerçekleşene kadar yapılan çağrı sayısıdır; hiç düşme olmayan görevde bütün çağrılar sayılır.
• AB49. Taban çizgisi sınırsız penceredir — sınırın hiç bağlamadığı döngü. Bedel toplam belirteç, adım, araç hatası ve düşen alan olarak yazılır.
• AB50. Görev kümesi kursun ortak yirmi dört görevidir; ölçüt yine son durumdaki yanıttır.

Ortak Döngü

Ortam, beş temel araç ve ajan döngüsü kurs boyunca aynıdır.

TOHUM, M32 = 20260218, 0xFFFFFFFF


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 str(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 str(m):
        h = ((h ^ ord(c)) * 16777619) & M32
    return h


# ---- KURGU ortam: olcum aginin kayitlari
BOLGE = ["dogu", "bati", "kuzey", "guney", "merkez"]
TIP = ["mesken", "isyeri"]
ABONE = {}
for i in range(60):
    r = uretec(TOHUM + 31 * i)
    onceki = 10000 + int(r() * 80000)
    ABONE[f"A{i + 1:03d}"] = {"bolge": BOLGE[int(r() * 5)], "tip": TIP[int(r() * 2)],
                              "onceki": onceki, "simdiki": onceki + int(r() * 70)}
BASAMAK, USTU = ((10, 4), (25, 7), (40, 11)), 16
ISYERI_KAT = 2
BELGE = {"TR01": "tarife basamaklari 10 25 40 metrekup ve ustu",
         "TR02": "isyeri abonesinde birim ucret iki katidir",
         "SY01": "endeks farki tuketimi verir sayac donusu 100000 eklenir",
         "AR01": "ariza kaydi acildiginda saha ekibi iki gun icinde gider",
         "KS01": "planli kesinti duyurusu bir hafta once yayimlanir"}

CAGRI = [0]                              # arac cagri sayaci


def _bedel(m3, tip):
    kalan, alt, top = m3, 0, 0
    for ust, birim in BASAMAK:
        dilim = min(kalan, ust - alt)
        if dilim <= 0:
            break
        top += dilim * birim
        kalan -= dilim
        alt = ust
    top += kalan * USTU
    return top * (ISYERI_KAT if tip == "isyeri" else 1)


def t_sayac_oku(abone=None, **_):
    a = ABONE.get(abone)
    if a is None:
        return {"hata": "abone yok"}
    return {"onceki": a["onceki"], "simdiki": a["simdiki"], "tip": a["tip"], "bolge": a["bolge"]}


def t_tuketim(onceki=None, simdiki=None, **_):
    if onceki is None or simdiki is None:
        return {"hata": "eksik alan"}
    f = simdiki - onceki
    return {"m3": f + 100000 if f < 0 else f}


def t_tarife(m3=None, tip="mesken", **_):
    if m3 is None:
        return {"hata": "eksik alan"}
    return {"tutar": _bedel(m3, tip)}


def t_belge(anahtar=None, **_):
    if not anahtar:
        return {"hata": "eksik alan"}
    ab = set(belirtecle(anahtar))
    en, kod = -1, None
    for k, m in BELGE.items():
        o = len(ab & set(belirtecle(m)))
        if o > en:
            en, kod = o, k
    return {"kod": kod, "metin": BELGE[kod]} if en > 0 else {"hata": "bulunamadi"}


def t_kayit(abone=None, sutun=None, deger=None, **_):
    if not (abone and sutun and deger is not None):
        return {"hata": "eksik alan"}
    return {"yazildi": True, "abone": abone, "sutun": sutun, "deger": deger}


ARAC = {
    "sayac_oku":  {"islev": t_sayac_oku, "alan": ("abone",), "yan_etki": False},
    "tuketim":    {"islev": t_tuketim, "alan": ("onceki", "simdiki"), "yan_etki": False},
    "tarife":     {"islev": t_tarife, "alan": ("m3", "tip"), "yan_etki": False},
    "belge_ara":  {"islev": t_belge, "alan": ("anahtar",), "yan_etki": False},
    "kayit_yaz":  {"islev": t_kayit, "alan": ("abone", "sutun", "deger"), "yan_etki": True},
}
ARAC_ADI = list(ARAC)


def cagir_arac(ad, durum):
    """Sema disindaki alanlar suzulur; eksik alan aracin kendi hatasidir."""
    CAGRI[0] += 1
    if ad not in ARAC:
        return {"hata": "arac yok"}
    kw = {a: durum[a] for a in ARAC[ad]["alan"] if a in durum}
    return ARAC[ad]["islev"](**kw)


# ---- KURGU gorevler: her biri bilinen bir arac dizisiyle cozulur
GOREV = []
for i in range(24):
    r = uretec(TOHUM + 9973 * i)
    ab = f"A{1 + int(r() * 60):03d}"
    t = ayrik(r(), [0.30, 0.22, 0.20, 0.28])
    if t == 0:
        GOREV.append({"ad": f"G{i + 1:02d}", "tur": "bedel", "abone": ab,
                      "istek": f"{ab} abonesinin bu donem bedeli nedir",
                      "dizi": ("sayac_oku", "tuketim", "tarife")})
    elif t == 1:
        GOREV.append({"ad": f"G{i + 1:02d}", "tur": "tuketim", "abone": ab,
                      "istek": f"{ab} abonesinin bu donem tuketimi kac metrekup",
                      "dizi": ("sayac_oku", "tuketim")})
    elif t == 2:
        GOREV.append({"ad": f"G{i + 1:02d}", "tur": "belge", "abone": ab,
                      "istek": "sayac donusunde endeks farki nasil hesaplanir",
                      "dizi": ("belge_ara",)})
    else:
        GOREV.append({"ad": f"G{i + 1:02d}", "tur": "kayit", "abone": ab,
                      "istek": f"{ab} abonesinin bedelini hesapla ve kayda yaz",
                      "dizi": ("sayac_oku", "tuketim", "tarife", "kayit_yaz")})


def dogru_yanit(g):
    a = ABONE[g["abone"]]
    f = a["simdiki"] - a["onceki"]
    m3 = f + 100000 if f < 0 else f
    if g["tur"] == "tuketim":
        return m3
    if g["tur"] == "belge":
        return "SY01"
    return _bedel(m3, a["tip"])


# ---- KURGU ajan: her adimda bir arac secer ya da biter
def gorme(d):
    return max(0.34, 0.80 - 0.09 * (d - 1))       # dogru araci secme payi, derinlikle duser


def ajan(g, en_cok_adim=8, tohum=TOHUM, oz_elestiri=False, onay=False):
    """KURGU ajan dongusu. Gercek bir model cagrilmaz; arac secimi
    gorevin dizisine ve derinlige bagli tek bir cekilisten gelir."""
    r = uretec(tohum ^ izno(g["ad"]))
    alan = {"abone": g["abone"], "anahtar": g["istek"], "sutun": "bedel"}
    iz, adim, bel, hata = [], 0, 0, 0
    dizi, k = g["dizi"], 0
    while adim < en_cok_adim:
        adim += 1
        bel += 60 + 22 * len(iz)
        hedef = dizi[k] if k < len(dizi) else None
        if hedef is None:                          # is bitti , ajan durmali
            if r() < 0.88:
                return {"bitti": True, "adim": adim, "iz": iz, "belirtec": bel,
                        "hata": hata, "yanit": alan.get("sonuc"), "onay": alan.get("onay", 0)}
            sec = ARAC_ADI[int(r() * len(ARAC_ADI))]
        else:
            sec = hedef if r() < gorme(k + 1) else ARAC_ADI[int(r() * len(ARAC_ADI))]
        if ARAC[sec]["yan_etki"] and onay:
            alan["onay"] = alan.get("onay", 0) + 1
        if sec == "kayit_yaz":
            alan["deger"] = alan.get("sonuc")
        s = cagir_arac(sec, alan)
        iz.append((sec, "hata" in s))
        bel += 30
        if "hata" in s:
            hata += 1
            if oz_elestiri:
                bel += 40
            continue
        alan.update({kk: vv for kk, vv in s.items() if kk != "hata"})
        if sec == "tuketim":
            alan["sonuc"] = s["m3"]
        if sec == "tarife":
            alan["sonuc"] = s["tutar"]
        if sec == "belge_ara":
            alan["sonuc"] = s["kod"]
        if sec == hedef:
            k += 1
    return {"bitti": False, "adim": adim, "iz": iz, "belirtec": bel, "hata": hata,
            "yanit": alan.get("sonuc"), "onay": alan.get("onay", 0)}


print("ortak ortam:", len(ABONE), "abone ,", len(BELGE), "belge ,",
      len(ARAC), "arac ,", len(GOREV), "gorev")

ortak ortam: 60 abone , 5 belge , 5 arac , 24 gorev

Adım Başına Taşınan Belirteç

Kısa süreli belleğin ölçüsü tek bir sayı değil, bir eğridir: her adımda taşınan yük bir önceki adımdan büyüktür. İlk blok bunu tek bir görevde adım adım basar; ikincisi aynı büyümeyi beş pencere değerinde yirmi dört göreve yayar.

# ---- Kisa sureli bellek: durum + iz, bir pencereye sigmak zorundadir
BELLEK = {"pencere": 10 ** 9, "cagri": 0, "bel": 0, "dusen": {},
          "sigan": -1, "profil": None}
_yurut = cagir_arac


def durum_belirteci(d):
    return sum(len(belirtecle(f"{k} : {v}")) for k, v in d.items())


def cagir_arac(ad, durum):
    """Pencere asilirsa duruma ilk giren alan duser; iz yuku dusurulemez."""
    b = BELLEK
    b["cagri"] += 1
    iz_yuk = 60 + 22 * (b["cagri"] - 1)
    while durum_belirteci(durum) + iz_yuk > b["pencere"] and len(durum) > 1:
        k = next(iter(durum))
        b["dusen"][k] = b["dusen"].get(k, 0) + 1
        if b["sigan"] < 0:
            b["sigan"] = b["cagri"] - 1
        del durum[k]
    d = durum_belirteci(durum)
    b["bel"] += d + iz_yuk
    if b["profil"] is not None:
        b["profil"].append((b["cagri"], ad, len(durum), d, iz_yuk))
    return _yurut(ad, durum)


def kosum(pencere, tohum=TOHUM):
    BELLEK.update(pencere=pencere, bel=0, dusen={})
    dogru = adim = hata = cagri = sigan = 0
    for g in GOREV:
        BELLEK.update(cagri=0, sigan=-1)
        s = ajan(g, tohum=tohum)
        dogru += s["yanit"] == dogru_yanit(g)
        adim, hata = adim + s["adim"], hata + s["hata"]
        cagri += BELLEK["cagri"]
        sigan += BELLEK["cagri"] if BELLEK["sigan"] < 0 else BELLEK["sigan"]
    return (dogru, hata, adim, BELLEK["bel"], BELLEK["bel"] / cagri, sigan / 24,
            sum(BELLEK["dusen"].values()), BELLEK["dusen"])


gk = next(g for g in GOREV if g["tur"] == "kayit")
BELLEK.update(pencere=10 ** 9, cagri=0, bel=0, dusen={}, sigan=-1, profil=[])
ajan(gk, tohum=TOHUM)
print(f"tek gorev ({gk['tur']}) , sinirsiz pencere: adim basina tasinan belirtec")
print("adim  arac         alan  durum  iz yuku  toplam")
for c, ad, n, d, y in BELLEK["profil"]:
    print(f"{c:>4}  {ad:<12} {n:>4}  {d:>5}  {y:>7}  {d + y:>6}")
BELLEK["profil"] = None

print("\npencere   dogru A  dogru B  adim  toplam bel  bel/cagri  sigan  hata A"
      "  hata B  dusen")
for pn in (10 ** 9, 260, 200, 150, 120):
    a, b = kosum(pn), kosum(pn, TOHUM + 1)
    print(f"{'sinirsiz' if pn > 10 ** 6 else pn:<9} {a[0] / 24:>7.4f}  {b[0] / 24:>7.4f}"
          f"  {a[2]:>4}  {a[3]:>10}  {a[4]:>9.1f}  {a[5]:>5.2f}  {a[1]:>6}  {b[1]:>6}"
          f"  {a[6]:>5}")
son = sorted(kosum(120)[7].items(), key=lambda x: (-x[1], x[0]))
print("\npencere 120 , en cok dusen alan:", son[:6])

tek gorev (kayit) , sinirsiz pencere: adim basina tasinan belirtec
adim  arac         alan  durum  iz yuku  toplam
   1  sayac_oku       3     19       60      79
   2  belge_ara       7     34       82     116
   3  belge_ara      10     54      104     158
   4  belge_ara      10     54      126     180
   5  tuketim        10     54      148     202
   6  tarife         11     57      170     227
   7  kayit_yaz      13     63      192     255

pencere   dogru A  dogru B  adim  toplam bel  bel/cagri  sigan  hata A  hata B  dusen
sinirsiz   0.9583   0.9583    97        9316      125.9   3.08       8       7      0
260        0.9583   0.9583    97        9297      125.6   3.04       9       7      3
200        0.8750   0.9167    98        9681      125.7   2.75      15      10     34
150        0.8333   0.7500   100        9926      124.1   2.42      28      35     40
120        0.7083   0.6250   112       12026      126.6   1.83      50      58     85

pencere 120 , en cok dusen alan: [('abone', 16), ('anahtar', 16), ('sutun', 15), ('onceki', 10), ('simdiki', 10), ('bolge', 5)]

Pencere Dolduğunda Düşen Alan

İlk çıktı büyümenin nereden geldiğini söyler. Durum yükü birinci adımda 19, yedinci adımda 63 belirteçtir; alan sayısı üçten on üçe çıkar. İz yükü ise 60’tan 192‘ye gider ve yedinci adımda durumun üç katıdır. Toplam 79’dan 255’e çıkıyor. Büyümenin büyük kısmı ajanın topladığı bilgiden değil, kaç adım attığından gelir. Bu ayrım dersin geri kalanını belirler, çünkü pencere daraldığında düşürülebilen tek parça durumdur.

İkinci tablo sınırı bağlar. Sınırsız pencerede yirmi dört görevin 0,9583‘ü doğru, toplam 9316 belirteç taşınıyor, hiçbir alan düşmüyor ve araç hatası 8. Pencere 260’a indiğinde üç alan düşüyor ve hiçbir sayı kıpırdamıyor. 200’de düşen alan 34’e, araç hatası 15‘e çıkıyor ve doğru yanıt 0,8750‘ye iniyor. 150’de düşen 40, hata 28, doğru yanıt 0,8333. 120’de düşen 85, hata 50, doğru yanıt 0,7083. Sığan çağrı sütunu daralmayı doğrudan okur: 3,08’den 1,83’e, yani en dar pencerede ortalama iki çağrı bile tamamlanmadan bir alan gidiyor.

Hangi alanın gittiği son satırdadır ve düzenin kendisinden gelir. En çok düşenler abone 16, anahtar 16, sutun 15 ile duruma ilk giren alanlardır; yani görevin kimlik bilgisi. Ardından onceki ve simdiki onar kez düşüyor. Sonucu bunlar açıklar: abone gidince sayac_oku abonesiz çağrılıyor, onceki gidince tuketim eksik alan döndürüyor. Araç hatasının 8’den 50’ye çıkması tek bir mekanizmanın sayımıdır ve iki koşumda da aynı yönde ilerliyor (7, 7, 10, 35, 58).

Başarım sütunu daha dikkatli okunmalı. En büyük iki koşum farkı 0,8333 ile 0,7500 arasındadır, band 0,0833. Sınırsız pencere ile 200 arasındaki düşüş de tam 0,0833‘tür: bandın altında değil ama üstünde de değil, bu yüzden bulgu sayılmaz; mekanizma düşen alan ve araç hatası sütunlarında görünür, görev başarımına etkisi ölçülmemiştir. 150’deki 0,1250 ve 120’deki 0,2500 bandın üstündedir ve ölçülmüştür.

Adım ile toplam belirteç sütunları dersin en ters sonucudur. Pencereyi daraltmak taşınan belirteci düşürmez: çağrı başına yük 125,9’dan 126,6’ya, yani hiç değişmiyor. Toplam ise 9316’dan 12026’ya, %29 artıyor, çünkü düşen alanlar araç hatası üretiyor ve döngü aynı işi bitirmek için 97 yerine 112 adım atıyor. Kısıtın kendisi bir tasarruf düzeneği değildir: küçülttüğü parça durum yüküdür ve o zaten yükün küçük kısmıdır; büyüyen parça olan iz yükü kısıttan hiç etkilenmez.

Özet

• Adım başına taşınan yük iki parçadır: durum yükü tek görevde 19’dan 63 belirtece çıkarken, iz yükü 60’tan 192’ye çıkar ve yedinci adımda durumun üç katıdır.
• Sınırsız pencerede doğru yanıt 0,9583, toplam 9316 belirteç, düşen alan 0, araç hatası 8.
• Pencere daraldıkça düşen alan 0’dan 85’e, araç hatası 8’den 50’ye çıkar ve sığan çağrı 3,08’den 1,83’e iner.
• Düşen alanlar duruma ilk giren kimlik alanlarıdır (abone 16, anahtar 16, sutun 15); düşüş sessizdir ve ancak o alanı isteyen aracın hatasında görünür.
• Pencereyi daraltmak taşınan belirteci düşürmez: çağrı başına yük 125,9’dan 126,6’ya sabit kalırken adım 97’den 112’ye çıktığı için toplam 9316’dan 12026’ya yükselir.
• Ölçüm bandı 0,0833’tür; 200 penceresindeki 0,0833’lük düşüş bulgu sayılmaz, 150 ve 120’deki 0,1250 ile 0,2500 ölçülmüştür.

Sonraki Adım

Bu derste bellek, tek bir görevin ömrü kadar yaşadı. Pencere doldu, alan düştü, araç hata verdi ve döngü bitti; bittiği anda geriye hiçbir şey kalmadı. Bir sonraki görev aynı aboneyi, aynı belge kodunu ve aynı tarife basamağını sıfırdan öğrenmek zorunda. Kısa süreli belleğin tuttuğu şey görevin çalışma kümesidir ve o küme görev bitince atılır. Sonraki ders kalıcı olanı sorar: hangi bilginin döngü dışına yazılacağı, yazma kararının kaç kayıt biriktirdiği ve bu kayıtların sonraki görevlerde kaç adım kazandırdığı.