Spinning Up: алгоритмы TRPO, DDPG, TD3 и SAC

Где в курсе то же самое проще

Q-обучение, DQN, буфер воспроизведения и целевая сеть — в уроке 6.0.2 «Монте-Карло, TD и Q-learning»; это фундамент DDPG, TD3 и SAC. Идея «не уходить далеко от старой политики», из которой выросли TRPO и PPO, — в уроке 6.0.3. KL-штраф к референсной модели в RLHF — родственник ограничения TRPO: урок 6.3.1. Для курса о LLM важнее всего TRPO; DDPG, TD3 и SAC работают с непрерывными действиями (роботы, управление) и с языковыми моделями почти не встречаются.

Как устроен перевод

Разделы «Основы», псевдокод и «Ссылки» всех четырёх страниц переведены целиком. Раздел «Документация» в оригинале вставляет полные docstring функций для PyTorch и TensorFlow; мы перевели описания всех параметров, но собрали общие для DDPG, TD3 и SAC параметры в одну таблицу, чтобы не повторять их трижды. Псевдокод записан нумерованным списком, формулы — как в оригинале. Абзацы «Словами» добавлены переводчиком.

Trust Region Policy Optimization (TRPO)

Основы

(Раньше: основы VPG)

TRPOTRPO (оптимизация политики в доверительной области)EN trust region policy optimization (TRPO)Schulman и др., 2015 — шаг политики с ограничением на KL к старой политике; предшественник PPO. обновляет политику, делая самый большой возможный шаг улучшения качества и при этом соблюдая особое ограничение на то, насколько близкими должны быть новая и старая политики. Ограничение выражено через KL-дивергенцию — меру (чем-то похожую на расстояние, но не совсем им являющуюся) различия между распределениями вероятностей.

Это отличается от обычного градиента политики, который держит новую и старую политику близкими в пространстве параметров. Но даже, казалось бы, маленькая разница в параметрах может дать очень большую разницу в качестве — так что один неудачный шаг может обрушить качество политики. Поэтому с простым градиентом политики опасно брать большие шаги, и это вредит его эффективности по данным. TRPO изящно избегает такого обрушения и обычно быстро и монотонно улучшает качество.

Коротко

• TRPO — алгоритм с обучением по текущей политике (on-policy).
• TRPO можно применять в средах как с дискретным, так и с непрерывным пространством действий.
• Реализация TRPO в Spinning Up поддерживает распараллеливание через MPI.

Ключевые формулы

Пусть $\pi_{\theta}$ — политика с параметрами $\theta$. Теоретическое обновление TRPO таково:

$$\begin{aligned} \theta_{k+1} = \arg \max_{\theta} \; & {\mathcal L}(\theta_k, \theta) \\ \text{s.t.} \; & \bar{D}_{KL}(\theta || \theta_k) \leq \delta \end{aligned}$$

где ${\mathcal L}(\theta_k, \theta)$ — суррогатное преимущество, мера того, насколько политика $\pi_{\theta}$ лучше старой политики $\pi_{\theta_k}$, посчитанная по данным старой политики:

$${\mathcal L}(\theta_k, \theta) = \underset{s,a \sim \pi_{\theta_k}}{\mathrm{E}}\left[ \frac{\pi_{\theta}(a|s)}{\pi_{\theta_k}(a|s)} A^{\pi_{\theta_k}}(s,a) \right],$$

а $\bar{D}_{KL}(\theta || \theta_k)$ — средняя KL-дивергенция между политиками по состояниям, которые посещала старая политика:

$$\bar{D}_{KL}(\theta || \theta_k) = \underset{s \sim \pi_{\theta_k}}{\mathrm{E}}\left[ D_{KL}\left(\pi_{\theta}(\cdot|s) || \pi_{\theta_k} (\cdot|s) \right) \right].$$

Словами: «s.t.» (subject to) — «при условии». Ищем параметры, при которых суррогатное преимущество максимально, но средняя KL-дивергенция между новой и старой политикой не больше $\delta$ (например, 0,01). Отношение $\pi_{\theta}/\pi_{\theta_k}$ — поправка по значимости (importance samplingвыборка по значимости (importance sampling)EN importance samplingПеревзвешивание сэмплов старой политики отношением π_new / π_old — основа PPO.): данные собраны старой политикой, а оцениваем новую.

Полезно знать

И цель, и ограничение равны нулю при $\theta = \theta_k$. Более того, градиент ограничения по $\theta$ равен нулю при $\theta = \theta_k$. Чтобы доказать эти факты, нужно тонкое владение соответствующей математикой — стоящее упражнение, когда почувствуете, что готовы!

С теоретическим обновлением TRPO работать не очень удобно, поэтому TRPO делает несколько приближений, чтобы быстро получить ответ. Разложим цель и ограничение в ряд Тейлора до главных членов вокруг $\theta_k$:

$$\begin{aligned} {\mathcal L}(\theta_k, \theta) &\approx g^T (\theta - \theta_k) \\ \bar{D}_{KL}(\theta || \theta_k) & \approx \frac{1}{2} (\theta - \theta_k)^T H (\theta - \theta_k) \end{aligned}$$

и получим приближённую задачу оптимизации

$$\begin{aligned} \theta_{k+1} = \arg \max_{\theta} \; & g^T (\theta - \theta_k) \\ \text{s.t.} \; & \frac{1}{2} (\theta - \theta_k)^T H (\theta - \theta_k) \leq \delta. \end{aligned}$$

Словами: цель приближаем линейной функцией (наклон $g$), а KL — квадратичной (матрица $H$ — гессиан KL, она же информационная матрица Фишера). Линейная цель на «эллипсоиде» допустимых шагов — задача, которая решается формулой.

Полезно знать

По счастливому совпадению градиент $g$ суррогатного преимущества по $\theta$, посчитанный при $\theta = \theta_k$, в точности равен градиенту политики $\nabla_{\theta} J(\pi_{\theta})$! Попробуйте доказать это, если уверенно чувствуете себя в математике.

Эту приближённую задачу можно решить аналитически методами двойственности Лагранжа ¹, и решение будет таким:

$$\theta_{k+1} = \theta_k + \sqrt{\frac{2 \delta}{g^T H^{-1} g}} H^{-1} g.$$

Если бы мы на этом остановились и просто использовали этот результат, алгоритм в точности вычислял бы натуральный градиент политики (Natural Policy Gradient). Проблема в том, что из-за ошибок приближения рядом Тейлора такой шаг может не удовлетворять ограничению на KL или на самом деле не улучшать суррогатное преимущество. TRPO добавляет к этому правилу обновления поправку — линейный поиск с возвратом (backtracking line search):

$$\theta_{k+1} = \theta_k + \alpha^j \sqrt{\frac{2 \delta}{g^T H^{-1} g}} H^{-1} g,$$

где $\alpha \in (0,1)$ — коэффициент возврата, а $j$ — наименьшее неотрицательное целое число, при котором $\pi_{\theta_{k+1}}$ удовлетворяет ограничению на KL и даёт положительное суррогатное преимущество.

Словами: сначала пробуем полный шаг ($j = 0$). Если он нарушает ограничение или ухудшает цель — укорачиваем шаг в $\alpha$ раз (например, до 80 %), потом ещё раз, пока не получится.

Наконец: вычислять и хранить обратную матрицу $H^{-1}$ мучительно дорого, когда у нейросетевой политики тысячи или миллионы параметров. TRPO обходит эту проблему с помощью алгоритма сопряжённых градиентов: он решает систему $Hx = g$ относительно $x = H^{-1} g$, и для этого нужна только функция, вычисляющая произведение матрицы на вектор $Hx$, а не вся матрица $H$ целиком. Сделать это не так уж трудно: заводим символьную операцию, вычисляющую

$$Hx = \nabla_{\theta} \left( \left(\nabla_{\theta} \bar{D}_{KL}(\theta || \theta_k)\right)^T x \right),$$

которая даёт правильный результат, не вычисляя всю матрицу.

Словами: сначала берём градиент KL (вектор), скалярно умножаем его на $x$ (получаем число) и ещё раз берём градиент — это произведение гессиана на вектор за два прохода автодифференцирования. Для сети с миллионом параметров матрица $H$ заняла бы $10^{12}$ чисел, а такой приём требует памяти порядка одного вектора.

Исследование и использование

TRPO обучает стохастическую политику on-policy. Это значит, что он исследует среду, выбирая действия по самой свежей версии своей стохастической политики. Насколько случаен выбор действий, зависит и от начальных условий, и от процедуры обучения. По ходу обучения политика обычно становится всё менее случайной, потому что правило обновления подталкивает её использовать награды, которые она уже нашла. Из-за этого политика может застрять в локальном оптимуме.

Псевдокод

Алгоритм 1. Trust Region Policy Optimization

1. Вход: начальные параметры политики $\theta_0$, начальные параметры функции ценности $\phi_0$.
2. Гиперпараметры: предел KL-дивергенции $\delta$, коэффициент возврата $\alpha$, максимальное число шагов возврата $K$.
3. Для $k = 0, 1, 2, \dots$:
   1. Собрать набор траекторий $\mathcal{D}_k = \{\tau_i\}$, запуская в среде политику $\pi_k = \pi(\theta_k)$.
   2. Посчитать reward-to-go $\hat{R}_t$.
   3. Посчитать оценки преимущества $\hat{A}_t$ (любым методом оценки преимущества) на основе текущей функции ценности $V_{\phi_k}$.
   4. Оценить градиент политики: $$\hat{g}_k = \frac{1}{|\mathcal{D}_k|} \sum_{\tau \in \mathcal{D}_k} \sum_{t=0}^T \left. \nabla_{\theta} \log\pi_{\theta}(a_t|s_t)\right|_{\theta_k} \hat{A}_t.$$
   5. Алгоритмом сопряжённых градиентов вычислить $$\hat{x}_k \approx \hat{H}_k^{-1} \hat{g}_k,$$ где $\hat{H}_k$ — гессиан выборочной средней KL-дивергенции.
   6. Обновить политику линейным поиском с возвратом: $$\theta_{k+1} = \theta_k + \alpha^j \sqrt{ \frac{2\delta}{\hat{x}_k^T \hat{H}_k \hat{x}_k}} \hat{x}_k,$$ где $j \in \{0, 1, 2, \dots K\}$ — наименьшее значение, которое улучшает выборочную функцию потерь и удовлетворяет выборочному ограничению на KL-дивергенцию.
   7. Подогнать функцию ценности регрессией по среднеквадратичной ошибке: $$\phi_{k+1} = \arg \min_{\phi} \frac{1}{|\mathcal{D}_k| T} \sum_{\tau \in \mathcal{D}_k} \sum_{t=0}^T\left( V_{\phi} (s_t) - \hat{R}_t \right)^2,$$ обычно каким-нибудь алгоритмом градиентного спуска.

Документация

Полезно знать

Сейчас в Spinning Up есть только реализация TRPO на TensorFlow (spinup.trpo_tf1).

spinup.trpo_tf1(env_fn, actor_critic=<mlp_actor_critic>, ac_kwargs={}, seed=0,
                steps_per_epoch=4000, epochs=50, gamma=0.99, delta=0.01, vf_lr=0.001,
                train_v_iters=80, damping_coeff=0.1, cg_iters=10, backtrack_iters=10,
                backtrack_coeff=0.8, lam=0.97, max_ep_len=1000, logger_kwargs={},
                save_freq=10, algo='trpo')

Trust Region Policy Optimization (с поддержкой натурального градиента политики). Параметры env_fn, ac_kwargs, seed, steps_per_epoch, epochs, gamma, vf_lr, train_v_iters, lam, max_ep_len, logger_kwargs, save_freq значат то же, что у VPG. Особые параметры TRPO:

Параметр	По умолчанию	Смысл
delta	0.01	Предел KL-дивергенции для обновления TRPO / NPG. (Для устойчивости должен быть маленьким: значения вроде 0,01, 0,05.)
damping_coeff	0.1	Костыль для численной устойчивости, должен быть небольшим. Меняет вычисление произведения гессиана на вектор: $Hv \rightarrow (\alpha I + H)v$, где $\alpha$ — коэффициент затухания. Этот гиперпараметр, скорее всего, лучше не трогать
cg_iters	10	Число итераций метода сопряжённых градиентов. Если увеличить, приближение к $H^{-1} g$ станет точнее и качество, возможно, немного вырастет, но ценой замедления. Тоже, скорее всего, лучше не трогать
backtrack_iters	10	Максимальное число шагов в линейном поиске с возвратом. Поиск обычно не возвращается, а если и возвращается, то обычно на один шаг, поэтому этот гиперпараметр редко важен
backtrack_coeff	0.8	Насколько далеко шагать назад при линейном поиске. (Всегда между 0 и 1, обычно больше 0,5.)
algo	'trpo'	Либо 'trpo', либо 'npg': код поддерживает оба, потому что они почти одинаковы

Граф вычислений, который сохраняет логгер, содержит: x — placeholder TensorFlow для входного состояния; pi — сэмплирует действие агента при состояниях из x; v — оценка ценности для состояний из x. К модели можно обратиться через инструмент test_policy.py или загрузить граф функцией restore_tf_graph.

Ссылки

Статьи по теме

• Trust Region Policy Optimization, Schulman et al. 2015
• High Dimensional Continuous Control Using Generalized Advantage Estimation, Schulman et al. 2016
• Approximately Optimal Approximate Reinforcement Learning, Kakade and Langford 2002

Почему эти статьи?

Schulman 2015 включена, потому что это исходная статья с описанием TRPO. Schulman 2016 включена, потому что наша реализация TRPO использует Generalized Advantage Estimation для вычисления градиента политики. Kakade and Langford 2002 включена, потому что в ней есть теоретические результаты, которые мотивируют теоретические основы TRPO и глубоко с ними связаны.

Другие открытые реализации

• Baselines
• ModularRL
• rllab

---

Deep Deterministic Policy Gradient (DDPG)

Основы

(Раньше: Введение в RL, часть 1: оптимальная Q-функция и оптимальное действие)

Deep Deterministic Policy Gradient (DDPG) — алгоритм, который одновременно учит Q-функцию и политику. Q-функцию он учит по off-policy данным с помощью уравнения Беллмана, а политику — с помощью Q-функции.

Этот подход тесно связан с Q-обучениемQ-learningEN Q-learningQ(s,a) ← Q(s,a) + α[r + γ max_a′ Q(s′,a′) − Q(s,a)]. Off-policy: учит Q* при любом поведении. и мотивирован так же: если известна оптимальная функция ценности действия $Q^*(s,a)$, то в любом состоянии оптимальное действие $a^*(s)$ можно найти, решив

$$a^*(s) = \arg \max_a Q^*(s,a).$$

DDPG чередует обучение аппроксиматора $Q^*(s,a)$ с обучением аппроксиматора $a^*(s)$ и делает это способом, специально приспособленным для сред с непрерывным пространством действий. Но что значит, что DDPG приспособлен именно для непрерывных действий? Это связано с тем, как мы вычисляем максимум по действиям в $\max_a Q^*(s,a)$.

Когда дискретных действий конечное число, максимум не проблема: можно просто посчитать Q-значения для каждого действия отдельно и напрямую их сравнить. (Это заодно сразу даёт действие, на котором Q-значение максимально.) Но когда пространство действий непрерывно, перебрать его целиком нельзя, а решать задачу оптимизации совсем не просто. Обычный алгоритм оптимизации сделал бы вычисление $\max_a Q^*(s,a)$ мучительно дорогой подпрограммой. А поскольку её пришлось бы запускать каждый раз, когда агент хочет сделать шаг в среде, это неприемлемо.

Раз пространство действий непрерывно, предполагается, что функция $Q^*(s,a)$ дифференцируема по аргументу-действию. Это позволяет построить эффективное правило обучения политики $\mu(s)$ на основе градиента, которое пользуется этим фактом. Тогда вместо дорогой подпрограммы оптимизации при каждом вычислении $\max_a Q(s,a)$ можно приблизить его: $\max_a Q(s,a) \approx Q(s,\mu(s))$. Подробности — в разделе «Ключевые формулы».

Коротко

• DDPG — алгоритм с обучением вне текущей политикиoff-policy (обучение на данных другой политики)EN off-policyПолитика, которую учим, отличается от той, что собирала данные. Пример — Q-learning; в PPO и GRPO — поправка π/π_old. (off-policy).
• DDPG можно применять только в средах с непрерывным пространством действий.
• DDPG можно считать глубоким Q-обучением для непрерывных пространств действий.
• Реализация DDPG в Spinning Up не поддерживает распараллеливание.

Ключевые формулы

Здесь мы объясним математику двух частей DDPG: обучения Q-функции и обучения политики.

Q-обучение в DDPG

Сначала напомним уравнение Беллмана для оптимальной функции ценности действия $Q^*(s,a)$. Оно имеет вид

$$Q^*(s,a) = \underset{s' \sim P}{{\mathrm E}}\left[r(s,a) + \gamma \max_{a'} Q^*(s', a')\right]$$

где $s' \sim P$ — краткая запись того, что следующее состояние $s'$ среда выбирает из распределения $P(\cdot| s,a)$.

Это уравнение Беллмана — отправная точка для обучения аппроксиматора $Q^*(s,a)$. Пусть аппроксиматор — нейросеть $Q_{\phi}(s,a)$ с параметрами $\phi$, и мы собрали набор $\mathcal{D}$ переходов $(s,a,r,s',d)$ (где $d$ показывает, терминально ли состояние $s'$). Можно построить функцию среднеквадратичной ошибки Беллмана (mean-squared Bellman error, MSBE), которая грубо показывает, насколько $Q_{\phi}$ близка к тому, чтобы удовлетворять уравнению Беллмана:

$$L(\phi, {\mathcal D}) = \underset{(s,a,r,s',d) \sim {\mathcal D}}{{\mathrm E}}\left[ \Bigg( Q_{\phi}(s,a) - \left(r + \gamma (1 - d) \max_{a'} Q_{\phi}(s',a') \right) \Bigg)^2 \right]$$

Здесь, вычисляя $(1-d)$, мы пользуемся соглашением Python, по которому True равно 1, а False — 0. Поэтому когда d==True — то есть когда $s'$ терминальное состояние, — Q-функция должна показывать, что после текущего состояния агент не получит дополнительных наград. (Такой выбор обозначений соответствует тому, что мы потом реализуем в коде.)

Алгоритмы Q-обучения с аппроксиматорами функций, такие как DQNDQN (глубокая Q-сеть)EN deep Q-network (DQN)Mnih и др., 2015 — Q-learning с нейросетью, буфером воспроизведения и целевой сетью; играл в Atari по пикселям. (и все его варианты) и DDPG, в основном построены на минимизации этой функции потерь MSBE. Все они используют два главных приёма, которые стоит описать, и ещё одну особую деталь DDPG.

Приём первый: буферы воспроизведения. Все стандартные алгоритмы обучения глубокой нейросети, приближающей $Q^*(s,a)$, используют буфер воспроизведения опытабуфер воспроизведения (replay buffer)EN experience replay bufferХранилище прошлых переходов (s, a, r, s′), из которого сэмплируют случайные мини-батчи. (experience replay buffer). Это и есть множество $\mathcal{D}$ прошлого опыта. Чтобы алгоритм вёл себя устойчиво, буфер должен быть достаточно большим, чтобы вмещать широкий спектр опыта, но не всегда хорошо хранить всё подряд. Если использовать только самые свежие данные, модель на них переобучится и всё сломается; если использовать слишком много опыта, обучение может замедлиться. Чтобы найти баланс, может понадобиться настройка.

Полезно знать

Мы упомянули, что DDPG — off-policy алгоритм; сейчас самое время подчеркнуть, почему и как. Обратите внимание: буфер воспроизведения должен содержать старый опыт, хотя он мог быть получен устаревшей политикой. Почему его вообще можно использовать? Потому что уравнению Беллмана неважно, какие кортежи переходов используются, как выбирались действия и что происходит после данного перехода: оптимальная Q-функция должна удовлетворять уравнению Беллмана для всех возможных переходов. Поэтому любые переходы, которые мы когда-либо видели, годятся для подгонки аппроксиматора Q-функции минимизацией MSBE.

Приём второй: целевые сети. Алгоритмы Q-обучения используют целевые сетицелевая сеть (target network)EN target networkЗамороженная копия Q-сети для вычисления цели r + γ max Q; её веса обновляют редко. (target networks). Выражение

$$r + \gamma (1 - d) \max_{a'} Q_{\phi}(s',a')$$

называется целью (target), потому что, минимизируя потери MSBE, мы пытаемся сделать Q-функцию похожей на эту цель. Беда в том, что цель зависит от тех же параметров $\phi$, которые мы обучаем. Из-за этого минимизация MSBE неустойчива. Решение — использовать набор параметров, близкий к $\phi$, но с запаздыванием: вторую сеть, называемую целевой, которая отстаёт от первой. Параметры целевой сети обозначают $\phi_{\text{targ}}$.

В алгоритмах на основе DQN целевую сеть просто копируют из основной раз в фиксированное число шагов. В алгоритмах в стиле DDPG целевая сеть обновляется при каждом обновлении основной сети усреднением Поляка (polyak averaging):

$$\phi_{\text{targ}} \leftarrow \rho \phi_{\text{targ}} + (1 - \rho) \phi,$$

где $\rho$ — гиперпараметр от 0 до 1 (обычно близкий к 1). (В нашем коде этот гиперпараметр называется polyak.)

Словами: при $\rho = 0{,}995$ целевая сеть на каждом шаге сдвигается к основной всего на 0,5 % — это экспоненциальное скользящее среднееэкспоненциальное скользящее среднее (EMA)EN exponential moving average (EMA)m ← βm + (1 − β)x. Помнит примерно последние 1/(1 − β) значений; при β = 0.9 — около 10. весов, которое отстаёт примерно на $1/(1-\rho) = 200$ обновлений.

Деталь DDPG: вычисление максимума по действиям в цели. Как говорилось выше, вычислить максимум по действиям в цели трудно, когда пространство действий непрерывно. DDPG справляется с этим, используя целевую сеть политики (target policy network), которая вычисляет действие, приблизительно максимизирующее $Q_{\phi_{\text{targ}}}$. Целевая сеть политики получается так же, как целевая Q-функция: усреднением Поляка параметров политики по ходу обучения.

Собирая всё вместе, Q-обучение в DDPG выполняется минимизацией следующей функции потерь MSBE стохастическим градиентным спуском:

$$L(\phi, {\mathcal D}) = \underset{(s,a,r,s',d) \sim {\mathcal D}}{{\mathrm E}}\left[ \Bigg( Q_{\phi}(s,a) - \left(r + \gamma (1 - d) Q_{\phi_{\text{targ}}}(s', \mu_{\theta_{\text{targ}}}(s')) \right) \Bigg)^2 \right],$$

где $\mu_{\theta_{\text{targ}}}$ — целевая политика.

Обучение политики в DDPG

Обучение политики в DDPG довольно простое. Мы хотим выучить детерминированную политику $\mu_{\theta}(s)$, которая выдаёт действие, максимизирующее $Q_{\phi}(s,a)$. Раз пространство действий непрерывно и мы предполагаем, что Q-функция дифференцируема по действию, можно просто делать градиентный подъём (только по параметрам политики), чтобы решить

$$\max_{\theta} \underset{s \sim {\mathcal D}}{{\mathrm E}}\left[ Q_{\phi}(s, \mu_{\theta}(s)) \right].$$

Обратите внимание: параметры Q-функции здесь считаются константами.

Словами: критик $Q_{\phi}$ подсказывает, в какую сторону сдвинуть действие, чтобы оценка выросла ($\nabla_a Q$), а цепное правило переносит эту подсказку на параметры политики: $\nabla_{\theta} Q(s, \mu_{\theta}(s)) = \nabla_a Q(s,a)\big|_{a=\mu_{\theta}(s)} \nabla_{\theta} \mu_{\theta}(s)$.

Исследование и использование

DDPG обучает детерминированную политику off-policy. Поскольку политика детерминированная, при исследовании по текущей политике агент в начале, скорее всего, не попробовал бы достаточно разнообразных действий, чтобы найти полезные обучающие сигналы. Чтобы политики DDPG лучше исследовали среду, мы во время обучения добавляем к их действиям шум. Авторы исходной статьи о DDPG рекомендовали коррелированный во времени шум Орнштейна — Уленбека (OU noise), но более свежие результаты говорят, что некоррелированный гауссов шум с нулевым средним работает ничуть не хуже. Поскольку последний проще, он предпочтительнее. Чтобы получать более качественные обучающие данные, масштаб шума можно уменьшать по ходу обучения. (В нашей реализации мы этого не делаем и держим масштаб шума постоянным.)

Во время тестирования, чтобы увидеть, насколько хорошо политика использует выученное, мы не добавляем к действиям шум.

Полезно знать

Наша реализация DDPG использует приём, улучшающий исследование в начале обучения. Первые несколько шагов (их число задаёт аргумент start_steps) агент выбирает действия равномерно случайно из допустимых. После этого он возвращается к обычному исследованию DDPG.

Псевдокод

Алгоритм 1. Deep Deterministic Policy Gradient

1. Вход: начальные параметры политики $\theta$, параметры Q-функции $\phi$, пустой буфер воспроизведения $\mathcal{D}$.
2. Приравнять целевые параметры к основным: $\theta_{\text{targ}} \leftarrow \theta$, $\phi_{\text{targ}} \leftarrow \phi$.
3. Повторять:
   1. Наблюдать состояние $s$ и выбрать действие $a = \text{clip}(\mu_{\theta}(s) + \epsilon, a_{Low}, a_{High})$, где $\epsilon \sim \mathcal{N}$.
   2. Выполнить $a$ в среде.
   3. Наблюдать следующее состояние $s'$, награду $r$ и сигнал завершения $d$, показывающий, терминально ли $s'$.
   4. Сохранить $(s,a,r,s',d)$ в буфер воспроизведения $\mathcal{D}$.
   5. Если $s'$ терминально, сбросить среду.
   6. Если пора обновляться, то столько раз, сколько нужно обновлений:
      1. Случайно выбрать из $\mathcal{D}$ батч переходов $B = \{ (s,a,r,s',d) \}$.
      2. Вычислить цели $$y(r,s',d) = r + \gamma (1-d) Q_{\phi_{\text{targ}}}(s', \mu_{\theta_{\text{targ}}}(s'))$$
      3. Обновить Q-функцию одним шагом градиентного спуска по $$\nabla_{\phi} \frac{1}{|B|}\sum_{(s,a,r,s',d) \in B} \left( Q_{\phi}(s,a) - y(r,s',d) \right)^2$$
      4. Обновить политику одним шагом градиентного подъёма по $$\nabla_{\theta} \frac{1}{|B|}\sum_{s \in B}Q_{\phi}(s, \mu_{\theta}(s))$$
      5. Обновить целевые сети: $$\begin{aligned} \phi_{\text{targ}} &\leftarrow \rho \phi_{\text{targ}} + (1-\rho) \phi \\ \theta_{\text{targ}} &\leftarrow \rho \theta_{\text{targ}} + (1-\rho) \theta \end{aligned}$$
4. До сходимости.

Документация

У DDPG есть реализации на PyTorch (spinup.ddpg_pytorch) и TensorFlow (spinup.ddpg_tf1) с почти одинаковыми вызовами. Параметры общие для DDPG, TD3 и SAC собраны в таблицу после SAC; особый параметр DDPG:

Параметр	По умолчанию	Смысл
act_noise	0.1	Стандартное отклонение гауссова шума для исследования, добавляемого к политике во время обучения. (Во время теста шум не добавляется.)

Сохранённую модель PyTorch можно загрузить командой ac = torch.load('path/to/model.pt') — получится объект актор-критика (ac) со свойствами, описанными в docstring функции ddpg_pytorch. Действия из неё: actions = ac.act(torch.as_tensor(obs, dtype=torch.float32)).

Граф TensorFlow, который сохраняет логгер, содержит: x — placeholder для входного состояния; a — placeholder для входного действия; pi — детерминированно вычисляет действие агента при состояниях из x; q — оценка ценности действия для состояний из x и действий из a.

Ссылки

Статьи по теме

• Deterministic Policy Gradient Algorithms, Silver et al. 2014
• Continuous Control With Deep Reinforcement Learning, Lillicrap et al. 2016

Почему эти статьи?

Silver 2014 включена, потому что в ней заложена теория детерминированных градиентов политики (DPG). Lillicrap 2016 включена, потому что в ней теоретически обоснованный алгоритм DPG адаптирован к глубокому RL — так получился DDPG.

Другие открытые реализации

• Baselines
• rllab
• rllib (Ray)
• TD3 release repo

---

Twin Delayed DDPG (TD3)

Основы

(Раньше: основы DDPG)

DDPG иногда показывает отличное качество, но часто капризен к гиперпараметрам и прочим настройкам. Типичный сбой DDPG: выученная Q-функция начинает резко завышать Q-значения, и тогда ломается политика, потому что она эксплуатирует ошибки Q-функции. Twin Delayed DDPG (TD3) — алгоритм, который решает эту проблему тремя ключевыми приёмами:

Приём первый: обрезанное двойное Q-обучение (clipped double-Q learning). TD3 учит две Q-функции вместо одной (отсюда «twin», «близнецы») и для целей в функциях потерь ошибки Беллмана берёт меньшее из двух Q-значений.

Приём второй: «отложенные» обновления политики. TD3 обновляет политику (и целевые сети) реже, чем Q-функцию. Статья рекомендует одно обновление политики на каждые два обновления Q-функции.

Приём третий: сглаживание целевой политики (target policy smoothing). TD3 добавляет шум к целевому действию, чтобы политике было труднее эксплуатировать ошибки Q-функции: шум сглаживает Q вдоль изменений действия.

Вместе эти три приёма дают заметно лучшее качество, чем базовый DDPG.

Коротко

• TD3 — алгоритм с обучением вне текущей политики (off-policy).
• TD3 можно применять только в средах с непрерывным пространством действий.
• Реализация TD3 в Spinning Up не поддерживает распараллеливание.

Ключевые формулы

TD3 одновременно учит две Q-функции, $Q_{\phi_1}$ и $Q_{\phi_2}$, минимизацией среднеквадратичной ошибки Беллмана — почти так же, как DDPG учит свою единственную Q-функцию. Чтобы показать, как именно TD3 это делает и чем он отличается от обычного DDPG, пойдём от самой внутренней части функции потерь наружу.

Первое: сглаживание целевой политики. Действия, по которым строится цель Q-обучения, берутся из целевой политики $\mu_{\theta_{\text{targ}}}$, но к каждой координате действия добавляется обрезанный шум. После добавления обрезанного шума целевое действие обрезается так, чтобы лежать в допустимом диапазоне (все допустимые действия $a$ удовлетворяют $a_{Low} \leq a \leq a_{High}$). Итак, целевые действия:

$$a'(s') = \text{clip}\left(\mu_{\theta_{\text{targ}}}(s') + \text{clip}(\epsilon,-c,c), a_{Low}, a_{High}\right), \;\;\;\;\; \epsilon \sim \mathcal{N}(0, \sigma)$$

Сглаживание целевой политики по сути служит регуляризатором алгоритма. Оно устраняет особый сбой, который случается в DDPG: если у аппроксиматора Q-функции появляется ложный острый пик на каких-то действиях, политика быстро начинает его эксплуатировать и ведёт себя хрупко или неправильно. Этого можно избежать, сгладив Q-функцию по похожим действиям, — для этого и придумано сглаживание целевой политики.

Далее: обрезанное двойное Q-обучение. Обе Q-функции используют одну общую цель, вычисленную по той из двух Q-функций, которая даёт меньшее значение цели:

$$y(r,s',d) = r + \gamma (1 - d) \min_{i=1,2} Q_{\phi_{i, \text{targ}}}(s', a'(s')),$$

и обе учатся регрессией к этой цели:

$$L(\phi_1, {\mathcal D}) = \underset{(s,a,r,s',d) \sim {\mathcal D}}{\mathrm{E}}\left[ \Bigg( Q_{\phi_1}(s,a) - y(r,s',d) \Bigg)^2 \right],$$ $$L(\phi_2, {\mathcal D}) = \underset{(s,a,r,s',d) \sim {\mathcal D}}{\mathrm{E}}\left[ \Bigg( Q_{\phi_2}(s,a) - y(r,s',d) \Bigg)^2 \right].$$

Если брать для цели меньшее Q-значение и регрессировать к нему, это помогает не допустить завышения Q-функции.

Словами: у каждой из двух сетей свои случайные ошибки. Если одна завысила оценку, а другая нет, минимум возьмёт более скромную — систематическое завышение «через максимум» сменяется лёгким занижением, которое для обучения безопаснее.

Наконец, политика учится просто максимизацией $Q_{\phi_1}$:

$$\max_{\theta} \underset{s \sim {\mathcal D}}{{\mathrm E}}\left[ Q_{\phi_1}(s, \mu_{\theta}(s)) \right],$$

что почти не отличается от DDPG. Но в TD3 политика обновляется реже, чем Q-функции. Это помогает гасить нестабильность, которая обычно возникает в DDPG из-за того, что обновление политики меняет цель.

Исследование и использование

TD3 обучает детерминированную политику off-policy. Поскольку политика детерминированная, при исследовании по текущей политике агент в начале, скорее всего, не попробовал бы достаточно разнообразных действий, чтобы найти полезные обучающие сигналы. Чтобы политики TD3 лучше исследовали среду, мы во время обучения добавляем к их действиям шум, обычно некоррелированный гауссов шум с нулевым средним. Чтобы получать более качественные обучающие данные, масштаб шума можно уменьшать по ходу обучения. (В нашей реализации мы этого не делаем и держим масштаб шума постоянным.)

Во время тестирования, чтобы увидеть, насколько хорошо политика использует выученное, мы не добавляем к действиям шум.

Полезно знать

Наша реализация TD3 использует приём, улучшающий исследование в начале обучения. Первые несколько шагов (их число задаёт аргумент start_steps) агент выбирает действия равномерно случайно из допустимых. После этого он возвращается к обычному исследованию TD3.

Псевдокод

Алгоритм 1. Twin Delayed DDPG

1. Вход: начальные параметры политики $\theta$, параметры Q-функций $\phi_1$, $\phi_2$, пустой буфер воспроизведения $\mathcal{D}$.
2. Приравнять целевые параметры к основным: $\theta_{\text{targ}} \leftarrow \theta$, $\phi_{\text{targ},1} \leftarrow \phi_1$, $\phi_{\text{targ},2} \leftarrow \phi_2$.
3. Повторять:
   1. Наблюдать состояние $s$ и выбрать действие $a = \text{clip}(\mu_{\theta}(s) + \epsilon, a_{Low}, a_{High})$, где $\epsilon \sim \mathcal{N}$.
   2. Выполнить $a$ в среде.
   3. Наблюдать следующее состояние $s'$, награду $r$ и сигнал завершения $d$, показывающий, терминально ли $s'$.
   4. Сохранить $(s,a,r,s',d)$ в буфер воспроизведения $\mathcal{D}$.
   5. Если $s'$ терминально, сбросить среду.
   6. Если пора обновляться, то для $j$ от 0 до нужного числа обновлений:
      1. Случайно выбрать из $\mathcal{D}$ батч переходов $B = \{ (s,a,r,s',d) \}$.
      2. Вычислить целевые действия $$a'(s') = \text{clip}\left(\mu_{\theta_{\text{targ}}}(s') + \text{clip}(\epsilon,-c,c), a_{Low}, a_{High}\right), \;\;\;\;\; \epsilon \sim \mathcal{N}(0, \sigma)$$
      3. Вычислить цели $$y(r,s',d) = r + \gamma (1-d) \min_{i=1,2} Q_{\phi_{\text{targ},i}}(s', a'(s'))$$
      4. Обновить Q-функции одним шагом градиентного спуска по $$\nabla_{\phi_i} \frac{1}{|B|}\sum_{(s,a,r,s',d) \in B} \left( Q_{\phi_i}(s,a) - y(r,s',d) \right)^2 \qquad \text{для } i=1,2$$
      5. Если $j \bmod$ policy_delay $= 0$:
         • обновить политику одним шагом градиентного подъёма по $$\nabla_{\theta} \frac{1}{|B|}\sum_{s \in B}Q_{\phi_1}(s, \mu_{\theta}(s))$$
         • обновить целевые сети: $$\begin{aligned} \phi_{\text{targ},i} &\leftarrow \rho \phi_{\text{targ}, i} + (1-\rho) \phi_i \qquad \text{для } i=1,2\\ \theta_{\text{targ}} &\leftarrow \rho \theta_{\text{targ}} + (1-\rho) \theta \end{aligned}$$
4. До сходимости.

Документация

У TD3 есть реализации на PyTorch (spinup.td3_pytorch) и TensorFlow (spinup.td3_tf1). Общие параметры — в таблице после SAC; особые параметры TD3:

Параметр	По умолчанию	Смысл
act_noise	0.1	Стандартное отклонение гауссова шума для исследования, добавляемого к политике во время обучения. (Во время теста шум не добавляется.)
target_noise	0.2	Стандартное отклонение сглаживающего шума, добавляемого к целевой политике ($\sigma$ в формулах)
noise_clip	0.5	Предел для модуля сглаживающего шума целевой политики ($c$ в формулах)
policy_delay	2	Политика обновляется только один раз на каждые policy_delay обновлений Q-сетей

Сохранённая модель PyTorch загружается так же, как у DDPG. Граф TensorFlow содержит: x и a — placeholder для состояния и действия; pi — детерминированно вычисляет действие при состояниях из x; q1 — одна оценка ценности действия для x и a; q2 — другая оценка ценности действия для x и a.

Ссылки

Статьи по теме

• Addressing Function Approximation Error in Actor-Critic Methods, Fujimoto et al, 2018

Другие открытые реализации

• TD3 release repo

---

Soft Actor-Critic (SAC)

Основы

(Раньше: основы TD3)

Soft Actor Critic (SAC) — алгоритм, который оптимизирует стохастическую политику off-policy; он служит мостом между стохастической оптимизацией политики и подходами в стиле DDPG. Это не прямой наследник TD3 (они опубликованы примерно одновременно), но SAC использует приём обрезанного двойного Q, а благодаря стохастичности, присущей политике SAC, в итоге получает и что-то вроде сглаживания целевой политики.

Центральная особенность SAC — регуляризация энтропией. Политика обучается максимизировать компромисс между ожидаемой отдачей и энтропией — мерой случайности политики. Это тесно связано с компромиссом между исследованием и использованием: рост энтропии ведёт к большему исследованию, что может ускорить обучение в дальнейшем. Он также может помешать политике преждевременно сойтись к плохому локальному оптимуму.

Коротко

• SAC — алгоритм с обучением вне текущей политики (off-policy).
• Реализованная здесь версия SAC применима только в средах с непрерывным пространством действий.
• Альтернативную версию SAC, слегка меняющую правило обновления политики, можно реализовать для дискретных пространств действий.
• Реализация SAC в Spinning Up не поддерживает распараллеливание.

Ключевые формулы

Чтобы объяснить Soft Actor Critic, сначала нужно ввести постановку RL с регуляризацией энтропией. В ней формулы для функций ценности немного другие.

RL с регуляризацией энтропией

Энтропияэнтропия (информационная)EN (Shannon) entropyH(p) = −Σ p log p — среднее «удивление», мера неопределённости распределения. Максимальна у равномерного распределения. — величина, которая, грубо говоря, показывает, насколько случайна случайная величина. Если монета утяжелена так, что почти всегда выпадает орлом, у неё низкая энтропия; если она честная и оба исхода выпадают с вероятностью половина, у неё высокая энтропия.

Пусть $x$ — случайная величина с функцией вероятности или плотностью $P$. Энтропия $H$ величины $x$ вычисляется по её распределению $P$ так:

$$H(P) = \underset{x \sim P}{\mathrm{E}}\left[-\log P(x)\right].$$

Словами и числами: честная монета: $H = -(0{,}5 \ln 0{,}5 + 0{,}5 \ln 0{,}5) = \ln 2 \approx 0{,}69$ нат; монета с орлом в 99 % случаев: $H = -(0{,}99 \ln 0{,}99 + 0{,}01 \ln 0{,}01) \approx 0{,}056$ нат.

В RL с регуляризацией энтропией агент на каждом шаге получает бонус к награде, пропорциональный энтропии политики на этом шаге. Это меняет задачу RL на такую:

$$\pi^* = \arg \max_{\pi} \underset{\tau \sim \pi}{\mathrm{E}}\left[ \sum_{t=0}^{\infty} \gamma^t \bigg( R(s_t, a_t, s_{t+1}) + \alpha H\left(\pi(\cdot|s_t)\right) \bigg)\right],$$

где $\alpha > 0$ — коэффициент компромисса. (Примечание: здесь и далее на этой странице мы предполагаем бесконечный горизонт с дисконтированием.) Теперь можно определить немного другие функции ценности в этой постановке. $V^{\pi}$ меняется так, чтобы включать бонусы за энтропию на каждом шаге:

$$V^{\pi}(s) = \underset{\tau \sim \pi}{\mathrm{E}}\left[ \left. \sum_{t=0}^{\infty} \gamma^t \bigg( R(s_t, a_t, s_{t+1}) + \alpha H\left(\pi(\cdot|s_t)\right) \bigg) \right| s_0 = s\right]$$

$Q^{\pi}$ меняется так, чтобы включать бонусы за энтропию на каждом шаге, кроме первого:

$$Q^{\pi}(s,a) = \underset{\tau \sim \pi}{\mathrm{E}}\left[ \left. \sum_{t=0}^{\infty} \gamma^t R(s_t, a_t, s_{t+1}) + \alpha \sum_{t=1}^{\infty} \gamma^t H\left(\pi(\cdot|s_t)\right)\right| s_0 = s, a_0 = a\right]$$

При таких определениях $V^{\pi}$ и $Q^{\pi}$ связаны соотношением

$$V^{\pi}(s) = \underset{a \sim \pi}{\mathrm{E}}\left[Q^{\pi}(s,a)\right] + \alpha H\left(\pi(\cdot|s)\right)$$

а уравнение Беллмана для $Q^{\pi}$ имеет вид

$$\begin{aligned} Q^{\pi}(s,a) &= \underset{\substack{s' \sim P \\ a' \sim \pi}}{\mathrm{E}}\left[R(s,a,s') + \gamma\left(Q^{\pi}(s',a') + \alpha H\left(\pi(\cdot|s')\right) \right)\right] \\ &= \underset{s' \sim P}{\mathrm{E}}\left[R(s,a,s') + \gamma V^{\pi}(s')\right]. \end{aligned}$$

Полезно знать

То, как мы задали функции ценности в постановке с регуляризацией энтропией, немного произвольно, и на самом деле можно было сделать иначе (например, включить в $Q^{\pi}$ бонус за энтропию на первом шаге). Выбор определения может немного различаться от статьи к статье.

Soft Actor-Critic

SAC одновременно учит политику $\pi_{\theta}$ и две Q-функции $Q_{\phi_1}, Q_{\phi_2}$. Сейчас стандартны два варианта SAC: один использует фиксированный коэффициент регуляризации энтропией $\alpha$, а другой обеспечивает ограничение на энтропию, меняя $\alpha$ по ходу обучения. Для простоты Spinning Up использует версию с фиксированным коэффициентом, но практики обычно предпочитают вариант с ограничением на энтропию.

Полезно знать

Алгоритм SAC со временем немного менялся. Более старая версия SAC кроме Q-функций учит ещё и функцию ценности $V_{\psi}$; эта страница посвящена современной версии, в которой лишней функции ценности нет.

Обучение Q. Q-функции учатся похоже на TD3, но с несколькими ключевыми отличиями.

Сначала — что похоже?

1. Как и в TD3, обе Q-функции учатся минимизацией MSBE, регрессией к одной общей цели.
2. Как и в TD3, общая цель вычисляется с помощью целевых Q-сетей, а целевые Q-сети получаются усреднением Поляка параметров Q-сетей по ходу обучения.
3. Как и в TD3, общая цель использует приём обрезанного двойного Q.

Что отличается?

1. В отличие от TD3, в цели есть ещё слагаемое, которое появляется из-за регуляризации энтропией в SAC.
2. В отличие от TD3, действия в следующем состоянии, используемые в цели, берутся из текущей политики, а не из целевой политики.
3. В отличие от TD3, явного сглаживания целевой политики нет. TD3 учит детерминированную политику и поэтому сглаживает, добавляя случайный шум к действиям в следующем состоянии. SAC учит стохастическую политику, и шума от этой стохастичности хватает для похожего эффекта.

Прежде чем дать окончательный вид функции потерь Q, разберёмся, как в неё входит вклад регуляризации энтропией. Начнём с рекурсивного уравнения Беллмана для $Q^{\pi}$ с регуляризацией энтропией и немного перепишем его, используя определение энтропии:

$$\begin{aligned} Q^{\pi}(s,a) &= \underset{\substack{s' \sim P \\ a' \sim \pi}}{\mathrm{E}}\left[R(s,a,s') + \gamma\left(Q^{\pi}(s',a') + \alpha H\left(\pi(\cdot|s')\right) \right)\right] \\ &= \underset{\substack{s' \sim P \\ a' \sim \pi}}{\mathrm{E}}\left[R(s,a,s') + \gamma\left(Q^{\pi}(s',a') - \alpha \log \pi(a'|s') \right)\right] \end{aligned}$$

Правая часть — матожидание по следующим состояниям (они берутся из буфера воспроизведения) и следующим действиям (они берутся из текущей политики, а не из буфера воспроизведения). Раз это матожидание, его можно приблизить выборкой:

$$Q^{\pi}(s,a) \approx r + \gamma\left(Q^{\pi}(s',\tilde{a}') - \alpha \log \pi(\tilde{a}'|s') \right), \;\;\;\;\; \tilde{a}' \sim \pi(\cdot|s').$$

Полезно знать

Мы обозначаем следующее действие $\tilde{a}'$, а не $a'$, чтобы подчеркнуть: следующие действия нужно заново сэмплировать из политики (тогда как $r$ и $s'$, наоборот, должны браться из буфера воспроизведения).

SAC строит функцию потерь MSBE для каждой Q-функции с помощью такого выборочного приближения цели. Не определено осталось только одно: какую Q-функцию использовать для выборочного подсчёта цели. Как и TD3, SAC использует приём обрезанного двойного Q и берёт минимальное Q-значение из двух аппроксиматоров.

Собирая всё вместе, функции потерь для Q-сетей в SAC таковы:

$$L(\phi_i, {\mathcal D}) = \underset{(s,a,r,s',d) \sim {\mathcal D}}{{\mathrm E}}\left[ \Bigg( Q_{\phi_i}(s,a) - y(r,s',d) \Bigg)^2 \right],$$

где цель задаётся так:

$$y(r, s', d) = r + \gamma (1 - d) \left( \min_{j=1,2} Q_{\phi_{\text{targ},j}}(s', \tilde{a}') - \alpha \log \pi_{\theta}(\tilde{a}'|s') \right), \;\;\;\;\; \tilde{a}' \sim \pi_{\theta}(\cdot|s').$$

Обучение политики. Политика в каждом состоянии должна действовать так, чтобы максимизировать ожидаемую будущую отдачу плюс ожидаемую будущую энтропию. То есть она должна максимизировать $V^{\pi}(s)$, которую мы раскрываем так:

$$\begin{aligned} V^{\pi}(s) &= \underset{a \sim \pi}{\mathrm{E}}\left[Q^{\pi}(s,a)\right] + \alpha H\left(\pi(\cdot|s)\right) \\ &= \underset{a \sim \pi}{\mathrm{E}}\left[Q^{\pi}(s,a) - \alpha \log \pi(a|s)\right]. \end{aligned}$$

Способ, которым мы оптимизируем политику, использует трюк с репараметризациейтрюк репараметризацииEN reparameterization trickz = μ + σ·ε, ε ~ N(0, 1): случайность выносится во вход, и градиент проходит к μ и σ: выборка из $\pi_{\theta}(\cdot|s)$ получается вычислением детерминированной функции от состояния, параметров политики и независимого шума. Для иллюстрации: вслед за авторами статьи о SAC мы используем «сплющенную» гауссову политику (squashed Gaussian policy), то есть выборки получаются так:

$$\tilde{a}_{\theta}(s, \xi) = \tanh\left( \mu_{\theta}(s) + \sigma_{\theta}(s) \odot \xi \right), \;\;\;\;\; \xi \sim \mathcal{N}(0, I).$$

Полезно знать

У этой политики два ключевых отличия от политик, которые мы используем в других алгоритмах оптимизации политики.

1. Сплющивающая функция. $\tanh$ в политике SAC гарантирует, что действия ограничены конечным диапазоном. В политиках VPG, TRPO и PPO этого нет. Она также меняет распределение: до $\tanh$ политика SAC — факторизованное гауссово распределение, как у политик других алгоритмов, а после $\tanh$ — уже нет. (Логарифмы вероятностей действий всё равно можно вычислить в замкнутом виде: подробности — в приложении к статье.)

2. Способ параметризации стандартных отклонений. В VPG, TRPO и PPO логарифмы стандартных отклонений представлены векторами параметров, не зависящими от состояния. В SAC логарифмы стандартных отклонений — выходы нейросети, то есть они сложным образом зависят от состояния. SAC с не зависящими от состояния логарифмами стандартных отклонений, по нашему опыту, не работал. (Можете догадаться почему? А ещё лучше — поставить эксперимент и проверить?)

Трюк с репараметризацией позволяет переписать матожидание по действиям (в котором есть неприятность: распределение зависит от параметров политики) в матожидание по шуму (в котором неприятность исчезает: распределение больше не зависит от параметров):

$$\underset{a \sim \pi_{\theta}}{\mathrm{E}}\left[Q^{\pi_{\theta}}(s,a) - \alpha \log \pi_{\theta}(a|s)\right] = \underset{\xi \sim \mathcal{N}}{\mathrm{E}}\left[Q^{\pi_{\theta}}(s,\tilde{a}_{\theta}(s,\xi)) - \alpha \log \pi_{\theta}(\tilde{a}_{\theta}(s,\xi)|s)\right]$$

Чтобы получить функцию потерь политики, остаётся последний шаг: заменить $Q^{\pi_{\theta}}$ одним из наших аппроксиматоров. В отличие от TD3, который использует $Q_{\phi_1}$ (только первый аппроксиматор Q), SAC использует $\min_{j=1,2} Q_{\phi_j}$ (минимум из двух аппроксиматоров Q). Таким образом, политика оптимизируется по

$$\max_{\theta} \underset{\substack{s \sim \mathcal{D} \\ \xi \sim \mathcal{N}}}{\mathrm{E}}\left[\min_{j=1,2} Q_{\phi_j}(s,\tilde{a}_{\theta}(s,\xi)) - \alpha \log \pi_{\theta}(\tilde{a}_{\theta}(s,\xi)|s)\right],$$

что почти совпадает с оптимизацией политики в DDPG и TD3, за исключением приёма с минимумом двух Q, стохастичности и слагаемого с энтропией.

Исследование и использование

SAC обучает стохастическую политику с регуляризацией энтропией и исследует среду по текущей политике. Коэффициент регуляризации энтропией $\alpha$ явно управляет компромиссом между исследованием и использованием: большее $\alpha$ соответствует большему исследованию, меньшее $\alpha$ — большему использованию. Правильный коэффициент (тот, что ведёт к самому устойчивому обучению или к самой высокой награде) может различаться от среды к среде и требовать тщательной настройки.

Во время тестирования, чтобы увидеть, насколько хорошо политика использует выученное, мы убираем стохастичность и используем среднее действие вместо выборки из распределения. Обычно это улучшает качество по сравнению с исходной стохастической политикой.

Полезно знать

Наша реализация SAC использует приём, улучшающий исследование в начале обучения. Первые несколько шагов (их число задаёт аргумент start_steps) агент выбирает действия равномерно случайно из допустимых. После этого он возвращается к обычному исследованию SAC.

Псевдокод

Алгоритм 1. Soft Actor-Critic

1. Вход: начальные параметры политики $\theta$, параметры Q-функций $\phi_1$, $\phi_2$, пустой буфер воспроизведения $\mathcal{D}$.
2. Приравнять целевые параметры к основным: $\phi_{\text{targ},1} \leftarrow \phi_1$, $\phi_{\text{targ},2} \leftarrow \phi_2$.
3. Повторять:
   1. Наблюдать состояние $s$ и выбрать действие $a \sim \pi_{\theta}(\cdot|s)$.
   2. Выполнить $a$ в среде.
   3. Наблюдать следующее состояние $s'$, награду $r$ и сигнал завершения $d$, показывающий, терминально ли $s'$.
   4. Сохранить $(s,a,r,s',d)$ в буфер воспроизведения $\mathcal{D}$.
   5. Если $s'$ терминально, сбросить среду.
   6. Если пора обновляться, то для $j$ от 0 до нужного числа обновлений:
      1. Случайно выбрать из $\mathcal{D}$ батч переходов $B = \{ (s,a,r,s',d) \}$.
      2. Вычислить цели для Q-функций: $$y (r,s',d) = r + \gamma (1-d) \left(\min_{i=1,2} Q_{\phi_{\text{targ}, i}} (s', \tilde{a}') - \alpha \log \pi_{\theta}(\tilde{a}'|s')\right), \qquad \tilde{a}' \sim \pi_{\theta}(\cdot|s')$$
      3. Обновить Q-функции одним шагом градиентного спуска по $$\nabla_{\phi_i} \frac{1}{|B|}\sum_{(s,a,r,s',d) \in B} \left( Q_{\phi_i}(s,a) - y(r,s',d) \right)^2 \qquad \text{для } i=1,2$$
      4. Обновить политику одним шагом градиентного подъёма по $$\nabla_{\theta} \frac{1}{|B|}\sum_{s \in B} \Big(\min_{i=1,2} Q_{\phi_i}(s, \tilde{a}_{\theta}(s)) - \alpha \log \pi_{\theta} \left(\left. \tilde{a}_{\theta}(s) \right| s\right) \Big),$$ где $\tilde{a}_{\theta}(s)$ — выборка из $\pi_{\theta}(\cdot|s)$, дифференцируемая по $\theta$ благодаря трюку с репараметризацией.
      5. Обновить целевые сети: $$\phi_{\text{targ},i} \leftarrow \rho \phi_{\text{targ}, i} + (1-\rho) \phi_i \qquad \text{для } i=1,2$$
4. До сходимости.

Документация

У SAC есть реализации на PyTorch (spinup.sac_pytorch) и TensorFlow (spinup.sac_tf1). Общие параметры — в таблице ниже; особые параметры SAC:

Параметр	По умолчанию	Смысл
lr	0.001	Скорость обучения (одна и та же для политики и для обучения ценности)
alpha	0.2	Коэффициент регуляризации энтропией. (Эквивалентен величине, обратной масштабу награды в исходной статье о SAC.)

Сохранённая модель PyTorch загружается так же, как у DDPG. Граф TensorFlow содержит: x и a — placeholder для состояния и действия; mu — детерминированно вычисляет среднее действие агента при состояниях из x; pi — сэмплирует действие агента при состояниях из x; q1 и q2 — две оценки ценности действия для x и a; v — оценка ценности для состояний из x.

Примечание: для SAC правильная политика для оценки качества — mu, а не pi. Политику pi можно считать политикой исследования, а mu — политикой использования.

Ссылки

Статьи по теме

• Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor, Haarnoja et al, 2018
• Soft Actor-Critic Algorithms and Applications, Haarnoja et al, 2018
• Learning to Walk via Deep Reinforcement Learning, Haarnoja et al, 2018

Другие открытые реализации

• SAC release repo (исходная «официальная» кодовая база)
• Softlearning repo (текущая «официальная» кодовая база)
• Yarats and Kostrikov repo

---

Общие параметры DDPG, TD3 и SAC

Функции spinup.ddpg_pytorch, spinup.td3_pytorch и spinup.sac_pytorch (и их версии *_tf1) принимают одни и те же основные параметры. Значения по умолчанию одинаковые у всех трёх, кроме отмеченных.

Параметр	По умолчанию	Смысл
env_fn	—	Функция, которая создаёт копию среды. Среда должна удовлетворять API OpenAI Gym
actor_critic	MLPActorCritic	Конструктор модуля PyTorch с методом act, модулем pi и модулем (или модулями) q. У DDPG один q, у TD3 и SAC — q1 и q2; у SAC pi возвращает действие и его лог-вероятность. Критично: выход q должен быть плоским, формы (batch,)
ac_kwargs	{}	Любые именованные аргументы для объекта ActorCritic, переданного в алгоритм
seed	0	Сид генераторов случайных чисел
steps_per_epoch	4000	Число шагов взаимодействия (пар «состояние — действие») агента со средой за эпоху
epochs	100	Число эпох, в течение которых агент работает и обучается
replay_size	1 000 000	Максимальная длина буфера воспроизведения
gamma	0.99	Коэффициент дисконтирования. (Всегда между 0 и 1.)
polyak	0.995	Коэффициент интерполяции при усреднении Поляка для целевых сетей: $\theta_{\text{targ}} \leftarrow \rho \theta_{\text{targ}} + (1-\rho) \theta$, где $\rho$ — polyak. (Всегда между 0 и 1, обычно близок к 1.)
pi_lr, q_lr	0.001, 0.001	Скорости обучения политики и Q-сетей (у DDPG и TD3; у SAC вместо них один lr)
batch_size	100	Размер минибатча для SGD
start_steps	10 000	Число шагов, в течение которых действия выбираются равномерно случайно, прежде чем запустить настоящую политику. Помогает исследованию
update_after	1000	Сколько шагов взаимодействия со средой собрать, прежде чем начинать обновления градиентным спуском. Гарантирует, что в буфере достаточно данных для полезных обновлений
update_every	50	Сколько шагов взаимодействия со средой должно пройти между обновлениями градиентным спуском. Важно: как бы долго вы ни ждали между обновлениями, отношение шагов в среде к шагам градиента зафиксировано на 1
num_test_episodes	10	Сколько эпизодов в конце каждой эпохи тестировать детерминированную политику
max_ep_len	1000	Максимальная длина траектории / эпизода / роллаута
logger_kwargs	{}	Именованные аргументы для EpochLogger
save_freq	1	Как часто (через сколько эпох) сохранять текущие политику и функцию ценности

Что дальше

• VPG и PPO — два других алгоритма оптимизации политики.
• Упражнения: упражнение 1.3 — дописать математику TD3; упражнение 2.2 — найти «тихий» баг в DDPG.
• В модуле курса 6.0 те же идеи в простых средах и с кодом: 6.0.2, 6.0.3.

Footnotes

1. См. книгу Convex Optimization Бойда и Ванденберге, особенно главы 2–5. ↩