İleri Seviye Yapay Zeka Ajanları
İlk bölümde yapay zeka ajanlarının temel kavramlarını ve basit uygulamalarını incelemiştik. Bu üçüncü bölümde, daha ileri seviye yapay zeka ajanı konseptlerini, teknolojilerini ve uygulamalarını ele alacağız. Özellikle ajanların hafıza yönetimi, daha karmaşık görevlerin çözümü ve çoklu ajan sistemleri üzerinde duracağız.
Günümüzde yapay zeka ajanları, basit görevlerin ötesine geçerek birçok karmaşık sorunu ele alabilecek yeteneklere sahip. Bu bölümde, bu ileri yeteneklerin nasıl geliştirileceğini ve uygulanacağını adım adım inceleyeceğiz.
Gelişmiş Hafıza Sistemleri
İleri seviye ajanlar, basit bilgi depolamanın ötesinde, geçmiş deneyimlerinden öğrenebilen ve bu deneyimleri kullanabilen sistemlere ihtiyaç duyarlar. Bunun için farklı hafıza türleri geliştirilmiştir:
1. Kısa ve Uzun Süreli Hafıza
class AdvancedMemoryAgent:
def __init__(self, name):
self.name = name
self.short_term_memory = [] # Kısa süreli hafıza
self.long_term_memory = {} # Uzun süreli hafıza
self.stm_capacity = 5 # Kısa süreli hafıza kapasitesi
def add_to_short_term_memory(self, item):
"""Kısa süreli hafızaya öğe ekle"""
self.short_term_memory.append(item)
# Kapasite aşıldığında en eski öğeyi çıkar
if len(self.short_term_memory) > self.stm_capacity:
removed_item = self.short_term_memory.pop(0)
# Önemli bilgiyi uzun süreli hafızaya transfer et
if self._is_important(removed_item):
self._transfer_to_long_term_memory(removed_item)
def _is_important(self, item):
"""Bir öğenin önemli olup olmadığını değerlendir"""
# Gerçek uygulamada daha karmaşık bir mantık kullanılabilir
# Örneğin, duygusal değer, tekrar sıklığı, ilişkili bilgi miktarı gibi
return "önemli" in str(item).lower() or "kritik" in str(item).lower()
def _transfer_to_long_term_memory(self, item):
"""Öğeyi uzun süreli hafızaya aktar"""
# Basit bir kategorizasyon
category = self._categorize(item)
if category not in self.long_term_memory:
self.long_term_memory[category] = []
self.long_term_memory[category].append(item)
print(f"{self.name}: '{item}' uzun süreli hafızaya aktarıldı.")
def _categorize(self, item):
"""Öğeyi kategorize et"""
# Basit bir kategorizasyon örneği
if "kişi" in str(item).lower():
return "kişiler"
elif "yer" in str(item).lower():
return "yerler"
elif "tarih" in str(item).lower():
return "tarihler"
else:
return "genel"
def retrieve_from_long_term_memory(self, query):
"""Uzun süreli hafızadan ilgili bilgileri getir"""
results = []
# Basit bir arama mekanizması
for category, items in self.long_term_memory.items():
for item in items:
if query.lower() in str(item).lower():
results.append((category, item))
return results
def think(self, query=None):
"""Mevcut durumu değerlendir ve kararlar al"""
# Kısa süreli hafızadaki en güncel bilgilere öncelik ver
context = self.short_term_memory.copy()
# İlgili uzun süreli hafızadan bilgileri getir
if query:
ltm_results = self.retrieve_from_long_term_memory(query)
context.extend([f"{cat}: {item}" for cat, item in ltm_results])
# Gerçek bir uygulamada burada daha karmaşık bir çıkarım süreci olabilir
if context:
return f"Mevcut bağlam: {context}"
else:
return "Yeterli bilgi yok, daha fazla veri topla."2. Vektör Tabanlı Hafıza
Modern ajanlar, semantik benzerliğe dayalı bilgi erişimi için vektör tabanlı hafıza kullanır. Bu, bilgilerin sayısal vektörler olarak temsil edilmesi ve benzerlik hesaplamasıyla erişilmesi anlamına gelir.
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
class VectorMemoryAgent(AdvancedMemoryAgent):
def __init__(self, name, embedding_model):
super().__init__(name)
self.embedding_model = embedding_model # Metin gömme modeli
self.vector_memory = [] # (metin, vektör) çiftleri
def add_to_vector_memory(self, text):
"""Metni vektör hafızasına ekle"""
# Metinden vektör oluştur
vector = self.embedding_model.encode(text)
self.vector_memory.append((text, vector))
print(f"{self.name}: '{text}' vektör hafızasına eklendi.")
def query_vector_memory(self, query, top_k=3):
"""Sorguya en benzer metinleri bul"""
if not self.vector_memory:
return []
# Sorgu vektörünü oluştur
query_vector = self.embedding_model.encode(query)
# Tüm vektörlerle benzerlik hesapla
similarities = []
for text, vector in self.vector_memory:
similarity = cosine_similarity([query_vector], [vector])[0][0]
similarities.append((text, similarity))
# En benzer top_k öğeyi döndür
similarities.sort(key=lambda x: x[1], reverse=True)
return similarities[:top_k]
# Basit bir gömme modeli simülasyonu
class SimpleEmbedding:
def encode(self, text):
"""Basit bir gömme simülasyonu (gerçek uygulamada daha gelişmiş bir model kullanılır)"""
# Her kelime için rastgele bir vektör oluşturarak basit bir gömme
words = text.lower().split()
# Her kelime için tutarlı rastgele vektör oluşturmak için hash kullan
vectors = [np.array([hash(word) % 100 / 100 for _ in range(10)]) for word in words]
if vectors:
return np.mean(vectors, axis=0)
return np.zeros(10)Çoklu Ajan Sistemleri
Gerçek dünya problemleri genellikle tek bir ajanın çözebileceğinden daha karmaşıktır. Bu nedenle, birden fazla ajanın işbirliği yaparak çalıştığı çoklu ajan sistemleri kullanılır.
1. Temel Çoklu Yapay Zeka Ajanları Mimarisi
class AgentTeam:
def __init__(self, name):
self.name = name
self.agents = {} # ajan_adı: ajan_nesnesi
self.tasks = {} # görev_adı: görev_tanımı
self.coordinator = None
def add_agent(self, agent, role):
"""Ekibe bir ajan ekle"""
self.agents[role] = agent
print(f"{agent.name} ekibe {role} rolüyle eklendi.")
def set_coordinator(self, coordinator_role):
"""Ekip koordinatörünü belirle"""
if coordinator_role in self.agents:
self.coordinator = self.agents[coordinator_role]
print(f"{self.coordinator.name} ekip koordinatörü olarak atandı.")
else:
raise ValueError(f"{coordinator_role} rolünde bir ajan bulunamadı.")
def add_task(self, task_name, task_description, assigned_roles=None):
"""Ekibe bir görev ekle"""
self.tasks[task_name] = {
"description": task_description,
"assigned_roles": assigned_roles or [],
"status": "beklemede",
"result": None
}
print(f"'{task_name}' görevi ekibe eklendi.")
def assign_task(self, task_name, role):
"""Görevi bir role ata"""
if task_name in self.tasks and role in self.agents:
if role not in self.tasks[task_name]["assigned_roles"]:
self.tasks[task_name]["assigned_roles"].append(role)
print(f"'{task_name}' görevi {role} rolüne atandı.")
else:
print(f"Görev veya rol bulunamadı.")
def execute_task(self, task_name):
"""Görevi yürüt"""
if task_name not in self.tasks:
return f"'{task_name}' adında bir görev bulunamadı."
task = self.tasks[task_name]
if not task["assigned_roles"]:
return f"'{task_name}' görevine atanmış rol yok."
task["status"] = "yürütülüyor"
print(f"'{task_name}' görevi yürütülüyor...")
# Tüm atanmış ajanları çağır
results = []
for role in task["assigned_roles"]:
agent = self.agents[role]
# Gerçek uygulamada, ajanlar görev tanımına göre özel işlevler çağırabilir
result = agent.think(task["description"])
results.append(f"{role}: {result}")
task["status"] = "tamamlandı"
task["result"] = results
# Sonuçları birleştir (koordinatör varsa koordinatör tarafından)
if self.coordinator:
final_result = self.coordinator.think(f"Görev: {task['description']}, Sonuçlar: {results}")
else:
final_result = f"Görev sonuçları: {results}"
print(f"'{task_name}' görevi tamamlandı.")
return final_result2. Uzmanlaşmış Yapay Zeka Ajanları
Çoklu ajan sistemlerinde, her ajan belirli bir alanda uzmanlaşabilir:
class ResearchAgent(AdvancedMemoryAgent):
"""Bilgi toplama ve araştırma konusunda uzmanlaşmış ajan"""
def research(self, topic):
print(f"{self.name} şu konuda araştırma yapıyor: {topic}")
# Gerçek bir uygulamada, internet araması yapılabilir veya bir veritabanı sorgulanabilir
return f"{topic} hakkında araştırma sonuçları"
class AnalysisAgent(AdvancedMemoryAgent):
"""Veri analizi konusunda uzmanlaşmış ajan"""
def analyze(self, data):
print(f"{self.name} veri analizi yapıyor")
# Gerçek bir uygulamada, veri analizi algoritmaları kullanılabilir
return f"Analiz sonuçları: {data} içinde önemli kalıplar bulundu"
class DecisionAgent(AdvancedMemoryAgent):
"""Karar verme konusunda uzmanlaşmış ajan"""
def decide(self, options):
print(f"{self.name} karar veriyor")
# Gerçek bir uygulamada, karar verme algoritmaları kullanılabilir
if options:
return f"En iyi seçenek: {options[0]}"
return "Karar vermek için yeterli seçenek yok"
# Çoklu ajan sistemini oluşturma ve kullanma örneği
team = AgentTeam("Araştırma Ekibi")
# Ajanları oluştur ve ekibe ekle
researcher = ResearchAgent("Ali")
analyst = AnalysisAgent("Ayşe")
decision_maker = DecisionAgent("Mehmet")
team.add_agent(researcher, "araştırmacı")
team.add_agent(analyst, "analist")
team.add_agent(decision_maker, "karar_verici")
# Koordinatör belirle
team.set_coordinator("karar_verici")
# Görev ekle ve ata
team.add_task("pazar_araştırması", "Elektrikli araçlar pazarındaki büyüme trendlerini analiz et")
team.assign_task("pazar_araştırması", "araştırmacı")
team.assign_task("pazar_araştırması", "analist")
team.assign_task("pazar_araştırması", "karar_verici")
# Görevi yürüt
result = team.execute_task("pazar_araştırması")
print(f"Sonuç: {result}")LangChain ile Gelişmiş Ajan Zincirleri
LangChain, Yapay Zeka Ajanları arasında karmaşık etkileşimler ve iş akışları oluşturmak için ideal bir araçtır. Şimdi, LangChain kullanarak gelişmiş ajan zincirleri nasıl oluşturulur görelim:
from langchain.llms import OpenAI
from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent
from langchain.prompts import StringPromptTemplate
from langchain.memory import ConversationBufferMemory
import re
# LLM'yi (Dil Modeli) tanımlayın
llm = OpenAI(temperature=0)
# Araçları tanımlayın
tools = [
Tool(
name="Arama",
func=lambda x: f"'{x}' için arama sonuçları",
description="İnternet üzerinde bilgi aramak için kullanılır"
),
Tool(
name="Hesaplama",
func=lambda x: str(eval(x)),
description="Matematiksel hesaplamalar yapmak için kullanılır"
),
Tool(
name="Veritabanı",
func=lambda x: f"'{x}' veritabanı sorgusu sonuçları",
description="Veritabanı sorguları yapmak için kullanılır"
)
]
# Özel bir şablon tanımlayın
class CustomPromptTemplate(StringPromptTemplate):
template = """Bir yapay zeka asistanı olarak görevin kullanıcının isteklerini yerine getirmek.
Aşağıdaki araçlara erişimin var:
{tools}
Kullanıcının isteğini düşünmek için şu adımları izle:
1. Kullanıcının isteğini analiz et
2. Hangi araçları kullanman gerektiğine karar ver
3. Aracı kullan
4. Sonuçları değerlendir
Şimdiye kadar olan konuşma:
{history}
Kullanıcı isteği: {input}
Düşünce süreci:"""
def format(self, **kwargs):
# Araçların açıklamalarını biçimlendir
tools_str = "\n".join([f"{tool.name}: {tool.description}" for tool in kwargs.pop("tools")])
kwargs["tools"] = tools_str
return self.template.format(**kwargs)
# Hafıza tanımlayın
memory = ConversationBufferMemory(memory_key="history")
# Şablonu oluşturun
prompt = CustomPromptTemplate(
template=CustomPromptTemplate.template,
tools=tools,
input_variables=["input", "history"]
)
# Çıktı ayrıştırıcı tanımlayın
def output_parser(text):
# Eylemi ve girdiyi ayrıştır
match = re.search(r"Eylem: (\w+)\nGirdi: (.+)", text, re.DOTALL)
if match:
action = match.group(1)
action_input = match.group(2)
return {"action": action, "action_input": action_input}
else:
return {"action": "Düşünce", "action_input": text}
# Ajanı oluşturun
agent = LLMSingleActionAgent(
llm_chain=prompt,
output_parser=output_parser,
stop=["\nGözlem:"],
allowed_tools=[tool.name for tool in tools]
)
# Ajan yürütücüsü oluşturun
agent_executor = AgentExecutor.from_agent_and_tools(
agent=agent,
tools=tools,
verbose=True,
memory=memory
)
# Ajanı çalıştırın
agent_executor.run("3 ile 4'ün toplamı nedir ve yapay zeka hakkında bilgi arar mısın?")Yapay Zeka Ajanları Bellek Eklentileri ve Bilgi Alımı
Modern ajanlar, büyük miktarda bilgiyi işlemek ve gerektiğinde erişmek için gelişmiş bellek sistemlerine ihtiyaç duyarlar. LangChain, bu amaçla çeşitli bellek eklentileri sunar:
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import CharacterTextSplitter
from langchain.chains import RetrievalQA
# Belge yükleme ve işleme
texts = [
"Yapay zeka, insan zekasını taklit eden ve toplanan verilere göre yinelemeli olarak kendini iyileştirebilen sistemlerdir.",
"Makine öğrenimi, bilgisayarların açıkça programlanmadan öğrenmesini sağlayan yapay zekanın bir alt kümesidir.",
"Derin öğrenme, yapay sinir ağlarını kullanan bir makine öğrenimi tekniğidir.",
"Doğal dil işleme, bilgisayarların insan dilini anlamasını, yorumlamasını ve üretmesini sağlar."
]
# Metin bölücü
text_splitter = CharacterTextSplitter(chunk_size=100, chunk_overlap=0)
docs = text_splitter.create_documents(texts)
# Gömme modeli
embeddings = OpenAIEmbeddings()
# Vektör veritabanı oluştur
db = Chroma.from_documents(docs, embeddings)
# Bilgi alımı zinciri
retriever = db.as_retriever()
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=retriever
)
# Sorgu yapma
query = "Derin öğrenme nedir?"
result = qa_chain.run(query)
print(f"Soru: {query}")
print(f"Cevap: {result}")İleri Seviye Kullanım Örneği: Yazılım Geliştirme Asistanı
Şimdi, öğrendiğimiz tüm konseptleri birleştirerek gerçek bir kullanım örneği oluşturalım: Bir yazılım geliştirme asistanı.
from langchain.llms import OpenAI
from langchain.agents import Tool, initialize_agent, AgentType
from langchain.memory import ConversationBufferMemory
from langchain.tools import BaseTool
# LLM tanımlama
llm = OpenAI(temperature=0.2)
# Hafıza tanımlama
memory = ConversationBufferMemory(memory_key="chat_history")
# Kod analizi aracı
class CodeAnalysisTool(BaseTool):
name = "CodeAnalysis"
description = "Verilen kodu analiz eder ve geliştirilmesi gereken alanları belirler"
def _run(self, code: str) -> str:
# Gerçek bir uygulamada, statik kod analizi, güvenlik taraması gibi işlemler yapılabilir
analysis = f"Kod analizi sonuçları:\n"
analysis += "1. Kod genel olarak iyi yapılandırılmış.\n"
# Basit hata kontrolü
if "import" not in code.lower() and len(code.split("\n")) > 5:
analysis += "2. Gerekli kütüphaneler import edilmemiş olabilir.\n"
if "def " in code.lower() and "docstring" not in code.lower() and '"""' not in code:
analysis += "3. Fonksiyonlar için docstring eksik.\n"
if "try" in code.lower() and "except" not in code.lower():
analysis += "4. Try bloğu var ama exception handling eksik.\n"
return analysis
# Unit test oluşturma aracı
class UnitTestGeneratorTool(BaseTool):
name = "UnitTestGenerator"
description = "Verilen kod için unit test oluşturur"
def _run(self, code: str) -> str:
# Gerçek bir uygulamada, daha sofistike bir test oluşturma sistemi kullanılabilir
# Fonksiyonları tespit etme
functions = []
lines = code.split("\n")
for line in lines:
if line.strip().startswith("def "):
func_name = line.strip()[4:].split("(")[0].strip()
functions.append(func_name)
# Test kodu oluşturma
if not functions:
return "Test oluşturulamadı: Fonksiyon bulunamadı."
test_code = "import unittest\n"
test_code += f"# Test için gerekli importlar\n\n"
test_code += "class TestFunctions(unittest.TestCase):\n"
for func in functions:
test_code += f" def test_{func}(self):\n"
test_code += f" # {func} fonksiyonu için test\n"
test_code += f" result = {func}()\n"
test_code += f" self.assertEqual(result, expected_value) # Beklenen değer ile karşılaştırma\n\n"
test_code += "if __name__ == '__main__':\n"
test_code += " unittest.main()\n"
return test_code
# Kod optimizasyonu aracı
class CodeOptimizationTool(BaseTool):
name = "CodeOptimization"
description = "Verilen kodu optimize eder"
def _run(self, code: str) -> str:
# Gerçek bir uygulamada, kod optimizasyonu algoritmaları kullanılabilir
optimized_code = "# Optimize edilmiş kod\n"
lines = code.split("\n")
for line in lines:
# Basit optimizasyonlar
# List comprehension kullanımı
if "for" in line and "append" in line:
optimized_code += "# Bu döngü list comprehension ile optimize edilebilir\n"
# Gereksiz değişken kontrolü
if "=" in line and line.strip().split("=")[0].strip() not in "\n".join(lines[lines.index(line)+1:]):
optimized_code += "# Bu değişken daha sonra kullanılmıyor olabilir\n"
optimized_code += line + "\n"
optimized_code += "\n# Performans önerileri:\n"
optimized_code += "# 1. Döngüler yerine vektörel işlemler kullanılabilir\n"
optimized_code += "# 2. Gereksiz hesaplamalar döngü dışına alınabilir\n"
return optimized_code
# Araçları tanımlama
tools = [
CodeAnalysisTool(),
UnitTestGeneratorTool(),
CodeOptimizationTool(),
Tool(
name="PythonExecutor",
func=lambda code: "Kod çalıştırma sonucu: [burada gerçek sonuç olurdu]",
description="Python kodunu çalıştırır ve sonucu döndürür"
)
]
# Ajanı oluşturma
dev_assistant = initialize_agent(
tools=tools,
llm=llm,
agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
memory=memory,
verbose=True
)
# Ajanı kullanma örneği
def_code = """
def fibonacci(n):
if n <= 0:
return 0
elif n == 1:
return 1
else:
return fibonacci(n-1) + fibonacci(n-2)
result = fibonacci(10)
print(f"Fibonacci(10): {result}")
"""
query = f"Bu kodu analiz et ve optimize edilmiş bir versiyon öner:\n{def_code}"
response = dev_assistant.run(query)
print(response)
# İkinci bir soru sorma
query2 = "Bu kod için unit testler oluşturabilir misin?"
response2 = dev_assistant.run(query2)
print(response2)Modern Ajan Mimarisi: ReAct ve diğer Yaklaşımlar
ReAct (Reasoning + Acting), ajanların düşünme süreçlerini ve eylemlerini birleştiren güçlü bir yaklaşımdır:
from langchain.agents import load_tools, initialize_agent, AgentType
# LLM ve araçlar
llm = OpenAI(temperature=0)
tools = load_tools(["serpapi", "llm-math"], llm=llm)
# ReAct tabanlı ajan
react_agent = initialize_agent(
tools,
llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True
)
# Örnek sorgu
query = "Türkiye'nin başkentinin nüfusu kaçtır ve bu sayının karekökü nedir?"
result = react_agent.run(query)
print(f"Sonuç: {result}")Yapay Zeka Ajanları Değerlendirilmesi ve İyileştirilmesi
Gelişmiş ajanları değerlendirmek ve iyileştirmek için bazı stratejiler:
def evaluate_agent(agent, test_cases):
"""Bir ajanı test durumlarına göre değerlendir"""
results = []
for i, case in enumerate(test_cases):
print(f"\nTest Durumu {i+1}: {case['query']}")
try:
start_time = time.time()
response = agent.run(case["query"])
end_time = time.time()
execution_time = end_time - start_time
# Cevabı değerlendir
success = any(expected in response for expected in case["expected_keywords"])
results.append({
"query": case["query"],
"response": response,
"success": success,
"execution_time": execution_time
})
print(f"Başarı: {'✓' if success else '✗'}")
print(f"Çalışma Süresi: {execution_time:.2f} saniye")
except Exception as e:
print(f"Hata: {str(e)}")
results.append({
"query": case["query"],
"response": str(e),
"success": False,
"execution_time": -1
})
# Sonuçları özetle
success_count = sum(1 for r in results if r["success"])
success_rate = success_count / len(test_cases) * 100
avg_time = sum(r["execution_time"] for r in results if r["execution_time"] > 0) / len(results)
print(f"\nDeğerlendirme Özeti:")
print(f"Başarı Oranı: {success_rate:.2f}%")
print(f"Ortalama Çalışma Süresi: {avg_time:.2f} saniye")
return results
# Test durumları
test_cases = [
{
"query": "2 + 2 kaçtır?",
"expected_keywords": ["4", "dört"]
},
{
"query": "Türkiye'nin başkenti neresidir?",
"expected_keywords": ["Ankara"]
},
{
"query": "Fibonacci serisinin ilk 5 elemanı nedir?",
"expected_keywords": ["0, 1, 1, 2, 3", "0,1,1,2,3"]
}
]
import time
# Ajanı değerlendir
evaluation_results = evaluate_agent(dev_assistant, test_cases)Yapay zeka ajanlarının etkin çalışması için sürekli değerlendirme ve iyileştirme kritik öneme sahiptir. Bir ajanın gerçek dünya problemlerini ne kadar iyi çözebildiğini anlamak için çeşitli yöntemler kullanabiliriz.
Değerlendirme Metrikleri
# Ajan değerlendirme metrikleri için örnek bir sınıf
class AjanDeğerlendirici:
def __init__(self):
self.görev_tamamlama = []
self.doğruluk_puanları = []
self.verimlilik_metrikleri = []
self.kullanıcı_memnuniyeti = []
def görev_başarısını_ölç(self, ajan, görev_listesi):
başarı_sayısı = 0
for görev in görev_listesi:
sonuç = ajan.görevi_çalıştır(görev)
if sonuç.başarılı:
başarı_sayısı += 1
başarı_oranı = başarı_sayısı / len(görev_listesi)
self.görev_tamamlama.append(başarı_oranı)
return başarı_oranı
def doğruluğu_ölç(self, ajan_yanıtları, gerçek_yanıtlar):
doğruluk = 0
for ajan_yanıt, gerçek_yanıt in zip(ajan_yanıtları, gerçek_yanıtlar):
benzerlik = self.benzerlik_hesapla(ajan_yanıt, gerçek_yanıt)
doğruluk += benzerlik
ortalama_doğruluk = doğruluk / len(ajan_yanıtları)
self.doğruluk_puanları.append(ortalama_doğruluk)
return ortalama_doğruluk
def benzerlik_hesapla(self, yanıt1, yanıt2):
# Burada metinsel benzerlik için bir algoritma kullanılabilir
# Örneğin: cosine similarity, BLEU skoru, vb.
# Basit bir örnek:
return 0.8 # Gerçek uygulamada hesaplanmalı
def rapor_oluştur(self):
return {
"ortalama_görev_tamamlama": sum(self.görev_tamamlama) / len(self.görev_tamamlama),
"ortalama_doğruluk": sum(self.doğruluk_puanları) / len(self.doğruluk_puanları),
"trend": "İyileşiyor" if self.görev_tamamlama[-1] > self.görev_tamamlama[0] else "Kötüleşiyor"
}Değerlendirme sürecinde şu ana metriklere odaklanmalıyız:
- Görev Tamamlama Oranı: Ajanın verilen görevleri doğru şekilde tamamlama yüzdesi
- Doğruluk: Ajanın ürettiği yanıtların veya sonuçların doğruluğu
- Verimlilik: API çağrı sayısı, işlem süresi, bellek kullanımı gibi kaynak tüketimi ölçümleri
- Kullanıcı Memnuniyeti: Gerçek kullanıcılardan alınan geri bildirimler ve puanlamalar
A/B Testleri ve Deneysel Değerlendirme
Farklı ajan konfigürasyonlarını karşılaştırmak için A/B testleri yapabilirsiniz:
# Farklı ajan stratejilerini karşılaştırmak için A/B test fonksiyonu
def ab_test_ajanları(ajan_a, ajan_b, test_senaryoları):
sonuçlar_a = []
sonuçlar_b = []
for senaryo in test_senaryoları:
# İlk ajan için ölçüm
başlangıç_zamanı_a = time.time()
yanıt_a = ajan_a.çalıştır(senaryo)
bitiş_zamanı_a = time.time()
süre_a = bitiş_zamanı_a - başlangıç_zamanı_a
# İkinci ajan için ölçüm
başlangıç_zamanı_b = time.time()
yanıt_b = ajan_b.çalıştır(senaryo)
bitiş_zamanı_b = time.time()
süre_b = bitiş_zamanı_b - başlangıç_zamanı_b
# Sonuçları değerlendir
doğruluk_a = değerlendirme_fonksiyonu(yanıt_a, senaryo.beklenen_yanıt)
doğruluk_b = değerlendirme_fonksiyonu(yanıt_b, senaryo.beklenen_yanıt)
sonuçlar_a.append({"doğruluk": doğruluk_a, "süre": süre_a})
sonuçlar_b.append({"doğruluk": doğruluk_b, "süre": süre_b})
# Sonuçları analiz et
ortalama_doğruluk_a = sum(sonuç["doğruluk"] for sonuç in sonuçlar_a) / len(sonuçlar_a)
ortalama_doğruluk_b = sum(sonuç["doğruluk"] for sonuç in sonuçlar_b) / len(sonuçlar_b)
ortalama_süre_a = sum(sonuç["süre"] for sonuç in sonuçlar_a) / len(sonuçlar_a)
ortalama_süre_b = sum(sonuç["süre"] for sonuç in sonuçlar_b) / len(sonuçlar_b)
return {
"ajan_a": {
"ortalama_doğruluk": ortalama_doğruluk_a,
"ortalama_süre": ortalama_süre_a
},
"ajan_b": {
"ortalama_doğruluk": ortalama_doğruluk_b,
"ortalama_süre": ortalama_süre_b
},
"kazanan": "A" if ortalama_doğruluk_a > ortalama_doğruluk_b else "B"
}Ajanları İyileştirme Teknikleri
Prompt Mühendisliği ve Optimizasyon
Ajanlarınızın performansını artırmak için prompt’ları sürekli geliştirmeniz gerekir:
class PromptOptimizasyonu:
def __init__(self, temel_prompt_şablonu):
self.temel_şablon = temel_prompt_şablonu
self.varyasyonlar = []
self.performans_sonuçları = []
def yeni_varyasyon_ekle(self, değişiklik, açıklama):
yeni_prompt = self.temel_şablon.copy()
# Prompt üzerinde değişiklik yap
for anahtar, değer in değişiklik.items():
if anahtar in yeni_prompt:
yeni_prompt[anahtar] = değer
self.varyasyonlar.append({
"prompt": yeni_prompt,
"açıklama": açıklama
})
def varyasyonları_değerlendir(self, test_verileri, değerlendirme_fonksiyonu):
for idx, varyasyon in enumerate(self.varyasyonlar):
sonuçlar = []
for test in test_verileri:
# Varyasyonu kullanarak ajanı çalıştır
yanıt = ajan_çalıştır(varyasyon["prompt"], test.girdi)
# Sonucu değerlendir
puan = değerlendirme_fonksiyonu(yanıt, test.beklenen)
sonuçlar.append(puan)
ortalama_puan = sum(sonuçlar) / len(sonuçlar)
self.performans_sonuçları.append({
"varyasyon_idx": idx,
"ortalama_puan": ortalama_puan,
"açıklama": varyasyon["açıklama"]
})
def en_iyi_varyasyonu_bul(self):
en_iyi_puan = -1
en_iyi_idx = -1
for sonuç in self.performans_sonuçları:
if sonuç["ortalama_puan"] > en_iyi_puan:
en_iyi_puan = sonuç["ortalama_puan"]
en_iyi_idx = sonuç["varyasyon_idx"]
return {
"en_iyi_prompt": self.varyasyonlar[en_iyi_idx]["prompt"],
"açıklama": self.varyasyonlar[en_iyi_idx]["açıklama"],
"performans": en_iyi_puan
}İnsan Geri Bildirimi ve Güçlendirmeli Öğrenme
İnsan geri bildirimi, ajanları iyileştirmenin etkili bir yoludur. Bu geri bildirimleri yapılandırılmış bir şekilde toplamak ve kullanmak için:
class İnsanGeriBildirimToplayıcı:
def __init__(self):
self.geri_bildirimler = []
def geri_bildirim_al(self, ajan_yanıtı, kullanıcı_değerlendirmesi, etiketler=None):
"""
Kullanıcıdan geri bildirim alır.
Args:
ajan_yanıtı: Ajanın ürettiği çıktı
kullanıcı_değerlendirmesi: 1-5 arasında bir puan
etiketler: Yanıtın güçlü veya zayıf yönlerini belirten etiketler
"""
if etiketler is None:
etiketler = []
self.geri_bildirimler.append({
"yanıt": ajan_yanıtı,
"puan": kullanıcı_değerlendirmesi,
"etiketler": etiketler,
"zaman": datetime.now()
})
def düşük_puanlı_yanıtları_analiz_et(self, eşik=3):
"""Düşük puan alan yanıtları ve bunların ortak özelliklerini analiz eder."""
düşük_puanlı = [gb for gb in self.geri_bildirimler if gb["puan"] <= eşik]
if not düşük_puanlı:
return {"mesaj": "Düşük puanlı yanıt bulunamadı"}
# Ortak etiketleri bul
tüm_etiketler = {}
for gb in düşük_puanlı:
for etiket in gb["etiketler"]:
tüm_etiketler[etiket] = tüm_etiketler.get(etiket, 0) + 1
# En yaygın sorunları bul
yaygın_sorunlar = sorted(tüm_etiketler.items(), key=lambda x: x[1], reverse=True)
return {
"düşük_puanlı_sayısı": len(düşük_puanlı),
"toplam_yanıt_sayısı": len(self.geri_bildirimler),
"düşük_puan_oranı": len(düşük_puanlı) / len(self.geri_bildirimler),
"yaygın_sorunlar": yaygın_sorunlar[:5] # En yaygın 5 sorunu göster
}
def iyileştirme_önerileri_oluştur(self):
"""Geri bildirimlere dayanarak iyileştirme önerileri oluşturur."""
analiz = self.düşük_puanlı_yanıtları_analiz_et()
öneriler = []
if "yaygın_sorunlar" in analiz:
for sorun, sıklık in analiz["yaygın_sorunlar"]:
if sorun == "yanıt_çok_uzun":
öneriler.append("Yanıtları daha kısa ve öz hale getirin")
elif sorun == "yanıt_yanlış":
öneriler.append("Doğruluk kontrolü mekanizmaları ekleyin")
elif sorun == "yavaş_yanıt":
öneriler.append("Yanıt süresini optimize etmek için ara önbellekleme kullanın")
# Diğer olası sorunlar için çözümler...
return önerilerYapay Zeka Ajanları Çok Amaçlı ve Uzmanlaşmış Ajanlar
Karmaşık görevler için, her biri belirli bir alanda uzmanlaşmış çok amaçlı ajan sistemleri oluşturabilirsiniz:
class ÇokAmaçlıAjanSistemi:
def __init__(self):
self.ajanlar = {}
self.orkestratör = None
def yeni_ajan_ekle(self, ajan_id, ajan, uzmanlık_alanları):
"""Sisteme yeni bir uzman ajan ekler."""
self.ajanlar[ajan_id] = {
"ajan": ajan,
"uzmanlık": uzmanlık_alanları
}
def orkestratör_tanımla(self, orkestratör_ajan):
"""Ana koordinatör ajanı belirler."""
self.orkestratör = orkestratör_ajan
def görevi_işle(self, görev):
"""Görevi orkestratöre gönderir ve uygun ajanları atamayı ona bırakır."""
if not self.orkestratör:
raise ValueError("Orkestratör ajan tanımlanmamış")
# Görevin analiziyle başla
görev_analizi = self.orkestratör.görevi_analiz_et(görev)
# Gerekli uzmanlıkları belirle
gereken_uzmanlıklar = görev_analizi["gereken_uzmanlıklar"]
# Uygun ajanları seç
seçilen_ajanlar = []
for ajan_id, ajan_bilgisi in self.ajanlar.items():
for uzmanlık in ajan_bilgisi["uzmanlık"]:
if uzmanlık in gereken_uzmanlıklar:
seçilen_ajanlar.append(ajan_id)
break
# Alt görevleri oluştur ve dağıt
alt_görevler = görev_analizi["alt_görevler"]
ajan_sonuçları = {}
for alt_görev in alt_görevler:
uygun_ajan = self.en_uygun_ajanı_bul(alt_görev, seçilen_ajanlar)
sonuç = self.ajanlar[uygun_ajan]["ajan"].görevi_çalıştır(alt_görev)
ajan_sonuçları[alt_görev["id"]] = sonuç
# Sonuçları birleştir
final_yanıt = self.orkestratör.sonuçları_birleştir(ajan_sonuçları, görev)
return final_yanıt
def en_uygun_ajanı_bul(self, alt_görev, aday_ajanlar):
"""Alt görev için en uygun ajanı seçer."""
en_yüksek_uyumluluk = -1
en_uygun_ajan = None
for ajan_id in aday_ajanlar:
ajan_bilgisi = self.ajanlar[ajan_id]
uyumluluk = 0
# Uzmanlık alanı uyumluluğunu değerlendir
for uzmanlık in ajan_bilgisi["uzmanlık"]:
if uzmanlık in alt_görev["gereken_uzmanlık"]:
uyumluluk += 1
if uyumluluk > en_yüksek_uyumluluk:
en_yüksek_uyumluluk = uyumluluk
en_uygun_ajan = ajan_id
return en_uygun_ajanYapay Zeka Ajanları Hafıza ve Birikimli Öğrenme
Uzun süreli etkileşimlerde ajanların hafızasını geliştirmek için vektör veritabanları ve bilgi grafikleri kullanabilirsiniz:
import numpy as np
from datetime import datetime
class AjanHafızası:
def __init__(self, vektör_boyutu=1536):
self.anılar = []
self.vektör_gömmeleri = []
self.vektör_boyutu = vektör_boyutu
def anı_ekle(self, içerik, meta_veri=None, vektör=None):
"""Ajana yeni bir anı ekler ve vektör gömmesini saklar."""
if meta_veri is None:
meta_veri = {}
zaman_damgası = datetime.now()
# Eğer vektör sağlanmadıysa, varsayılan olarak rastgele bir vektör oluştur
# Not: Gerçek uygulamada, metin gömme API'si kullanarak uygun vektörü oluşturmalısınız
if vektör is None:
vektör = np.random.rand(self.vektör_boyutu)
vektör = vektör / np.linalg.norm(vektör) # Birim vektöre normalize et
anı = {
"içerik": içerik,
"meta_veri": meta_veri,
"zaman_damgası": zaman_damgası,
"erişim_sayısı": 0,
"önem_puanı": 1.0 # Başlangıçta standart önem
}
self.anılar.append(anı)
self.vektör_gömmeleri.append(vektör)
return len(self.anılar) - 1 # Anı indeksi döndür
def semantik_ara(self, sorgu_vektörü, k=5):
"""En benzer k anıyı bulur ve döndürür."""
benzerlikler = []
for idx, vektör in enumerate(self.vektör_gömmeleri):
benzerlik = np.dot(sorgu_vektörü, vektör) # Kosinüs benzerliği
benzerlikler.append((idx, benzerlik))
# En yüksek benzerliğe göre sırala
benzerlikler.sort(key=lambda x: x[1], reverse=True)
en_benzer_anılar = []
for idx, benzerlik in benzerlikler[:k]:
anı = self.anılar[idx].copy()
anı["benzerlik_puanı"] = benzerlik
anı["indeks"] = idx
en_benzer_anılar.append(anı)
# Erişim sayacını artır
self.anılar[idx]["erişim_sayısı"] += 1
return en_benzer_anılar
def anıları_tazele(self, zayıflama_faktörü=0.99, minimum_önem=0.1):
"""Zamanla anıların önemini azaltır ve çok az önemli olanları siler."""
güncel_zaman = datetime.now()
silinecek_indeksler = []
for idx, anı in enumerate(self.anılar):
# Anının yaşını hesapla (gün cinsinden)
yaş = (güncel_zaman - anı["zaman_damgası"]).days
# Zamanla azalan önem faktörü
zaman_faktörü = zayıflama_faktörü ** yaş
# Erişim sayısına göre önem artışı
erişim_faktörü = min(1.0 + (anı["erişim_sayısı"] * 0.1), 2.0)
# Yeni önem puanını hesapla
yeni_önem = anı["önem_puanı"] * zaman_faktörü * erişim_faktörü
self.anılar[idx]["önem_puanı"] = max(yeni_önem, minimum_önem)
# Minimum önemin altına düşen anıları işaretle
if self.anılar[idx]["önem_puanı"] <= minimum_önem and yaş > 30:
silinecek_indeksler.append(idx)
# İşaretli anıları sil (sondan başa doğru)
for idx in sorted(silinecek_indeksler, reverse=True):
del self.anılar[idx]
del self.vektör_gömmeleri[idx]
print(f"{len(silinecek_indeksler)} adet düşük önemli anı temizlendi.")Gerçek Dünya Uygulamaları
Yapay Zeka Ajanları İş Süreçleri Otomasyonu
İş süreçlerini otomatikleştiren ve optimize eden ajanlar oluşturabilirsiniz:
class İşSüreciOtomasyonAjanı:
def __init__(self, süreç_tanımı, araçlar=None):
self.süreç = süreç_tanımı
self.araçlar = araçlar or {}
self.süreç_durumu = "başlatılmadı"
self.mevcut_adım = 0
self.adım_sonuçları = []
def süreci_başlat(self, girdiler):
"""İş sürecini başlatır ve ilk adımı çalıştırır."""
self.süreç_durumu = "devam_ediyor"
self.mevcut_adım = 0
self.adım_sonuçları = []
return self.sonraki_adımı_çalıştır(girdiler)
def sonraki_adımı_çalıştır(self, girdiler):
"""Süreçteki bir sonraki adımı çalıştırır."""
if self.süreç_durumu != "devam_ediyor":
return {"durum": self.süreç_durumu, "mesaj": "Süreç şu anda çalıştırılamaz"}
# Mevcut adımı al
try:
mevcut_adım = self.süreç["adımlar"][self.mevcut_adım]
except IndexError:
self.süreç_durumu = "tamamlandı"
return {"durum": "tamamlandı", "sonuçlar": self.adım_sonuçları}
# Adımı çalıştır
try:
adım_fonksiyonu = getattr(self, f"adım_{mevcut_adım['tip']}")
sonuç = adım_fonksiyonu(mevcut_adım, girdiler)
self.adım_sonuçları.append(sonuç)
# Başarılıysa bir sonraki adıma geç
self.mevcut_adım += 1
# Son adım mı kontrol et
if self.mevcut_adım >= len(self.süreç["adımlar"]):
self.süreç_durumu = "tamamlandı"
return {"durum": "tamamlandı", "sonuçlar": self.adım_sonuçları}
return {"durum": "devam_ediyor", "sonraki_adım": self.mevcut_adım}
except Exception as e:
self.süreç_durumu = "hata"
return {"durum": "hata", "mesaj": str(e)}
def adım_veri_toplama(self, adım, girdiler):
"""Veri toplama adımını gerçekleştirir."""
kaynak = adım.get("veri_kaynağı")
if kaynak not in self.araçlar:
raise ValueError(f"Gerekli veri kaynağı bulunamadı: {kaynak}")
veri_aracı = self.araçlar[kaynak]
toplanan_veri = veri_aracı.veri_topla(adım.get("parametreler", {}))
return {
"adım_tipi": "veri_toplama",
"kaynak": kaynak,
"veri": toplanan_veri
}
def adım_analiz(self, adım, girdiler):
"""Analiz adımını gerçekleştirir."""
analiz_tipi = adım.get("analiz_tipi")
veri = self.son_adımdan_veri_al() or girdiler.get("veri")
if not veri:
raise ValueError("Analiz için veri bulunamadı")
# Analiz aracını seç
analiz_aracı = self.araçlar.get("analiz_motoru")
if not analiz_aracı:
raise ValueError("Analiz motoru bulunamadı")
sonuçlar = analiz_aracı.analiz_yap(veri, analiz_tipi, adım.get("parametreler", {}))
return {
"adım_tipi": "analiz",
"analiz_tipi": analiz_tipi,
"sonuçlar": sonuçlar
}
def adım_rapor_oluşturma(self, adım, girdiler):
"""Rapor oluşturma adımını gerçekleştirir."""
şablon = adım.get("rapor_şablonu")
analiz_sonuçları = self.önceki_adımları_bul("analiz")
if not analiz_sonuçları:
raise ValueError("Rapor için analiz sonuçları bulunamadı")
# Rapor oluşturma aracını seç
rapor_aracı = self.araçlar.get("rapor_oluşturucu")
if not rapor_aracı:
raise ValueError("Rapor oluşturucu bulunamadı")
rapor = rapor_aracı.rapor_oluştur(şablon, analiz_sonuçları)
return {
"adım_tipi": "rapor_oluşturma",
"rapor": rapor
}
def son_adımdan_veri_al(self):
"""Son adımın sonucundan veri alır."""
if not self.adım_sonuçları:
return None
son_sonuç = self.adım_sonuçları[-1]
return son_sonuç.get("veri") or son_sonuç.get("sonuçlar")
def önceki_adımları_bul(self, adım_tipi):
"""Belirli tipteki önceki adımların sonuçlarını bulur."""
sonuçlar = []
for sonuç in self.adım_sonuçları:
if sonuç.get("adım_tipi") == adım_tipi:
sonuçlar.append(sonuç)
return sonuçlar
