скачать книгу бесплатно
– В каждом эпизоде агент взаимодействует с окружением, выполняя действия и записывая последовательность состояний, действий и наград.
– После завершения эпизода вычисляется общий возврат `G` путем обратного прохода по эпизоду и обновляется Q-таблица для уникальных пар «состояние-действие».
5. Тестирование агента:
– После завершения обучения агент тестируется в окружении, используя политику, основанную на максимальных Q-значениях.
– Выводится статистика побед, ничьих и поражений.
Этот пример демонстрирует использование методов Монте-Карло для оценки стратегий на основе эпизодических возвратов в задаче блэкджека. Агент учится принимать оптимальные решения, основываясь на накопленном опыте из большого числа эпизодов.
Deep Q-Learning
Deep Q-Learning – это расширение Q-обучения, которое использует глубокие нейронные сети для представления и обновления Q-значений. Это позволяет агентам принимать более сложные и информированные решения в средах с высоким уровнем сложности и большим количеством состояний и действий. В традиционном Q-обучении Q-таблица используется для хранения значений всех возможных пар «состояние-действие», что становится неосуществимым в задачах с большой размерностью. Deep Q-Learning решает эту проблему, используя нейронные сети для аппроксимации функции Q. Агент обучается обновлять параметры нейронной сети, минимизируя разницу между предсказанными и реальными Q-значениями, что делает возможным обучение на больших наборах данных и в сложных средах. Один из ключевых компонентов Deep Q-Learning – это опытный буфер (experience replay), который позволяет агенту запоминать и повторно использовать предыдущие опыты для обучения, что повышает стабильность и эффективность процесса обучения.
Обучение с подкреплением применяется в робототехнике, играх, управлении ресурсами и других задачах, где требуется разработка стратегий и принятие решений в динамических и неопределённых средах.
Описание задачи
Рассмотрим задачу "CartPole" из OpenAI Gym. В этой задаче агент управляет тележкой, на которой закреплен вертикально стоящий столб. Цель агента – балансировать столб, не позволяя ему упасть, двигая тележку влево или вправо.
Описание среды "CartPole"
Состояния:
– Положение тележки (отрицательное значение – тележка слева от центра, положительное – справа).
– Скорость тележки.
– Угол отклонения столба от вертикального положения.
– Угловая скорость столба.
Действия:
– Двигать тележку влево.
– Двигать тележку вправо.
Награды:
– Агент получает награду +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()
