Архитектуры RL: DDPG иPPO04.11.2023 16:45

a952e85cfdb9bc31a37ae9949bda4fd9.jpg

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

В 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) определяется следующим образом:

L_actor(θ) = -E[R(π(s|θ))]

где R (π (s|θ)) представляет ожидаемое накопленное вознаграждение при использовании политики π (s|θ).

Критик (Critic) оценивает Q-функцию, которая оценивает ожидаемую сумму наград для заданных состояний и действий. Функция потерь критика (L_critic) определяется следующим образом:

L_critic(θ') = E[(Q(s, a|θ') - Q_target(s, a))^2]

где 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 определяется следующим образом:

L_actor(θ) = E[min(r(θ) * A, clip(r(θ), 1 - ε, 1 + ε) * A)]

где:

  • θ — параметры политики.

  • r (θ) = π (a|s) / π_old (a|s) — отношение вероятностей новой и старой политики.

  • A — преимущество действия, оцениваемое критиком (оценщиком).

  • ε — параметр обрезки (clipping), который ограничивает изменения в политике.

PPO включает механизм обрезки (clipping), который ограничивает, насколько сильно можно изменить политику на каждом шаге. Это делает алгоритм более стабильным и предсказуемым.

Функция потерь критика (Critic Loss) оценивает, насколько оценки Q-функции согласуются с ожидаемыми наградами:

L_critic(θ') = E[(Q(s, a|θ') - R(π))^2]

где:

  • θ' — параметры критика.

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

© Habrahabr.ru