– Двигать тележку вправо.
Награды:
– Агент получает награду +1 за каждый шаг, пока столб остается вертикально.
Конечное состояние:
– Эпизод заканчивается, если столб отклоняется слишком сильно от вертикального положения или тележка выходит за пределы поля.
Пример кода для Deep Q-Learning
Для реализации DQN мы будем использовать библиотеку PyTorch для создания и обучения нейронной сети.
Установка необходимых библиотек
Для начала нужно установить OpenAI Gym и PyTorch, если они еще не установлены:
```bash
pip install gym torch
```
Пример кода
```python
import gym
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
from collections import deque, namedtuple
import random
# Определение архитектуры нейронной сети
class DQN(nn.Module):
def __init__(self, state_size, action_size):
super(DQN, self).__init__()
self.fc1 = nn.Linear(state_size, 24)
self.fc2 = nn.Linear(24, 24)
self.fc3 = nn.Linear(24, action_size)
def forward(self, x):
x = torch.relu(self.fc1(x))
x = torch.relu(self.fc2(x))
return self.fc3(x)
# Параметры обучения
env = gym.make('CartPole-v1')
state_size = env.observation_space.shape[0]
action_size = env.action_space.n
batch_size = 64
gamma = 0.99 # Коэффициент дисконтирования
epsilon = 1.0 # Вероятность случайного действия
epsilon_min = 0.01
epsilon_decay = 0.995
learning_rate = 0.001
target_update = 10 # Как часто обновлять целевую сеть
memory_size = 10000
num_episodes = 1000
# Определение памяти для опыта
Transition = namedtuple('Transition', ('state', 'action', 'next_state', 'reward'))
memory = deque(maxlen=memory_size)
# Инициализация сети и оптимизатора
policy_net = DQN(state_size, action_size)
target_net = DQN(state_size, action_size)
target_net.load_state_dict(policy_net.state_dict())
target_net.eval()
optimizer = optim.Adam(policy_net.parameters(), lr=learning_rate)
# Функция для выбора действия
def select_action(state, epsilon):
if random.random() < epsilon:
return env.action_space.sample()
else:
with torch.no_grad():
return policy_net(torch.tensor(state, dtype=torch.float32)).argmax().item()
# Функция для обновления памяти
def store_transition(state, action, next_state, reward):
memory.append(Transition(state, action, next_state, reward))
# Функция для обучения сети
def optimize_model():
if len(memory) < batch_size:
return
transitions = random.sample(memory, batch_size)
batch = Transition(*zip(*transitions))
state_batch = torch.tensor(batch.state, dtype=torch.float32)
action_batch = torch.tensor(batch.action).unsqueeze(1)
reward_batch = torch.tensor(batch.reward, dtype=torch.float32)
non_final_mask = torch.tensor(tuple(map(lambda s: s is not None, batch.next_state)), dtype=torch.bool)
non_final_next_states = torch.tensor([s for s in batch.next_state if s is not None], dtype=torch.float32)
state_action_values = policy_net(state_batch).gather(1, action_batch)
next_state_values = torch.zeros(batch_size)
next_state_values[non_final_mask] = target_net(non_final_next_states).max(1)[0].detach()
expected_state_action_values = reward_batch + (gamma * next_state_values)
loss = nn.functional.mse_loss(state_action_values.squeeze(), expected_state_action_values)
optimizer.zero_grad()
loss.backward()
optimizer.step()
# Основной цикл обучения
for episode in range(num_episodes):
state = env.reset()
total_reward = 0
done = False
while not done:
action = select_action(state, epsilon)
next_state, reward, done, _ = env.step(action)
total_reward += reward
if done:
next_state = None
store_transition(state, action, next_state, reward)
state = next_state
optimize_model()
if epsilon > epsilon_min:
epsilon *= epsilon_decay
if episode % target_update == 0:
target_net.load_state_dict(policy_net.state_dict())
print(f"Episode {episode}, Total Reward: