Giriş: Yapay Zeka Ajanları Nedir?
Günümüzde yapay zeka teknolojileri hızla gelişirken, “AI Ajanları” veya “Yapay Zeka Ajanları” kavramı da giderek daha fazla önem kazanıyor. Yapay zeka ajanları, belirli görevleri yerine getirmek için tasarlanmış, çevrelerini algılayabilen, kararlar alabilen ve bu kararları uygulayabilen yapay zeka sistemleridir.
Bu yazı serisinin ilk bölümünde, yapay zeka ajanlarının temel kavramlarını, çalışma prensiplerini ve uygulamalarını inceleyeceğiz. Hem teorik bilgileri hem de pratik yaklaşımları ele alarak, sıfırdan başlayıp uzmanlaşmaya giden yolda sizlere rehberlik edeceğiz.
Yapay Zeka Ajanlarının Temel Özellikleri
Bir yapay zeka ajanı şu temel özelliklere sahiptir:
- Özerklik: Kendi başına çalışabilme ve karar alabilme yeteneği
- Çevresel Farkındalık: Çevresini algılayabilme ve değişikliklere tepki verebilme
- Hedef Odaklılık: Belirli bir amacı gerçekleştirmek için çalışma
- Rasyonellik: Hedeflerine en iyi şekilde ulaşmak için mantıklı kararlar alma
- Adaptasyon: Yeni durumlara uyum sağlayabilme
Yapay Zeka Ajanlarının Mimari Yapısı
Temel bir yapay zeka ajanı mimarisi genellikle şu bileşenlerden oluşur:
- Algılayıcılar (Sensors): Ajanın çevresinden bilgi toplamasını sağlayan bileşenler
- Bilgi Tabanı (Knowledge Base): Ajanın sahip olduğu bilgilerin depolandığı yer
- Çıkarım Motoru (Inference Engine): Bilgi tabanındaki bilgileri kullanarak yeni bilgiler türeten sistem
- Karar Verme Mekanizması: Toplanan bilgilere dayanarak en iyi eylemi seçen bileşen
- Eyleyiciler (Actuators): Ajanın kararlarını eyleme dönüştüren bileşenler
Python ile Basit Bir Ajan Oluşturma
Şimdi, temel bir yapay zeka ajanının Python ile nasıl oluşturulabileceğini görelim:
class BasicAgent:
def __init__(self, name):
self.name = name
self.knowledge_base = {} # Bilgi tabanı
self.goals = [] # Hedefler listesi
def perceive(self, environment):
"""Çevreden algılanan bilgileri işleme"""
# Çevreden algılanan bilgileri bilgi tabanına ekleyin
for key, value in environment.items():
self.knowledge_base[key] = value
print(f"{self.name} çevreyi algıladı: {environment}")
def think(self):
"""Bilgi tabanını kullanarak karar verme"""
# Basit bir düşünme mantığı
if not self.knowledge_base:
return "Daha fazla bilgi topla"
# Hedeflerinize göre karar verme mantığı
for goal in self.goals:
if goal["type"] == "find" and goal["target"] in self.knowledge_base:
return f"{goal['target']} bulundu: {self.knowledge_base[goal['target']]}"
return "Hedeflere ulaşmak için daha fazla bilgi gerekiyor"
def act(self, decision):
"""Kararı eyleme dönüştürme"""
print(f"{self.name} şu kararı aldı: {decision}")
return {"action": "execute_decision", "decision": decision}
def add_goal(self, goal_type, target):
"""Ajana yeni bir hedef ekleme"""
self.goals.append({"type": goal_type, "target": target})
print(f"{self.name} için yeni hedef eklendi: {goal_type} {target}")
def run_cycle(self, environment):
"""Ajanın algılama-düşünme-eylem döngüsünü çalıştırma"""
self.perceive(environment)
decision = self.think()
return self.act(decision)Bu basit ajan sınıfını şu şekilde kullanabiliriz:
# Bir ajan oluşturalım
agent = BasicAgent("AI Asistan")
# Ajana hedefler ekleyelim
agent.add_goal("find", "hava_durumu")
# Çevre bilgisi oluşturalım
environment = {
"saat": "14:30",
"hava_durumu": "güneşli",
"sıcaklık": 25
}
# Ajanı çalıştıralım
result = agent.run_cycle(environment)
print(f"Sonuç: {result}")Çıktı:
AI Asistan için yeni hedef eklendi: find hava_durumu
AI Asistan çevreyi algıladı: {'saat': '14:30', 'hava_durumu': 'güneşli', 'sıcaklık': 25}
AI Asistan şu kararı aldı: hava_durumu bulundu: güneşli
Sonuç: {'action': 'execute_decision', 'decision': 'hava_durumu bulundu: güneşli'}Yapay Zeka Ajanlarının Türleri
Yapay zeka ajanları, işlevlerine ve davranışlarına göre farklı kategorilere ayrılır:
1. Reaktif Ajanlar
Sadece mevcut duruma tepki veren, geçmiş deneyimleri olmayan basit ajanlardır. Uyaranlara doğrudan tepki verirler.
class ReactiveAgent(BasicAgent):
def think(self):
"""Sadece mevcut algılara tepki ver"""
if "tehlike" in self.knowledge_base and self.knowledge_base["tehlike"] == True:
return "Tehlikeden kaç!"
elif "yiyecek" in self.knowledge_base and self.knowledge_base["yiyecek"] == True:
return "Yiyeceğe doğru git"
else:
return "Etrafta dolaş"2. Model Tabanlı Ajanlar
İçsel bir dünya modeli oluşturan ve bu modeli kullanarak karar veren ajanlardır.
class ModelBasedAgent(BasicAgent):
def __init__(self, name):
super().__init__(name)
self.world_model = {} # İçsel dünya modeli
def update_model(self):
"""Bilgi tabanını kullanarak dünya modelini güncelle"""
# Bilgi tabanından dünya modelini oluştur
for key, value in self.knowledge_base.items():
self.world_model[key] = value
# Basit çıkarımlar yap
if "yağmur" in self.world_model and self.world_model["yağmur"] == True:
self.world_model["zemin"] = "ıslak"
def think(self):
self.update_model()
# Dünya modelini kullanarak karar ver
if "zemin" in self.world_model and self.world_model["zemin"] == "ıslak":
return "Dikkatli yürü, zemin kaygan olabilir"
return super().think()3. Hedef Tabanlı Ajanlar
Belirli hedeflere ulaşmak için planlama yapan ajanlardır.
class GoalBasedAgent(BasicAgent):
def __init__(self, name):
super().__init__(name)
self.current_plan = [] # Planlar listesi
def plan(self):
"""Hedeflere ulaşmak için plan oluştur"""
# Basit bir planlama örneği
for goal in self.goals:
if goal["type"] == "ulaş" and "konum" in self.knowledge_base:
start = self.knowledge_base["konum"]
end = goal["target"]
# Basit bir yol planı (gerçekte daha karmaşık olur)
self.current_plan = [
f"{start}'dan çık",
f"{end}'e doğru ilerle",
f"{end}'e ulaş"
]
return True
return False
def think(self):
# Plan yoksa yeni plan oluştur
if not self.current_plan:
self.plan()
# Plan varsa planın bir sonraki adımına geç
if self.current_plan:
return self.current_plan.pop(0)
return super().think()4. Öğrenen Yapay Zeka Ajanları
Deneyimlerinden öğrenen ve davranışlarını zaman içinde iyileştiren ajanlardır.
class LearningAgent(BasicAgent):
def __init__(self, name):
super().__init__(name)
self.experiences = [] # Deneyimler listesi
self.rules = {} # Öğrenilen kurallar
def learn_from_experience(self, state, action, result):
"""Deneyimlerden öğrenme"""
self.experiences.append({
"state": state,
"action": action,
"result": result
})
# Basit bir kural çıkarımı
key = f"{state}_{action}"
if key not in self.rules:
self.rules[key] = []
self.rules[key].append(result)
def think(self):
# Mevcut durumu belirle
current_state = "_".join([f"{k}:{v}" for k, v in self.knowledge_base.items()])
# Önceki deneyimlere dayanarak en iyi eylemi seç
best_action = None
best_score = -1
for key, results in self.rules.items():
if key.startswith(current_state):
action = key.split('_')[1]
success_rate = sum(1 for r in results if r == "başarılı") / len(results)
if success_rate > best_score:
best_score = success_rate
best_action = action
if best_action:
return best_action
return super().think()LangChain ile Daha Gelişmiş Ajanlar Oluşturma
LangChain, dil modelleri kullanarak daha karmaşık ajanlar oluşturmak için popüler bir kütüphanedir. Şimdi LangChain kullanarak basit bir ajan nasıl oluşturulur görelim:
from langchain.llms import OpenAI
from langchain.agents import initialize_agent, Tool
from langchain.agents import AgentType
from langchain.tools import BaseTool
# OpenAI API anahtarınızı ayarlayın
import os
os.environ["OPENAI_API_KEY"] = "sizin_api_anahtariniz"
# LLM'yi (Dil Modeli) tanımlayın
llm = OpenAI(temperature=0)
# Araçları tanımlayın
tools = [
Tool(
name="Hesap Makinesi",
func=lambda x: eval(x),
description="Matematiksel hesaplamalar yapmak için kullanılır"
),
Tool(
name="Tarih",
func=lambda _: "Bugünün tarihi: 21 Nisan 2023",
description="Bugünün tarihini öğrenmek için kullanılır"
)
]
# Ajanı başlatın
agent = initialize_agent(
tools,
llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True
)
# Ajanı çalıştırın
agent.run("3 ile 7'nin toplamı nedir ve bugün hangi tarih?")Bu kod, LangChain kullanarak OpenAI’nin dil modeliyle çalışan bir ajan oluşturur. Bu ajan, matematiksel hesaplamalar yapabilir ve bugünün tarihini söyleyebilir.
Yapay Zeka Ajanları ile Özel Araçlar Oluşturma
LangChain ile kendi özel araçlarınızı da oluşturabilirsiniz:
from langchain.tools import BaseTool
class HavaDurumuTool(BaseTool):
name = "HavaDurumu"
description = "Belirli bir şehirdeki hava durumunu öğrenmek için kullanılır"
def _run(self, şehir: str) -> str:
# Gerçek bir uygulamada, burada bir hava durumu API'si kullanılabilir
hava_durumu_verileri = {
"İstanbul": "Güneşli, 25°C",
"Ankara": "Parçalı bulutlu, 20°C",
"İzmir": "Açık, 28°C"
}
return hava_durumu_verileri.get(şehir, f"{şehir} için hava durumu bilgisi bulunamadı.")
def _arun(self, şehir: str):
# Asenkron versiyonu (bu örnekte aynı)
return self._run(şehir)
# Yeni aracı araçlar listesine ekleyin
tools.append(HavaDurumuTool())
# Ajanı güncelleyin
agent = initialize_agent(
tools,
llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True
)
# Yeni ajanı çalıştırın
agent.run("İstanbul'da hava durumu nasıl?")AutoGPT Benzeri Yapay Zeka Ajanları Oluşturma
AutoGPT, kendi hedeflerini belirleyen ve bu hedeflere ulaşmak için kendi başına hareket eden daha gelişmiş bir ajan türüdür. Basitleştirilmiş bir AutoGPT benzeri ajan şu şekilde oluşturulabilir:
class AutoGPTAgent:
def __init__(self, llm, tools, goal):
self.llm = llm
self.tools = {tool.name: tool for tool in tools}
self.goal = goal
self.memory = []
self.thoughts = []
def add_to_memory(self, item):
"""Bellekte bir öğe ekle"""
self.memory.append(item)
# Bellek boyutunu sınırla
if len(self.memory) > 10:
self.memory = self.memory[-10:]
def generate_thoughts(self):
"""Düşünceleri üret"""
memory_str = "\n".join([f"- {item}" for item in self.memory])
prompt = f"""
Hedefin: {self.goal}
Mevcut bellek:
{memory_str}
Kullanılabilir araçlar:
{', '.join(self.tools.keys())}
Düşün: Bu hedefe ulaşmak için ne yapmalıyım? Hangi adımları izlemeliyim?
"""
# LLM'i kullanarak düşünce üret
thought = self.llm(prompt)
self.thoughts.append(thought)
return thought
def select_tool(self):
"""Kullanılacak aracı seç"""
tools_str = "\n".join([f"- {name}: {tool.description}" for name, tool in self.tools.items()])
prompt = f"""
Hedefin: {self.goal}
Son düşünce: {self.thoughts[-1] if self.thoughts else 'Henüz düşünce yok.'}
Kullanılabilir araçlar:
{tools_str}
Hangi aracı kullanmalısın? Aracın adını ve argümanları şu formatta yaz:
Araç: <araç_adı>
Argümanlar: <argümanlar>
"""
# LLM'i kullanarak araç seçimi yap
response = self.llm(prompt)
# Yanıtı ayrıştır
try:
lines = response.strip().split('\n')
tool_name = lines[0].split(':', 1)[1].strip()
args = lines[1].split(':', 1)[1].strip()
return tool_name, args
except:
return None, None
def execute_tool(self, tool_name, args):
"""Seçilen aracı çalıştır"""
if tool_name in self.tools:
try:
result = self.tools[tool_name]._run(args)
return result
except Exception as e:
return f"Hata: {str(e)}"
return f"{tool_name} adında bir araç bulunamadı."
def run(self, iterations=5):
"""Belirli sayıda yineleme için ajanı çalıştır"""
for i in range(iterations):
print(f"\n--- İterasyon {i+1} ---")
# Düşünce üret
thought = self.generate_thoughts()
print(f"Düşünce: {thought}")
# Araç seç
tool_name, args = self.select_tool()
print(f"Seçilen araç: {tool_name}")
print(f"Argümanlar: {args}")
# Aracı çalıştır
if tool_name:
result = self.execute_tool(tool_name, args)
print(f"Sonuç: {result}")
self.add_to_memory(f"Araç '{tool_name}' kullanıldı. Sonuç: {result}")
else:
print("Geçerli bir araç seçilemedi.")
# Son düşünceyi döndür
return self.thoughts[-1] if self.thoughts else "Hiçbir düşünce üretilmedi."
# AutoGPT benzeri ajanı oluşturma
goal = "İstanbul'daki hava durumunu öğren ve 5 ile 3'ün toplamını hesapla"
auto_agent = AutoGPTAgent(llm, tools, goal)
final_thought = auto_agent.run(iterations=3)
print(f"\nSon düşünce: {final_thought}")Yapay Zeka Ajanları Geliştirme İpuçları
Kendi yapay zeka ajanlarınızı geliştirirken aşağıdaki ipuçlarını göz önünde bulundurabilirsiniz:
- Açık ve Net Hedefler: Ajanınızın hedeflerini açık ve net bir şekilde tanımlayın
- Modüler Yapı: Ajanınızı modüler bir şekilde tasarlayın, böylece bileşenleri kolayca değiştirebilirsiniz
- Yeterli Bilgi: Ajanınızın görevlerini yerine getirebilmesi için yeterli bilgiye sahip olduğundan emin olun
- Hata Yönetimi: Ajanınızın hataları ele alabilmesi için sağlam hata yönetimi mekanizmaları ekleyin
- Test ve Değerlendirme: Ajanınızı farklı senaryolarla test edin ve performansını değerlendirin
Sonuç
Bu yazıda, yapay zeka ajanlarının temel kavramlarını, türlerini ve Python ile nasıl oluşturulabileceklerini inceledik. Basit bir ajandan başlayarak, daha karmaşık ajanların nasıl oluşturulabileceğini adım adım gördük.
Yapay zeka ajanları, günümüzde otomatik asistanlardan robotlara, akıllı ev sistemlerinden endüstriyel uygulamalara kadar birçok alanda kullanılmaktadır. Bu ajanların gelişimi, yapay zeka teknolojilerindeki ilerlemelerle birlikte hızla devam etmektedir.
Serinin bir sonraki bölümünde, yapay zeka ajanlarının daha karmaşık görevleri nasıl yerine getirebileceğini ve gerçek dünya uygulamalarını inceleyeceğiz.