import numpy as np from scipy.optimize import minimize class MaxEntIRL: def init(self,…
- User
import numpy as np from scipy.optimize import minimize
class MaxEntIRL: def init(self, num_states, num_actions, discount_factor=0.99, learning_rate=0.01, num_iterations=100): self.num_states = num_states self.num_actions = num_actions self.discount_factor = discount_factor self.learning_rate = learning_rate self.num_iterations = num_iterations
# Initialize transition probabilities self.P = np.zeros((num_states, num_actions, num_states)) # Initialize feature expectations self.feature_expectations = np.zeros(num_states) # Initialize rewards self.rewards = np.zeros(num_states) def set_transition_probabilities(self, transitions): for (s, a, s_next) in transitions: self.P[s, a, s_next] += 1 # Normalize self.P = self.P / np.sum(self.P, axis=2, keepdims=True) def compute_state_visitation_freq(self, policy): T = 1000 # Time horizon mu = np.zeros((T, self.num_states)) mu[0] = np.ones(self.num_states) / self.num_states # Initial state distribution for t in range(1, T): for s in range(self.num_states): for a in range(self.num_actions): mu[t, s] += np.sum(mu[t-1] * self.P[:, a, s] * policy[:, a]) return np.sum(mu, axis=0) def compute_expected_svf(self, policy): svf = self.compute_state_visitation_freq(policy) return np.dot(svf, np.eye(self.num_states)) def compute_gradient(self, rewards, expert_feature_expectations, policy): expected_svf = self.compute_expected_svf(policy) gradient = expert_feature_expectations - expected_svf return gradient def optimize_rewards(self, expert_feature_expectations): def objective(rewards): policy = self.compute_policy(rewards) expected_svf = self.compute_expected_svf(policy) return -np.dot(expert_feature_expectations, rewards) + np.dot(expected_svf, rewards) def gradient(rewards): policy = self.compute_policy(rewards) return self.compute_gradient(rewards, expert_feature_expectations, policy) initial_rewards = np.random.rand(self.num_states) result = minimize(objective, initial_rewards, method='L-BFGS-B', jac=gradient) return result.x def compute_policy(self, rewards): Q = np.zeros((self.num_states, self.num_actions)) for _ in range(1000): # Value iteration for s in range(self.num_states): for a in range(self.num_actions): Q[s, a] = rewards[s] + self.discount_factor * np.sum(self.P[s, a] * np.max(Q, axis=1)) return np.exp(Q) / np.sum(np.exp(Q), axis=1, keepdims=True) def fit(self, expert_trajectories): # Compute expert feature expectations expert_feature_expectations = np.zeros(self.num_states) for trajectory in expert_trajectories: for state in trajectory: expert_feature_expectations[state] += 1 expert_feature_expectations /= len(expert_trajectories) # Optimize rewards self.rewards = self.optimize_rewards(expert_feature_expectations) return self.rewards def get_optimal_policy(self): return self.compute_policy(self.rewards)Örnek kullanım
num_states = 15 num_actions = 3
MaxEnt IRL modelini oluştur
model = MaxEntIRL(num_states, num_actions)
Geçiş olasılıklarını ayarla (gerçek verilerle değiştirilmeli)
transitions = [(np.random.randint(0, num_states), np.random.randint(0, num_actions), np.random.randint(0, num_states)) for _ in range(1000)] model.set_transition_probabilities(transitions)
Uzman yörüngeleri oluştur (gerçek verilerle değiştirilmeli)
expert_trajectories = [[np.random.randint(0, num_states) for _ in range(10)] for _ in range(100)]
Modeli eğit
learned_rewards = model.fit(expert_trajectories)
print("Öğrenilen Ödül Fonksiyonu:") for state, reward in enumerate(learned_rewards): print(f"Durum {state}: Ödül {reward:.4f}")
Optimal politikayı hesapla
optimal_policy = model.get_optimal_policy()
print("\nOptimal Politika:") for state in range(num_states): action = np.argmax(optimal_policy[state]) print(f"Durum {state}: Eylem {action} ({'Sat' if action == 0 else 'Nötr' if action == 1 else 'Satın Al'})")
Kodu 587 günlük verilerime göre değiştirmeni istiyorum. Ayrıca elimde state, act,on, next state ten oluşan bir csv dosyası var. Feature ları statelere göre one hot encoded yapmak istiyorum. Ben sadece dosyayı yükleyeyim gerisini kod çözsün.
- Assistant
Tabii, mevcut MaxEnt Inverse Reinforcement Learning (IRL) sınıfınızı, 587 günlük verilerinize ve elinizdeki CSV dosyasına uygun hale getirmek için gerekli adımları atabiliriz. Aşağıda, CSV dosyasını yüklemek, verileri işlemek, durumları one-hot encode etmek ve MaxEntIRL sınıfını buna göre uyarlamak için tam bir örnek sunuyorum.
Adımlar:
- Gerekli Kütüphanelerin Kurulumu ve İçe Aktarılması
- CSV Dosyasının Yüklenmesi ve İşlenmesi
- One-Hot Encoding ile Durum Özelliklerinin Oluşturulması
- MaxEntIRL Sınıfının Güncellenmesi
- Modelin Eğitilmesi ve Sonuçların Çıkarılması
1. Gerekli Kütüphanelerin Kurulumu ve İçe Aktarılması
Öncelikle, gerekli Python kütüphanelerini kurduğunuzdan emin olun. Bu örnekte
pandaskütüphanesini kullanacağız, eğer henüz yüklü değilse aşağıdaki komut ile kurabilirsiniz:pip install pandasArdından, gerekli kütüphaneleri içe aktaralım:
import numpy as np import pandas as pd from scipy.optimize import minimize from sklearn.preprocessing import OneHotEncoder2. CSV Dosyasının Yüklenmesi ve İşlenmesi
Elinizdeki CSV dosyasının
state,action, venext_statesütunlarına sahip olduğunu varsayıyorum. Aşağıdaki kod, CSV dosyasını yükler ve bu verileri işler:# CSV dosyasının yolu csv_file_path = 'transitions.csv' # Dosya adınızı buraya girin # CSV dosyasını yükle data = pd.read_csv(csv_file_path) # Verilerin ilk birkaç satırına göz atın print(data.head())Not: CSV dosyanızın sütun adları farklı ise,
pd.read_csvfonksiyonunu uygun şekilde ayarlayın.3. One-Hot Encoding ile Durum Özelliklerinin Oluşturulması
Durumları one-hot encode etmek için
OneHotEncoderkullanacağız. Bu, durumların daha iyi temsil edilmesini sağlar ve IRL algoritmasının özelliklerini daha iyi yakalamasına yardımcı olur.# Durumları one-hot encode etmek için OneHotEncoder kullanın encoder = OneHotEncoder(sparse=False, handle_unknown='ignore') states = data[['state', 'next_state']].values.flatten().reshape(-1, 1) encoder.fit(states) # Encoded feature'ları alalım state_features = encoder.transform(np.array(data['state']).reshape(-1, 1)) # Özel durum sayısını bulmak için unique durumları alın unique_states = np.unique(data[['state', 'next_state']].values) num_states = len(unique_states) num_actions = data['action'].nunique() print(f'Unique States: {num_states}, Unique Actions: {num_actions}')4. MaxEntIRL Sınıfının Güncellenmesi
Mevcut
MaxEntIRLsınıfınız, ödülleri her durum için ayrı ayrı tahmin ediyor. Bunun yerine, özellik tabanlı bir yaklaşım kullanmak, daha esnek ve güçlü sonuçlar elde etmenizi sağlar. Aşağıda,MaxEntIRLsınıfını özellik tabanlı olarak güncellenmiş haliyle bulabilirsiniz:class MaxEntIRL: def __init__(self, num_states, num_actions, feature_matrix, discount_factor=0.99, learning_rate=0.01, num_iterations=100): self.num_states = num_states self.num_actions = num_actions self.feature_matrix = feature_matrix # Feature matrix (num_states x num_features) self.num_features = feature_matrix.shape[1] self.discount_factor = discount_factor self.learning_rate = learning_rate self.num_iterations = num_iterations # Initialize transition probabilities self.P = np.zeros((num_states, num_actions, num_states)) # Initialize rewards as a linear combination of features self.theta = np.random.rand(self.num_features) def set_transition_probabilities(self, transitions): for (s, a, s_next) in transitions: self.P[s, a, s_next] += 1 # Normalize self.P = self.P / np.sum(self.P, axis=2, keepdims=True) def compute_policy(self, rewards): # Compute the softmax policy via value iteration epsilon = 1e-5 V = np.zeros(self.num_states) while True: V_prev = V.copy() Q = rewards[:, np.newaxis] + self.discount_factor * np.dot(self.P, V_prev) V = np.log(np.sum(np.exp(Q), axis=1)) if np.max(np.abs(V - V_prev)) < epsilon: break # Compute the policy Q = rewards[:, np.newaxis] + self.discount_factor * np.dot(self.P, V) policy = np.exp(Q - V[:, np.newaxis]) # Normalize policy = policy / np.sum(policy, axis=1, keepdims=True) return policy def fit(self, expert_trajectories, transitions): # Set transition probabilities self.set_transition_probabilities(transitions) # Compute expert feature expectations expert_feature_expectations = np.zeros(self.num_features) for trajectory in expert_trajectories: for state in trajectory: expert_feature_expectations += self.feature_matrix[state] expert_feature_expectations /= len(expert_trajectories) # Optimize theta def objective(theta): self.theta = theta rewards = self.feature_matrix.dot(self.theta) policy = self.compute_policy(rewards) expected_svf = self.compute_state_visitation_freq(policy) return -np.dot(expert_feature_expectations, theta) + np.dot(expected_svf, theta) def gradient(theta): self.theta = theta rewards = self.feature_matrix.dot(self.theta) policy = self.compute_policy(rewards) expected_svf = self.compute_state_visitation_freq(policy) gradient = expert_feature_expectations - expected_svf return -gradient # Because we are minimizing initial_theta = np.random.rand(self.num_features) result = minimize(objective, initial_theta, method='L-BFGS-B', jac=gradient, options={'maxiter': self.num_iterations}) self.theta = result.x return self.theta def compute_state_visitation_freq(self, policy): T = 1000 # Time horizon mu = np.zeros((T, self.num_states)) mu[0] = np.ones(self.num_states) / self.num_states # Initial state distribution for t in range(1, T): for s in range(self.num_states): for a in range(self.num_actions): mu[t, s] += mu[t-1].dot(self.P[:, a, s] * policy[:, a]) return np.sum(mu, axis=0) def get_optimal_policy(self): rewards = self.feature_matrix.dot(self.theta) return self.compute_policy(rewards)Açıklamalar:
- Feature Matrix: Ödüller, durum özelliklerinin bir doğrusal kombinasyonu olarak tanımlanır (
rewards = feature_matrix * theta). - Policy Computation: Softmax politikası, ödüllere dayalı olarak hesaplanır.
- Gradient Descent:
thetaparametrelerini optimize etmek içinL-BFGS-Byöntemi kullanılır. - State Visitation Frequency (SVF): Politikanın beklenen durum ziyaret sıklığını hesaplar.
5. Modelin Eğitilmesi ve Sonuçların Çıkarılması
Artık tüm bileşenler hazır, modelimizi eğitip sonuçları inceleyebiliriz.
# Geçiş verilerini tuple listesine dönüştürün transitions = list(zip(data['state'], data['action'], data['next_state'])) # Uzman yörüngelerini oluşturun # Bu örnekte, rastgele yörüngeler oluşturulmuştur. Gerçek verileriniz varsa, onları kullanmalısınız. # Örnek: Her yörünge, belirli bir başlangıçtan itibaren bir dizi durum içerir. expert_trajectories = [] trajectory_length = 10 # Her yörüngenin uzunluğu num_trajectories = 100 # Yörünge sayısı for _ in range(num_trajectories): traj = np.random.choice(unique_states, size=trajectory_length).tolist() expert_trajectories.append(traj) # One-hot encoded feature matrisini oluşturun (num_states x num_features) # Burada her durum için one-hot encoding kullanıyoruz. one_hot_encoder = OneHotEncoder(sparse=False, handle_unknown='ignore') state_indices = np.array(range(num_states)).reshape(-1, 1) feature_matrix = one_hot_encoder.fit_transform(state_indices) # MaxEntIRL modelini oluştur model = MaxEntIRL(num_states, num_actions, feature_matrix) # Modeli eğit learned_theta = model.fit(expert_trajectories, transitions) print("Öğrenilen Theta Değerleri:") print(learned_theta) # Öğrenilen ödül fonksiyonunu hesapla learned_rewards = feature_matrix.dot(learned_theta) print("\nÖğrenilen Ödül Fonksiyonu:") for state in range(num_states): print(f"Durum {state}: Ödül {learned_rewards[state]:.4f}") # Optimal politikayı hesapla optimal_policy = model.get_optimal_policy() print("\nOptimal Politika:") action_names = {0: 'Sat', 1: 'Nötr', 2: 'Satın Al'} # Eylem isimlerini ihtiyacınıza göre güncelleyin for state in range(num_states): action = np.argmax(optimal_policy[state]) action_name = action_names.get(action, f'Eylem {action}') print(f"Durum {state}: Eylem {action} ({action_name})")Açıklamalar:
- Geçiş Verilerinin Hazırlanması: CSV dosyasından alınan geçiş verilerini
(state, action, next_state)tuple'ları listesine dönüştürüyoruz. - Uzman Yörüngelerinin Oluşturulması: Bu örnekte rastgele yörüngeler oluşturulmuştur. Kendi uzman yörüngelerinizi kullanmanız daha iyi sonuçlar sağlayacaktır.
- Feature Matrix: Durumları one-hot encode ederek özellik matrisini oluşturuyoruz. Her durum, benzersiz bir özellik vektörüne sahip olur.
- Modelin Eğitilmesi:
MaxEntIRLsınıfını kullanarak modeli eğitiyoruz.thetadeğerleri öğrenilir ve bu değerler aracılığıyla ödül fonksiyonu elde edilir. - Optimal Politikanın Hesaplanması: Öğrenilen ödüllere dayanarak optimal politika hesaplanır ve her durum için en iyi eylem belirlenir.
Notlar ve İpuçları
- Veri Kalitesi: Gerçek uzman yörüngeleriniz varsa, rastgele yörüngeler yerine bunları kullanmanız model performansını artıracaktır.
- Feature Engineer: One-hot encoding dışında, daha zengin özellikler (örneğin, durumların birbirleriyle olan ilişkileri) kullanmak modelinizi daha etkili hale getirebilir.
- Model Parametreleri:
discount_factor,learning_rate, venum_iterationsgibi hiperparametreleri veri setinize uygun şekilde ayarlamak için denemeler yapabilirsiniz. - Politika Değerlendirmesi: Öğrenilen politikayı değerlendirmek için çeşitli metrikler kullanabilirsiniz, örneğin başarı oranı, ortalama ödül gibi.
Sonuç
Bu adımları izleyerek, elinizdeki 587 günlük veri seti ile MaxEnt IRL modelinizi başarıyla eğitebilir ve optimal politikayı elde edebilirsiniz. Herhangi bir adımda sorun yaşarsanız veya daha fazla yardıma ihtiyaç duyarsanız, lütfen bana bildirin!