Yapay zeka ajanları serimizin ilk bölümünde temel kavramları ve basit ajan yapılarını ele almıştık. Bu ikinci bölümde, daha gelişmiş yapay zeka ajanı türlerini, bunların nasıl çalıştığını ve Python ile pratik uygulamalarını inceleyeceğiz.
Yapay Zeka Ajanları Türleri
1. Basit Refleks Ajanları
En temel yapay zeka ajanı türüdür. Mevcut durumu algılar ve önceden tanımlanmış kurallara göre hareket eder.
class SimpleReflexAgent:
def __init__(self, rules):
self.rules = rules # Durum-hareket eşleştirmeleri
def perceive_and_act(self, current_state):
for condition, action in self.rules:
if condition(current_state):
return action
return None # Eşleşme yoksa hareketsiz kal
# Örnek kullanım
rules = [
(lambda state: state['weather'] == 'rainy', 'take_umbrella'),
(lambda state: state['temperature'] < 15, 'wear_jacket')
]
agent = SimpleReflexAgent(rules)
current_state = {'weather': 'rainy', 'temperature': 10}
print(agent.perceive_and_act(current_state)) # Çıktı: take_umbrella2. Model Tabanlı Refleks Ajanları
Bu ajanlar, içsel bir dünya modelini korur ve geçmiş durumları hatırlayarak daha akıllı kararlar verebilir.
class ModelBasedReflexAgent:
def __init__(self, rules, initial_state):
self.rules = rules
self.state = initial_state
self.history = []
def update_state(self, new_perception):
self.history.append(self.state.copy())
# Durumu güncelleme mantığı buraya gelir
self.state.update(new_perception)
def act(self):
for condition, action in self.rules:
if condition(self.state):
return action
return None
# Örnek kullanım
initial_state = {'battery_level': 100, 'location': 'home'}
rules = [
(lambda s: s['battery_level'] < 20, 'return_to_charge'),
(lambda s: s['location'] == 'home' and s['battery_level'] < 100, 'charge')
]
agent = ModelBasedReflexAgent(rules, initial_state)
agent.update_state({'battery_level': 15})
print(agent.act()) # Çıktı: return_to_charge3. Hedef Tabanlı Ajanlar
Belirli hedeflere ulaşmak için hareket eden bu ajanlar, farklı eylemleri değerlendirerek en uygun olanı seçer.
class GoalBasedAgent:
def __init__(self, goals):
self.goals = goals
self.actions = []
def plan(self, current_state):
# Basit bir planlama algoritması
plan = []
remaining_goals = self.goals.copy()
while remaining_goals:
next_goal = remaining_goals.pop(0)
plan.append(f"achieve_{next_goal}")
return plan
# Örnek kullanım
agent = GoalBasedAgent(['clean_house', 'buy_groceries'])
print(agent.plan({})) # Çıktı: ['achieve_clean_house', 'achieve_buy_groceries']4. Fayda Tabanlı Ajanlar
Bu gelişmiş ajanlar, olası eylemlerin beklenen faydasını hesaplayarak en yüksek faydayı sağlayacak hareketi seçer.
import numpy as np
class UtilityBasedAgent:
def __init__(self, utility_function):
self.utility_function = utility_function
def decide(self, possible_actions, current_state):
utilities = []
for action in possible_actions:
utility = self.utility_function(action, current_state)
utilities.append((utility, action))
# En yüksek faydalı eylemi seç
return max(utilities)[1]
# Örnek kullanım
def utility_func(action, state):
# Basit bir fayda fonksiyonu
if action == 'study':
return state['knowledge'] * 1.5
elif action == 'rest':
return state['energy'] * 0.8
else:
return 0
agent = UtilityBasedAgent(utility_func)
current_state = {'knowledge': 50, 'energy': 30}
print(agent.decide(['study', 'rest'], current_state)) # Çıktı: studyYapay Zeka Ajanları Öğrenme Yeteneği
Modern yapay zeka ajanları, makine öğrenmesi algoritmaları sayesinde deneyimlerinden öğrenebilir. İşte basit bir öğrenen ajan örneği:
from sklearn.linear_model import LinearRegression
class LearningAgent:
def __init__(self):
self.model = LinearRegression()
self.experiences = []
def add_experience(self, state, action, reward):
self.experiences.append((state, action, reward))
def train(self):
if len(self.experiences) < 10: # Yeterli veri yoksa
return
# Eğitim verilerini hazırla
X = [[s['feature'] for s, _, _ in self.experiences]]
y = [r for _, _, r in self.experiences]
# Modeli eğit
self.model.fit(X, y)
def predict_reward(self, state):
return self.model.predict([[state['feature']]])[0]
# Örnek kullanım
agent = LearningAgent()
for i in range(10):
agent.add_experience({'feature': i}, f"action_{i}", i*2)
agent.train()
print(agent.predict_reward({'feature': 5})) # Yaklaşık 10 çıktısı beklenirGerçek Dünya Uygulamaları
Yapay zeka ajanları günlük hayatımızda birçok alanda karşımıza çıkıyor:
- Sanal Asistanlar: Siri, Alexa, Google Assistant
- Öneri Sistemleri: Netflix, Amazon ürün önerileri
- Otonom Araçlar: Kendi kendine giden arabalar
- Finansal Danışmanlar: Otomatik yatırım stratejileri
- Oyun Ajanları: Starcraft, DOTA 2’deki yapay zeka rakipler
Python ile Gelişmiş Yapay Zeka Ajanları Örneği
İşte çoklu ortamda çalışabilen daha gelişmiş bir yapay zeka ajanı örneği:
import random
from collections import defaultdict
class AdvancedAIAgent:
def __init__(self, possible_actions):
self.possible_actions = possible_actions
self.q_table = defaultdict(lambda: defaultdict(float))
self.learning_rate = 0.1
self.discount_factor = 0.9
self.exploration_rate = 0.3
def choose_action(self, state):
state_key = str(state)
# Keşif (exploration) veya kullanım (exploitation)
if random.random() < self.exploration_rate:
return random.choice(self.possible_actions)
else:
return max(self.possible_actions,
key=lambda a: self.q_table[state_key][a])
def learn(self, state, action, reward, new_state):
state_key = str(state)
new_state_key = str(new_state)
# Q-öğrenme formülü
best_next_action = max(self.possible_actions,
key=lambda a: self.q_table[new_state_key][a])
td_target = reward + self.discount_factor * self.q_table[new_state_key][best_next_action]
td_error = td_target - self.q_table[state_key][action]
self.q_table[state_key][action] += self.learning_rate * td_error
# Keşif oranını zamanla azalt
self.exploration_rate *= 0.99
# Örnek kullanım
actions = ['up', 'down', 'left', 'right']
agent = AdvancedAIAgent(actions)
# Eğitim döngüsü (basit bir labirent ortamında)
for episode in range(100):
state = {'position': (0, 0)} # Başlangıç pozisyonu
total_reward = 0
for step in range(100):
action = agent.choose_action(state)
# Ortam simülasyonu (gerçek uygulamada ortamdan gelir)
if action == 'up':
new_pos = (state['position'][0], state['position'][1]+1)
elif action == 'down':
new_pos = (state['position'][0], state['position'][1]-1)
elif action == 'left':
new_pos = (state['position'][0]-1, state['position'][1])
else: # right
new_pos = (state['position'][0]+1, state['position'][1])
new_state = {'position': new_pos}
# Ödül hesapla (hedef (5,5) pozisyonu)
if new_pos == (5,5):
reward = 100
done = True
else:
reward = -1
done = False
# Ajan öğrensin
agent.learn(state, action, reward, new_state)
total_reward += reward
state = new_state
if done:
break
print(f"Episode {episode}, Total reward: {total_reward}")Sonuç
Yapay zeka ajanları, basit kurallardan karmaşık öğrenme algoritmalarına kadar geniş bir yelpazede uygulama alanı buluyor. Bu yazıda, farklı ajan türlerini ve Python ile nasıl uygulanabileceklerini inceledik. Serinin bir sonraki bölümünde, derin öğrenme tabanlı ajanları ve gerçek dünya problemlerine nasıl uygulanabileceklerini ele alacağız.
Yapay zeka ajanları hakkında daha fazla bilgi edinmek ve uygulamalı projeler yapmak için sitemizi takip etmeye devam edin. Aşağıdaki yorum bölümünden sorularınızı ve görüşlerinizi paylaşabilirsiniz.
