Ajan Nedir

Erişim Artırılmış Üretim kursu on altı derste tek bir soruyu ölçtü: modele hangi bilginin gireceği. Parçalama, gömme, erişim ve yeniden sıralama o seçimin ayarlarıydı ve her ayarın bedeli belirteçle yazıldı. Ama o hattın iki sessiz varsayımı vardı. Seçimi hep biz yaptık: hangi parçanın getirileceğine kod karar verdi, model yalnız getirileni okudu. Ve hat tek geçişliydi: istek geldi, bağlam kuruldu, bir yanıt üretildi, iş bitti.

Bu kurs iki varsayımı da kaldırır. Modelin kendisi hangi aracı çağıracağına karar verir, aracın döndürdüğü sonucu görür ve yetersiz bulduğunda başka bir araç dener. Ortaya çıkan şey tek bir yanıt değil bir döngüdür, ve ölçülebilir yüzeyi de tek bir yanıtın değil bütün döngünün yüzeyidir. Bu ders o döngüyü kurar. Döngünün nerede duracağı ayrı bir sorudur ve dördüncü derse kadar açık kalır.

• AM1. Kod bir benzeticidir ve ortam kurgudur: ölçüm ağının kurgu abone kayıtları ve kurgu belge dağarcığı. Gerçek bir model uç noktası, gerçek bir araç sunucusu ya da gerçek bir çalışma zamanı çağrılmaz. Tohum 20260218, ikinci koşum 20260219.
• AM2. Ortam 60 kurgu abone, beş bölge, iki abone tipi ve 5 kurgu belge taşır.
• AM3. Araç kümesi beş araçtır ve her araç yalnız bildirdiği alanları görür; şema dışındaki alanlar süzülür, eksik alan aracın kendi hatasıdır.
• AM4. Görev kümesi 24 görevdir ve her görev bilinen bir araç dizisiyle çözülür. Dört tür vardır: belge (bir adım), tüketim (iki adım), bedel (üç adım), kayıt (dört adım).
• AM5. Doğru aracı seçme payı derinlikle düşer. Birinci adımda 0,80, sonra her adımda 0,09 azalır ve 0,34’te taban yapar. Yanlış seçim beş araçtan rastgele biridir.
• AM6. Gözlemler bir durum sözlüğünde birikir; bir sonraki aracın girdisi önceki adımın çıktısıdır.
• AM7. İş bittiğinde ajan 0,88 payla durur; kalan payda dolaşmaya devam eder ve biriken sonucu bozabilir.
• AM8. kayit_yaz yan etkili tek araçtır ve onay açıkken her çağrısı bir onay noktası sayar.
• AM9. Görev başarımı yanıtın doğruluğudur: döngünün ürettiği son sonuç, görevin bilinen doğru yanıtına eşit mi.
• AM10. Taban çizgisi tek adımlı, araçsız çağrıdır. Model yalnız istek metnini görür.
• AM11. Sayılan birimler adım, araç çağrısı, belirteç, araç hatası ve görev başarımıdır. Süre yazılmaz.
• AM12. Her ölçüm iki tohumla koşulur; iki koşum farkının altında kalan fark ölçülmemiş sayılır.

Model, Araç ve Döngü

Bir ajan üç parçanın birleşimidir. Model her adımda ne yapılacağına karar verir. Araç modelin dışarıya uzanan tek elidir: bir kayda bakmak, bir hesap yapmak, bir satır yazmak. Döngü ikisini bağlayan denetim akışıdır — model bir araç seçer, araç çalışır, sonucu bir gözlem olarak geri döner ve model bir sonraki adımda o gözlemi de görür.

Üçünden biri eksikse ortada ajan yoktur. Modelsiz döngü sabit bir betiktir. Döngüsüz araç, Model API’leri ile Uygulama Geliştirme kursunda ölçülen tek araç çağrısıdır: o ders çağrının biçimini saydı, bu kurs çağrıların dizisini sayar. Araçsız model ise tek geçişli bir çağrıdır ve bu dersin taban çizgisi tam olarak odur.

Makine Öğrenmesi kursunun pekiştirmeli öğrenme konusu da bir ajandan söz eder; oradaki ajan deneyimden öğrenir ve davranışı koşumdan koşuma değişir, buradaki ajan ise öğrenmez — koşum boyunca değişen tek şey elindeki gözlemlerdir.

Kurgu Ortam, Araç Kümesi ve Döngü

Aşağıdaki kod ortamı, beş aracı, yirmi dört görevi ve ajan döngüsünü kurar. Kurs boyunca aynı tanım kullanılır.

# BENZETICI -- KURGUDUR. Gercek bir model ucu, arac sunucusu ya da calisma
# zamani cagrilmaz; ortam da araclar da gorevler de kurgudur.
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)}


g = GOREV[0]
s = ajan(g)
print(f"ortam : {len(ABONE)} abone , {len(BELGE)} belge , {len(ARAC)} arac ,"
      f" {len(GOREV)} gorev")
print(f"{g['ad']} ({g['tur']}) : {g['istek']}")
print("  iz    :", " -> ".join(f"{a}{' [hata]' if h else ''}" for a, h in s["iz"]))
print(f"  yanit {s['yanit']}  dogru {dogru_yanit(g)}  adim {s['adim']}"
      f"  belirtec {s['belirtec']}  arac hatasi {s['hata']}")

ortam : 60 abone , 5 belge , 5 arac , 24 gorev
G01 (belge) : sayac donusunde endeks farki nasil hesaplanir
  iz    : tuketim [hata] -> kayit_yaz [hata] -> belge_ara
  yanit SY01  dogru SY01  adim 4  belirtec 462  arac hatasi 2

Tek bir iz döngünün bütün mekaniğini gösteriyor. Görev tek adımlıktır: belge_ara bir kez çağrılsa yeter. Ajan ilk iki adımda başka araçlara uzanıyor ve ikisi de araç hatası veriyor, çünkü durum sözlüğünde o araçların bildirdiği alanlar yok. Üçüncü adımda doğru aracı buluyor, dördüncü adımda duruyor. Tek adımlık iş dört adım ve 462 belirteç tuttu. Bir yanıtın sayısına bakan bir ölçüm bu üç adımı hiç görmez.

Tek Adımlı Araçsız Çağrı ile Döngünün Sayısı

Taban çizgisi araçsızdır: model yalnız istek metnini görür, hiçbir araç çağrılmaz ve geri hiçbir gözlem gelmez. Aynı yirmi dört görev iki kurulumda ve iki tohumda koşturulur.

def tek_adim(g, tohum=TOHUM):
    """TABAN CIZGISI: tek adimli, ARACSIZ cagri; hicbir arac cagrilmaz."""
    r = uretec(tohum ^ izno("taban" + g["ad"]))
    yanit = (list(BELGE)[int(r() * len(BELGE))] if g["tur"] == "belge"
             else 10 + int(r() * 900))
    return {"adim": 1, "belirtec": 60, "hata": 0, "yanit": yanit}


def olc(kur, tohum=TOHUM):
    CAGRI[0] = 0
    bas = adim = bel = hata = 0
    for g in GOREV:
        s = kur(g, tohum)
        adim, bel, hata = adim + s["adim"], bel + s["belirtec"], hata + s["hata"]
        bas += s["yanit"] == dogru_yanit(g)
    return bas / len(GOREV), adim, CAGRI[0], bel, hata


def dongu(g, tohum):
    return ajan(g, en_cok_adim=8, tohum=tohum)


print("kurulum          basarim A  basarim B   adim  cagri  belirtec  hata")
for ad, kur in (("tek adim aracsiz", tek_adim), ("ajan dongusu", dongu)):
    a, b = olc(kur), olc(kur, TOHUM + 1)
    print(f"{ad:<16} {a[0]:>9.4f} {b[0]:>10.4f} {a[1]:>6} {a[2]:>6} {a[3]:>9} {a[4]:>5}")
print("dongu , tur bazinda :", " , ".join(
    f"{t} {sum(ajan(g)['yanit'] == dogru_yanit(g) for g in GOREV if g['tur'] == t)}"
    f"/{sum(g['tur'] == t for g in GOREV)}"
    for t in ("belge", "tuketim", "bedel", "kayit")))

kurulum          basarim A  basarim B   adim  cagri  belirtec  hata
tek adim aracsiz    0.0417     0.0000     24      0      1440     0
ajan dongusu        0.9583     0.9583     97     74     11978     8
dongu , tur bazinda : belge 7/7 , tuketim 8/8 , bedel 6/6 , kayit 2/3

Taban çizgisi neredeyse sıfırdır ve niçin sıfır olduğu tanımın kendisinde yazılıdır: sayaç endeksleri ortamdadır, istek metninde değildir. Araçsız çağrı bir sayı üretebilir ama o sayı tahmindir. İlk koşumdaki 0,0417 tek bir isabetten gelir ve o isabet de bir belge kodu tahminidir; ikinci koşumda 0,0000‘a iniyor. İki koşum farkı taban çizgisinde 0,0417’dir, yani taban çizgisinin tek başarısı ölçüm bandının içindedir ve bir yetenek sayılmaz.

Döngü aynı görev kümesinde 0,9583 veriyor ve bu sayı iki koşumda da aynı. Fark 0,9166’dır ve bandın yirmi katı üstündedir; bu kazanç ölçülmüştür. Bedeli aynı satırda durur: adım 24’ten 97’ye (4,04 kat), araç çağrısı sıfırdan 74’e, belirteç 1440’tan 11978’e (8,32 kat) ve araç hatası sıfırdan 8’e. Araçsız bir çağrının araç hatası olamaz; hata sayısı sıfırdan büyükse ortada bir döngü var demektir.

Son satır kazancın nerede bittiğini gösteriyor. Bir, iki ve üç adımlık görevlerin hepsi tamamlanıyor. Dört adımlık kayıt görevlerinde üç görevden ikisi doğru. Doğru aracı seçme payı derinlikle düştüğü için, dizi uzadıkça bir adımı ıskalama olasılığı birikiyor. Üç görevlik bir alt kümede 2/3 ile 3/3 arasındaki fark kendi başına bir bulgu değildir; ama düşüşün hangi eksende olduğunu söylüyor ve o eksen adım derinliğidir.

Özet

• Bir ajan model, araç ve döngünün birleşimidir; döngüsüz araç tek bir araç çağrısı, araçsız model tek geçişli bir çağrıdır.
• Ortam, beş araç, yirmi dört görev ve döngü ders içinde standart kitaplıkla kurulur ve hepsi kurgudur; gerçek bir model ucu ya da araç sunucusu çağrılmaz.
• Tek adımlı araçsız çağrı 0,0417 görev başarımı veriyor, ikinci koşumda 0,0000; bu tek isabet ölçüm bandının içindedir ve bir yetenek sayılmaz.
• Sekiz adım bütçeli döngü iki koşumda da 0,9583 veriyor; kazanç 0,9166 ile bandın kat kat üstündedir.
• Bedel adımda 24’ten 97’ye, araç çağrısında sıfırdan 74’e, belirteçte 1440’tan 11978’e ve araç hatasında sıfırdan 8’e çıkmaktır.
• Tür bazında bir, iki ve üç adımlık görevlerin hepsi tamamlanıyor, dört adımlık yazma görevlerinde üçte ikisi tamamlanıyor.

Sonraki Adım

Bu derste döngü bir kutu olarak ölçüldü: giren görev, çıkan yanıt ve aradaki toplam bedel. Kutunun içi tek bir izde göründü ve o iz iki yanlış araç seçimi taşıyordu. Tür bazındaki son satır da aynı yöne işaret ediyor: iş uzadıkça başarım düşüyor. Sonraki ders döngünün içini adım adım açar — her adımın algı, akıl yürütme, eylem ve gözlem olarak hangi parçaya karşılık geldiğini yazar ve doğru araç seçme payını adım derinliğine göre sayar. Aynı sayı dört görev türünde ayrı ayrı okunur, çünkü türlerin dizi uzunlukları farklıdır ve düşüşün tek bir ortalamada saklandığı yer tam da budur.