Skip to content
The Chat Archive
o1-mini-2024-09-12· OpenAI WildChat-4.8M (AI2)

bana davranış klonlama hakkında bir Python kodu yaz

  1. User

    bana davranış klonlama hakkında bir Python kodu yaz

  2. Assistant

    Tabii ki! Davranış klonlama (Behavior Cloning), bir ajanının (genellikle insan veya önceden eğitilmiş bir modelin) davranışlarını taklit etmek için denetimli öğrenme tekniklerini kullanır. Bu yöntem, genellikle özerk sistemlerin insan benzeri kararlar almasını sağlamak için kullanılır.

    Aşağıda, OpenAI Gym'in CartPole-v1 ortamında davranış klonlama örneği için Python kodu bulabilirsiniz. Bu örnekte, önceden toplanmış bir uzman veri setini (arnav datası) kullanarak basit bir sinir ağı modeli eğiteceğiz.

    1. Gerekli Kütüphanelerin Kurulumu

    Öncelikle gerekli kütüphaneleri yükleyelim:

    pip install gym
    pip install torch
    pip install numpy
    pip install matplotlib
    

    2. Uzman Verisinin Toplanması

    Davranış klonlama için önce uzman bir ajan tarafından toplanmış veri setine ihtiyaç vardır. Bu örnekte, rastgele hareket eden bir ajan kullanacağız, ancak gerçek uygulamalarda daha iyi performans için uzman bir politika ile veri toplamak önemlidir.

    import gym
    import numpy as np
    import pickle
    
    env = gym.make('CartPole-v1')
    
    observations = []
    actions = []
    
    for episode in range(100):
        obs = env.reset()
        done = False
        while not done:
            action = env.action_space.sample()  # Rastgele hareket
            observations.append(obs)
            actions.append(action)
            obs, reward, done, info = env.step(action)
    
    # Veriyi kaydet
    with open('expert_data.pkl', 'wb') as f:
        pickle.dump((np.array(observations), np.array(actions)), f)
    
    env.close()
    

    3. Davranış Klonlama Modelinin Eğitilmesi

    Toplanan uzman verisini kullanarak basit bir sinir ağı modelini eğiteceğiz.

    import torch
    import torch.nn as nn
    import torch.optim as optim
    from torch.utils.data import Dataset, DataLoader
    import pickle
    
    # Veri setini yükle
    with open('expert_data.pkl', 'rb') as f:
        observations, actions = pickle.load(f)
    
    class ExpertDataset(Dataset):
        def __init__(self, observations, actions):
            self.observations = torch.tensor(observations, dtype=torch.float32)
            self.actions = torch.tensor(actions, dtype=torch.long)
        
        def __len__(self):
            return len(self.actions)
        
        def __getitem__(self, idx):
            return self.observations[idx], self.actions[idx]
    
    dataset = ExpertDataset(observations, actions)
    dataloader = DataLoader(dataset, batch_size=64, shuffle=True)
    
    # Basit bir sinir ağı modeli
    class BehavioralClone(nn.Module):
        def __init__(self, input_dim, output_dim):
            super(BehavioralClone, self).__init__()
            self.fc1 = nn.Linear(input_dim, 128)
            self.relu = nn.ReLU()
            self.fc2 = nn.Linear(128, output_dim)
        
        def forward(self, x):
            out = self.fc1(x)
            out = self.relu(out)
            out = self.fc2(out)
            return out
    
    input_dim = observations.shape[1]  # Gözlem boyutu
    output_dim = env.action_space.n     # Aksiyon sayısı
    
    model = BehavioralClone(input_dim, output_dim)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    
    # Modeli eğit
    num_epochs = 10
    for epoch in range(num_epochs):
        for batch_obs, batch_actions in dataloader:
            outputs = model(batch_obs)
            loss = criterion(outputs, batch_actions)
            
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
        
        print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}")
    
    # Modeli kaydet
    torch.save(model.state_dict(), 'behavior_clone_model.pth')
    

    4. Eğitilen Modelin Değerlendirilmesi

    Eğitilen modeli kullanarak CartPole-v1 ortamında performansını değerlendirelim.

    import gym
    import torch
    import torch.nn as nn
    import pickle
    
    # Model tanımı (aynı yapı)
    class BehavioralClone(nn.Module):
        def __init__(self, input_dim, output_dim):
            super(BehavioralClone, self).__init__()
            self.fc1 = nn.Linear(input_dim, 128)
            self.relu = nn.ReLU()
            self.fc2 = nn.Linear(128, output_dim)
        
        def forward(self, x):
            out = self.fc1(x)
            out = self.relu(out)
            out = self.fc2(out)
            return out
    
    env = gym.make('CartPole-v1')
    
    input_dim = env.observation_space.shape[0]
    output_dim = env.action_space.n
    
    model = BehavioralClone(input_dim, output_dim)
    model.load_state_dict(torch.load('behavior_clone_model.pth'))
    model.eval()
    
    def choose_action(state):
        state = torch.tensor(state, dtype=torch.float32)
        with torch.no_grad():
            logits = model(state)
        action = torch.argmax(logits).item()
        return action
    
    # Performans değerlendirmesi
    num_episodes = 10
    for episode in range(num_episodes):
        state = env.reset()
        done = False
        total_reward = 0
        while not done:
            action = choose_action(state)
            state, reward, done, info = env.step(action)
            total_reward += reward
        print(f"Episode {episode+1}: Total Reward = {total_reward}")
    
    env.close()
    

    5. Sonuç

    Bu basit örnekte, rastgele hareket eden bir ajandan toplanan veriyi kullanarak bir davranış klonlama modeli oluşturduk ve eğittik. Gerçek uygulamalarda, daha kaliteli ve uzman verileri kullanmak, model mimarisini geliştirmek ve hiperparametre optimizasyonu yapmak performansı artıracaktır.

    Davranış klonlama, özerk sistemlerin insan benzeri davranışlar sergilemesi için güçlü bir yöntemdir. Ancak, genel bir politika öğrenmek yerine sadece gözlemlenen davranışları taklit ettiğinden, dağılım kayması gibi sorunlarla karşılaşabilir. Bu nedenle, genellikle Ekstra Teknikler (örneğin, DAgger algoritması) ile desteklenir.

    Umarım bu örnek yardımcı olur! Başka sorularınız olursa sormaktan çekinmeyin.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.