--- title: 'Ajan Nedir' source: 'https://academia.sh/tr/kurslar/yapay-zeka-ajanlari/ajan-nedir' course: 'Yapay Zekâ Ajanları' language: tr updated: '2026-08-17T18:06:31+00:00' license: 'CC BY-SA 4.0' --- # Ajan Nedir Model, araç ve döngünün birleşiminin kurulması ve tek bir yanıt yerine bütün döngünün sayılması: 24 kurgu görevde tek adımlı araçsız çağrı 0,0417 görev başarımı verirken sekiz adım bütçeli döngü 0,9583 veriyor, ikinci koşumda taban 0,0000'a inip döngü 0,9583'te kalıyor. Bedel 24 adımdan 97 adıma, sıfır araç çağrısından 74 çağrıya, 1440 belirteçten 11978 belirtece ve sıfırdan 8 araç hatasına çıkmaktır. Tür bazında okunduğunda üç adımlı ve daha kısa görevlerde döngü hepsini bitiriyor, dört adımlı yazma görevlerinde üçte ikisinde kalıyor: başarımın düştüğü yer adım derinliğidir. Ajan öğrenmez; koşum boyunca değişen tek şey elindeki gözlemlerdir. 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. ```python # 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. ```python 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.