Архитектуры RL: DDPG иPPO

Привет, уважаемые читатели Хабра!

В 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 :

1. Оценка Q-функции:

   В DDPG используется Q-функция (функция оценки долгосрочной награды), как и в DQN. Однако, вместо дискретных действий, DDPG работает с непрерывными действиями, что делает его подходящим для задач, где агенту нужно выбирать значения из непрерывного диапазона.

2. Параметрическая стратегия:

   DDPG использует параметрическую стратегию, которая представляет собой нейронную сеть, принимающую состояния среды и предсказывающую действия. Эта стратегия обучается на основе градиента, что делает его методом, основанным на политике (policy-based).

3. Целевые сети:

   Для обеспечения стабильности в обучении, 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 зависит от ряда факторов:

1. Непрерывные действия: Если ваша задача включает в себя непрерывные действия, то DDPG может быть хорошим выбором.

2. Средний размер пространства действий и состояний: DDPG подходит для задач с средними или большими размерами пространств состояний и действий.

3. Требования к стабильности: Если вам важна стабильность в обучении и вы готовы потратить время на настройку гиперпараметров, DDPG может быть вашим выбором.

4. Доступность библиотек: Множество фреймворков 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-функции.

Основные принципы:

1. Политика и стратегия:

   В PPO, центральным понятием является политика (policy) или стратегия, которая определяет, какие действия агент должен предпринимать в ответ на состояния среды. Политика обычно представлена нейронной сетью.

2. Объект функции потерь:

   PPO оптимизирует функцию потерь, которая является комбинацией нескольких компонентов. Основными компонентами являются функция потерь для политики (policy loss) и функция потерь для оценки значений состояний (value loss).

3. Оптимизация стратегии:

   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 для вашей задачи зависит от следующих факторов:

1. Требования к стабильности: Если вам важна стабильность в обучении и вы не хотите тратить много времени на настройку гиперпараметров, PPO может быть хорошим выбором.

2. Средний размер пространства действий и состояний: PPO работает хорошо в задачах с средними или большими размерами пространств состояний и действий.

3. Доступность библиотек: PPO легко реализовать с использованием популярных библиотек машинного обучения, что упрощает его применение.

4. Количество доступных обучающих данных: PPO может потребовать большое количество данных для стабильного обучения, поэтому убедитесь, что у вас есть доступ к достаточному объему данных.

При выборе PPO для своей задачи также учтите, что этот алгоритм, как и многие другие в RL, требует экспериментов и итераций для настройки и оптимизации.

Другие популярные архитектуры RL

A3C (Asynchronous Advantage Actor-Critic)

A3C (Asynchronous Advantage Actor-Critic) — это алгоритм обучения с подкреплением, который применяет метод Actor-Critic с использованием асинхронного обучения на нескольких агентах. Он был разработан для обучения агентов на многозадачных и многопроцессорных системах.

1. Преимущества A3C:

   • Способность обучать агентов на многозадачных системах.

   • Скорость обучения благодаря асинхронному методу.

   • Применим в различных задачах, включая игры и робототехнику.

2. Пример кода 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 для гарантированного улучшения политики на каждом шаге. Это делает его стабильным и надежным алгоритмом.

1. Преимущества TRPO:

   • Стабильное обучение и гарантированное улучшение политики.

   • Подходит для широкого спектра задач обучения с подкреплением.

2. Пример кода 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:

1. Эффективный и широко применимый алгоритм для задач с дискретными действиями.

2. Базовая архитектура для более сложных алгоритмов, таких как 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. На странице курса вы можете зарегистрироваться на бесплатные уроки по темам:

• Применение обучения с подкреплением на финансовых рынках.

• Игры с человеком и компьютером.