Привет, уважаемые читатели Хабра!
В RL существует множество алгоритмов, каждый из которых имеет свои преимущества и недостатки.
DDPG (Deep Deterministic Policy Gradients) - это алгоритм, объединяющий в себе идеи из двух областей: DPG (Deterministic Policy Gradients) и DQN (Deep Q-Network). DDPG подходит для задач с непрерывным действием, и он стал основой к примеру для управления роботами и автономному вождению.
PPO (Proximal Policy Optimization) - это алгоритм, который сосредотачивается на обучении стратегии (policy) с учетом границ для обновлений. PPO стал популярным выбором благодаря своей стабильности и хорошей производительности в различных средах. Он также широко используется в научном обучение, ИИ героев в играх и в других областях.
Deep Deterministic Policy Gradients (DDPG)
Deep Deterministic Policy Gradients (DDPG) - это алгоритм обучения с подкреплением, который сочетает в себе элементы Q-обучения (оценки функции полезности) и метода актер-критик (Actor-Critic).
В DDPG используется нейронная сеть для параметризации политики (актер) и критика (критика) для оценки Q-функции состояния-действия. Пусть:
S - множество состояний.
A - множество действий.
π(a|s) - параметризованная политика, где a представляет действие, s - состояние, и π(a|s) определяет вероятность выбора действия a в состоянии s.
Q(s, a) - Q-функция, оценивающая ожидаемую награду при выполнении действия a в состоянии s.
θ - параметры актера (политики), и θ' - параметры критика (Q-функции).
Цель DDPG - максимизировать ожидаемую сумму наград (называемую накопленным вознаграждением) через оптимизацию параметров актера и критика. Это делается с помощью функции цели, называемой "актор-критиковой функцией потерь" (Actor-Critic Loss).
Актор (Actor) стремится максимизировать ожидаемую сумму наград, выбирая действия, которые максимизируют политику. Функция потерь актера (L_actor) определяется следующим образом:
где R(π(s|θ)) представляет ожидаемое накопленное вознаграждение при использовании политики π(s|θ).
Критик (Critic) оценивает Q-функцию, которая оценивает ожидаемую сумму наград для заданных состояний и действий. Функция потерь критика (L_critic) определяется следующим образом:
где Q_target(s, a) - целевое значение Q-функции, обычно вычисляемое с помощью временной разницы (temporal difference, TD) между текущим оцениваемым Q-значением и следующим Q-значением. Параметры критика обновляются таким образом, чтобы минимизировать L_critic.
Обновление параметров актера и критика в DDPG осуществляется с использованием градиентного спуска (или его вариантов) для оптимизации L_actor и L_critic. Обновление актера направлено на увеличение накопленного вознаграждения, в то время как обновление критика направлено на улучшение оценки Q-функции.
DDPG также использует целевую сеть (target network) для более стабильного обучения, обновляя параметры целевой сети медленно с использованием экспоненциального скользящего среднего.
Основные принципы DDPG :
Оценка Q-функции:
В DDPG используется Q-функция (функция оценки долгосрочной награды), как и в DQN. Однако, вместо дискретных действий, DDPG работает с непрерывными действиями, что делает его подходящим для задач, где агенту нужно выбирать значения из непрерывного диапазона.
Параметрическая стратегия:
DDPG использует параметрическую стратегию, которая представляет собой нейронную сеть, принимающую состояния среды и предсказывающую действия. Эта стратегия обучается на основе градиента, что делает его методом, основанным на политике (policy-based).
Целевые сети:
Для обеспечения стабильности в обучении, DDPG использует две сети для оценки Q-функции и стратегии. Одна сеть обновляется медленно (целевая сеть), что позволяет сглаживать обновления и делать процесс более стабильным.
Преимущества DDPG:
Подходит для задач с непрерывными действиями, что делает его отличным выбором для управления роботами и другими агентами.
Способен решать задачи с высокоразмерными пространствами состояний и действий.
Хорошо масштабируется и может быть использован для обучения глубоких нейронных сетей.
Недостатки DDPG:
Требует осторожной настройки гиперпараметров, чтобы достичь стабильности в обучении.
Может быть чувствителен к начальным условиям и требует больше данных для обучения, чем некоторые другие алгоритмы.
Примеры кода
Пример 1: Импорт библиотек и определение нейронной сети для стратегии DDPG:
import tensorflow as tf
import numpy as np
# Определение нейронной сети для стратегии
class ActorNetwork(tf.keras.Model):
def __init__(self, state_dim, action_dim):
super(ActorNetwork, self).__init__()
self.fc1 = tf.keras.layers.Dense(400, activation='relu')
self.fc2 = tf.keras.layers.Dense(300, activation='relu')
self.fc3 = tf.keras.layers.Dense(action_dim, activation='tanh')
def call(self, state):
x = self.fc1(state)
x = self.fc2(x)
return self.fc3(x)
Пример 2: Импорт окружения и определение Q-сети DDPG:
import gym
# Определение окружения
env = gym.make('Pendulum-v0')
# Определение Q-сети
class CriticNetwork(tf.keras.Model):
def __init__(self, state_dim, action_dim):
super(CriticNetwork, self).__init__()
self.fc1 = tf.keras.layers.Dense(400, activation='relu')
self.fc2 = tf.keras.layers.Dense(300, activation='relu')
self.fc3 = tf.keras.layers.Dense(1)
def call(self, state, action):
x = tf.concat([state, action], axis=-1)
x = self.fc1(x)
x = self.fc2(x)
return self.fc3(x)
Пример 3: Обновление параметров стратегии и Q-сети DDPG:
def update_actor_target(actor, actor_target, tau):
for (a_var, a_target_var) in zip(actor.trainable_variables, actor_target.trainable_variables):
a_target_var.assign(tau * a_var + (1.0 - tau) * a_target_var)
def update_critic_target(critic, critic_target, tau):
for (c_var, c_target_var) in zip(critic.trainable_variables, critic_target.trainable_variables):
c_target_var.assign(tau * c_var + (1.0 - tau) * c_target_var)
Пример 4: Вычисление градиента и обновление параметров стратегии:
def get_actor_loss(actor, critic, states):
actions = actor(states)
q_values = critic([states, actions])
return -tf.reduce_mean(q_values)
def train_actor(actor, critic, states, actor_optimizer):
with tf.GradientTape() as tape:
actor_loss = get_actor_loss(actor, critic, states)
actor_gradients = tape.gradient(actor_loss, actor.trainable_variables)
actor_optimizer.apply_gradients(zip(actor_gradients, actor.trainable_variables))
Пример 5: Главный цикл обучения DDPG:
#
Основной цикл обучения
for episode in range(num_episodes):
state = env.reset()
total_reward = 0
for t in range(max_steps):
action = actor(state)
next_state, reward, done, _ = env.step(action)
replay_buffer.add((state, action, reward, next_state, done))
if len(replay_buffer) > batch_size:
batch = replay_buffer.sample(batch_size)
train_critic(critic, critic_target, batch, critic_optimizer)
train_actor(actor, critic, states, actor_optimizer)
update_actor_target(actor, actor_target, tau)
update_critic_target(critic, critic_target, tau)
state = next_state
total_reward += reward
if done:
break
Выбор DDPG для вашей задачи в RL зависит от ряда факторов:
Непрерывные действия: Если ваша задача включает в себя непрерывные действия, то DDPG может быть хорошим выбором.
Средний размер пространства действий и состояний: DDPG подходит для задач с средними или большими размерами пространств состояний и действий.
Требования к стабильности: Если вам важна стабильность в обучении и вы готовы потратить время на настройку гиперпараметров, DDPG может быть вашим выбором.
Доступность библиотек: Множество фреймворков RL, таких как TensorFlow и PyTorch, предоставляют реализации DDPG, что делает его доступным для использования.
Proximal Policy Optimization (PPO)
Proximal Policy Optimization (PPO) - это алгоритм обучения с подкреплением, который использует методы оптимизации политики, чтобы обучать агентов принимать действия в среде
В PPO используется актер-критиковый подход, где актер (политика) обновляется для улучшения выбора действий, а критик (оценщик) оценивает, насколько хорошо действия агента соответствуют ожидаемым наградам. Определим несколько ключевых элементов:
S - множество состояний.
A - множество действий.
π(a|s) - политика, представляющая вероятность выбора действия a в состоянии s.
R(π) - средняя ожидаемая награда при использовании политики π.
Q(s, a) - Q-функция, оценивающая ожидаемую сумму наград при выполнении действия a в состоянии s.
Цель PPO - максимизировать ожидаемую сумму наград через оптимизацию параметров политики. Это делается с использованием функции цели, называемой "функцией потерь актера" (Actor Loss).
Функция потерь актера в PPO определяется следующим образом:
где:
θ - параметры политики.
r(θ) = π(a|s) / π_old(a|s) - отношение вероятностей новой и старой политики.
A - преимущество действия, оцениваемое критиком (оценщиком).
ε - параметр обрезки (clipping), который ограничивает изменения в политике.
PPO включает механизм обрезки (clipping), который ограничивает, насколько сильно можно изменить политику на каждом шаге. Это делает алгоритм более стабильным и предсказуемым.
Функция потерь критика (Critic Loss) оценивает, насколько оценки Q-функции согласуются с ожидаемыми наградами:
где:
θ' - параметры критика.
Q(s, a|θ') - оценка Q-функции с использованием параметров критика θ'.
R(π) - средняя ожидаемая награда при использовании текущей политики π.
Обновление параметров политики и критика в PPO осуществляется с использованием градиентного спуска (или его вариантов) для оптимизации L_actor и L_critic. Обновление политики направлено на увеличение накопленных вознаграждений, в то время как обновление критика направлено на улучшение оценки Q-функции.
Основные принципы:
Политика и стратегия:
В PPO, центральным понятием является политика (policy) или стратегия, которая определяет, какие действия агент должен предпринимать в ответ на состояния среды. Политика обычно представлена нейронной сетью.
Объект функции потерь:
PPO оптимизирует функцию потерь, которая является комбинацией нескольких компонентов. Основными компонентами являются функция потерь для политики (policy loss) и функция потерь для оценки значений состояний (value loss).
Оптимизация стратегии:
PPO работает над улучшением текущей политики, делая это в "проксимальном" (proximal) смысле, чтобы гарантировать стабильность обучения. Это достигается через ограничение изменений в политике.
Преимущества PPO:
Стабильность обучения: PPO известен своей способностью достичь стабильного обучения даже в сложных средах.
Относительная простота: В сравнении с некоторыми другими алгоритмами, PPO имеет относительно простую реализацию и настройку гиперпараметров.
Хорошая производительность: PPO часто демонстрирует хорошую производительность на различных задачах обучения с подкреплением.
Недостатки PPO:
Высокое количество данных: PPO может потребовать большое количество обучающих данных, что может быть проблемой в реальных задачах.
Параметры для настройки: Несмотря на относительную простоту, настройка гиперпараметров PPO может потребовать некоторого времени и опыта.
Примеры кода
Пример 1: Импорт библиотек и создание среды:
import gym
import numpy as np
import tensorflow as tf
# Создание среды
env = gym.make('CartPole-v1')
Пример 2: Определение политики и критика сети:
class PolicyNetwork(tf.keras.Model):
def __init__(self, num_actions):
super(PolicyNetwork, self).__init__()
# Определите вашу нейронную сеть для политики
# ...
class ValueNetwork(tf.keras.Model):
def __init__(self):
super(ValueNetwork, self).__init__()
# Определите вашу нейронную сеть для оценки состояний
# ...
Пример 3: Определение функции потерь для PPO:
def ppo_loss(old_policy, new_policy, advantages, epsilon=0.2):
prob_ratio = new_policy / old_policy
clipped_prob_ratio = tf.clip_by_value(prob_ratio, 1 - epsilon, 1 + epsilon)
surrogate_loss = tf.minimum(prob_ratio * advantages, clipped_prob_ratio * advantages)
return -tf.reduce_mean(surrogate_loss)
Пример 4: Обновление политики PPO:
def update_policy(policy_network, optimizer, states, actions, advantages, epsilon=0.2):
with tf.GradientTape() as tape:
old_policy = policy_network(states, training=True)
new_policy = policy_network(states, training=True)
loss = ppo_loss(old_policy, new_policy, advantages, epsilon)
gradients = tape.gradient(loss, policy_network.trainable_variables)
optimizer.apply_gradients(zip(gradients, policy_network.trainable_variables))
Пример 5: Главный цикл обучения PPO:
# Основной цикл обучения
for episode in range(num_episodes):
state = env.reset()
done = False
while not done:
action = policy_network(state, training=False)
next_state, reward, done, _ = env.step(action)
# Вычисление преимуществ для обновления политики
advantages = compute_advantages(state, next_state, rewards, gamma, lam)
# Обновление политики
update_policy(policy_network, optimizer, states, actions, advantages, epsilon)
state = next_state
Выбор PPO для вашей задачи зависит от следующих факторов:
Требования к стабильности: Если вам важна стабильность в обучении и вы не хотите тратить много времени на настройку гиперпараметров, PPO может быть хорошим выбором.
Средний размер пространства действий и состояний: PPO работает хорошо в задачах с средними или большими размерами пространств состояний и действий.
Доступность библиотек: PPO легко реализовать с использованием популярных библиотек машинного обучения, что упрощает его применение.
Количество доступных обучающих данных: PPO может потребовать большое количество данных для стабильного обучения, поэтому убедитесь, что у вас есть доступ к достаточному объему данных.
При выборе PPO для своей задачи также учтите, что этот алгоритм, как и многие другие в RL, требует экспериментов и итераций для настройки и оптимизации.
Другие популярные архитектуры RL
A3C (Asynchronous Advantage Actor-Critic)
A3C (Asynchronous Advantage Actor-Critic) - это алгоритм обучения с подкреплением, который применяет метод Actor-Critic с использованием асинхронного обучения на нескольких агентах. Он был разработан для обучения агентов на многозадачных и многопроцессорных системах.
Преимущества A3C:
Способность обучать агентов на многозадачных системах.
Скорость обучения благодаря асинхронному методу.
Применим в различных задачах, включая игры и робототехнику.
Пример кода A3C:
В этом коде используется библиотека tf_agents, разработанная Google, для реализации A3C на среде CartPole:
from tf_agents.environments import suite_gym
from tf_agents.environments import tf_py_environment
from tf_agents.networks import actor_distribution_network
from tf_agents.networks import value_network
from tf_agents.agents.a3c import a3c_agent
from tf_agents.utils import common
import tensorflow as tf
# Создание среды
env_name = 'CartPole-v1'
env = suite_gym.load(env_name)
train_env = tf_py_environment.TFPyEnvironment(env)
# Создание сетей для актера и критика
actor_net = actor_distribution_network.ActorDistributionNetwork(
train_env.observation_spec(),
train_env.action_spec(),
fc_layer_params=(100,))
value_net = value_network.ValueNetwork(
train_env.observation_spec(),
fc_layer_params=(100,))
# Создание A3C агента
optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=1e-3)
train_step_counter = tf.Variable(0)
agent = a3c_agent.A3CAgent(
train_env.time_step_spec(),
train_env.action_spec(),
actor_network=actor_net,
value_network=value_net,
optimizer=optimizer,
train_step_counter=train_step_counter)
agent.initialize()
TRPO (Trust Region Policy Optimization)
TRPO (Trust Region Policy Optimization) - это алгоритм обучения с подкреплением, который основан на методе максимизации функции полезности с ограничением (trust region). Он известен своей способностью обеспечивать стабильное обучение и гарантировать улучшение политики.
TRPO оптимизирует политику, используя метод trust region для гарантированного улучшения политики на каждом шаге. Это делает его стабильным и надежным алгоритмом.
Преимущества TRPO:
Стабильное обучение и гарантированное улучшение политики.
Подходит для широкого спектра задач обучения с подкреплением.
Пример кода TRPO:
В следующем примере кода используется библиотека Stable Baselines, чтобы реализовать TRPO на среде CartPole:
from stable_baselines import TRPO
from stable_baselines.common.envs import CartPoleEnv
# Создание среды
env = CartPoleEnv()
# Создание и обучение TRPO агента
model = TRPO('MlpPolicy', env, verbose=1)
model.learn(total_timesteps=10000)
# Сохранение модели
model.save("trpo_cartpole")
DQN (Deep Q-Network)
DQN (Deep Q-Network) - это алгоритм обучения с подкреплением, который основан на методе Q-обучения. Он является основой для многих других алгоритмов обучения с подкреплением и известен своей способностью обучать агентов в средах с дискретными действиями.
DQN использует нейронные сети для оценки Q-функции и оптимизации стратегии агента. Он был впервые применен к задачам игр и способен достичь выдающихся результатов.
Преимущества DQN:
Эффективный и широко применимый алгоритм для задач с дискретными действиями.
Базовая архитектура для более сложных алгоритмов, таких как Double DQN и Dueling DQN.
Примеры коf DQN: В следующем примере кода используется библиотека
tf_agents
, чтобы реализовать DQN на среде CartPole:
from tf_agents.environments import suite_gym
from tf_agents.environments import tf_py_environment
from tf_agents.networks import q_network
from tf_agents.agents.dqn import dqn_agent
from tf_agents.utils import common
import tensorflow as tf
# Создание среды
env_name = 'CartPole-v1'
env = suite_gym.load(env_name)
train_env = tf_py_environment.TFPyEnvironment(env)
# Создание Q-сети
fc_layer_params = (100,)
q_net = q_network.QNetwork(
train_env.observation_spec(),
train_env.action_spec(),
fc_layer_params=fc_layer_params)
# Создание DQN агента
optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=1e-3)
train_step_counter = tf.Variable(0)
agent = dqn_agent.DqnAgent(
train_env.time_step_spec(),
train_env.action_spec(),
q_network=q_net,
optimizer=optimizer,
td_errors_loss_fn=common.element_wise_squared_loss,
train_step_counter=train_step_counter)
agent.initialize()
И другие
SAC (Soft Actor-Critic): Алгоритм, предназначенный для обучения с непрерывными действиями и оптимизирующий стратегию с использованием энтропии для регуляризации.
DDPG (Deep Deterministic Policy Gradients): Алгоритм, также работающий с непрерывными действиями и основанный на методе DPG.
Rainbow: Совокупность различных улучшений для DQN, включая Double DQN, Prioritized Experience Replay и др.
A2C (Advantage Actor-Critic): Вариация A3C, ориентированная на обучение в однопоточной среде.
Рекомендуем вам экспериментировать с различными алгоритмами и выбирать тот, который наилучшим образом подходит для вашей конкретной задачи в области обучения с подкреплением.
Статья подготовлена в рамках запуска нового потока курса Reinforcement Learning. На странице курса вы можете зарегистрироваться на бесплатные уроки по темам: