Spinning Up in Deep RL: введение

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

Spinning Up написан для тех, кто уже знает Python, PyTorch и основы глубокого обучения. В нашем курсе тот же путь пройден медленнее и с числовыми примерами: модуль 6.0 «Основы обучения с подкреплением» — 6.0.1 MDP, отдача и функции ценности, 6.0.2 Монте-Карло, TD и Q-learning, 6.0.3 Actor-critic, GAE и PPO. Удобный порядок: урок курса → соответствующая часть Spinning Up → снова урок, практика.

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

Spinning Up — небольшой сайт-учебник OpenAI (2018, обновление для PyTorch — 2020). Мы перевели его ключевые части целиком. Текст оригинала распространяется по лицензии MIT, поэтому перевод полный; наши вставки помечены как «примечание переводчика».

Часть оригинала	Наша страница	Урок курса
Introduction, Algorithms	эта страница	—
Part 1: Key Concepts in RL	Часть 1: ключевые понятия	6.0.1
Part 2: Kinds of RL Algorithms	Часть 2: виды алгоритмов	6.0.2
Part 3: Intro to Policy Optimization	Часть 3: оптимизация политики	6.0.3, 6.3.1
Spinning Up as a Deep RL Researcher	Как стать исследователем	—
Key Papers in Deep RL	Ключевые статьи	—
Algorithms Docs: VPG, PPO	VPG и PPO	6.0.3, 6.3.2, 6.4.1
Algorithms Docs: TRPO, DDPG, TD3, SAC	TRPO, DDPG, TD3, SAC	6.0.2, 6.0.3
Exercises	Упражнения	—

Не переведены технические страницы про установку, запуск экспериментов, логгер, графики и MPI: они описывают устаревшее окружение 2019–2020 годов. Что из них нужно сегодня, мы собрали в конце этой страницы.

---

Введение

Что это

Добро пожаловать в Spinning Up in Deep RL! Это учебный ресурс от OpenAI, который помогает разобраться в глубоком обучении с подкреплением (deep reinforcement learning, deep RL).

Для тех, кто не знаком с темой: обучение с подкреплением (reinforcement learning, RL) — это подход машинного обучения, при котором агенты учатся решать задачи методом проб и ошибок. Глубокое RL — это сочетание RL с глубоким обучением.

В этом модуле собраны полезные материалы:

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

Зачем мы это сделали

Один из самых частых вопросов, которые мы слышим:

Я хочу внести вклад в безопасность ИИ (AI safety). С чего начать?

В OpenAI мы считаем, что глубокое обучение вообще — и глубокое обучение с подкреплением в особенности — будут играть центральную роль в создании мощных технологий ИИ. Чтобы ИИ был безопасным, нужно придумать стратегии и алгоритмы безопасности, совместимые с этой парадигмой. Поэтому всем, кто задаёт этот вопрос, мы советуем изучать эти области.

Однако если для быстрого входа в глубокое обучение ресурсов много, то войти в глубокое RL сложнее. Начнём с того, что студенту нужны некоторые знания математики, программирования и обычного глубокого обучения. Сверх этого ему нужны и общий взгляд на область — понимание, какие темы в ней изучают, почему они важны и что уже сделано, — и внимательное объяснение того, как связать теорию алгоритма с его кодом.

Общий взгляд получить трудно, потому что область очень молодая. Стандартного учебника по глубокому RL пока нет, поэтому большая часть знаний заперта в статьях или циклах лекций, на разбор и усвоение которых уходит много времени. А научиться реализовывать алгоритмы глубокого RL обычно мучительно, потому что

• статья, в которой опубликован алгоритм, опускает или ненамеренно затемняет ключевые детали устройства;
• либо широко известные реализации алгоритма трудно читать: в них не видно, как код соответствует алгоритму.

Прекрасные репозитории вроде garage, Baselines и rllib помогают продвигаться исследователям, которые уже работают в области. Но они встраивают алгоритмы во фреймворки, и это требует множества неочевидных решений и компромиссов — по такому коду трудно учиться. В итоге порог входа в глубокое RL довольно высок — и для новых исследователей, и для практиков, и для любителей.

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

При этом польза от этих материалов не только (и не обязательно) для практиков. Чтобы решить задачу безопасности ИИ, нужны люди с самым разным опытом и взглядами, и многие подходящие профессии вообще никак не связаны с инженерией или информатикой. Тем не менее всем участникам нужно будет понимать технологию достаточно хорошо, чтобы принимать обоснованные решения, и несколько частей Spinning Up отвечают именно этой потребности.

Как это служит нашей миссии

Миссия OpenAI — обеспечить безопасное развитие AGI и, шире, широкое распределение выгод от ИИ. Учебные инструменты вроде Spinning Up помогают продвигаться к обеим целям.

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

Во-вторых, что крайне важно, нам нужны люди, которые помогут сделать AGI безопасным. Для этого нужен набор навыков, которого сейчас не хватает, потому что область очень молодая. Мы знаем, что многие хотели бы помочь нам, но не знают как, — вот что вам стоит изучить! Если вы станете экспертом в этом материале, вы сможете изменить ситуацию с безопасностью ИИ.

Философия кода

Реализации алгоритмов в репозитории Spinning Up задуманы так, чтобы они были

• настолько простыми, насколько возможно, оставаясь при этом достаточно хорошими;
• очень согласованными друг с другом — чтобы показать фундаментальное сходство алгоритмов.

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

Важно, что все они устроены похоже: если вы как следует поняли один алгоритм, перейти к следующему будет легко.

Мы постарались свести к минимуму число трюков в каждой реализации и различия между в остальном похожими алгоритмами. Примеры убранных трюков: мы опустили регуляризационные слагаемые из оригинального кода Soft Actor-Critic, а также нормализацию наблюдений во всех алгоритмах. Пример устранённого различия: наши реализации DDPG, TD3 и SAC одинаково запускают шаги градиентного спуска через фиксированные интервалы взаимодействия со средой. (Другие публичные реализации этих алгоритмов обычно делают это немного по-разному, и сравнивать их чуть труднее.)

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

Долгосрочная поддержка и история поддержки

Сейчас Spinning Up в режиме поддержки. Если найдутся критические ошибки, мы их исправим, чтобы Spinning Up и дальше помогал людям изучать глубокое RL.

История поддержки на данный момент:

• 8 ноября 2018: первый выпуск!
• Ноябрь 2018: после выпуска — три недели интенсивной поддержки.
• Апрель 2019: примерно через полгода после выпуска мы провели внутренний обзор Spinning Up по отзывам сообщества. Обзор выявил интерес к нескольким ключевым возможностям:
  • Реализации на других нейросетевых библиотеках. Несколько человек хотели бы видеть в Spinning Up альтернативы Tensorflow v1. Некоторые участники сообщества даже сделали собственные версии алгоритмов Spinning Up на PyTorch: Fired Up Кашифа Расула, Spinning Up Basic Кая Арулкумарана и Torching Up Миши Ласкина. Поэтому создание такого «Розеттского камня» для глубокого RL стало приоритетом для будущей работы.
  • Открытые среды RL. Многие хотели бы, чтобы Spinning Up использовал больше открытых сред RL (например, PyBullet) для бенчмарков, примеров и упражнений.
  • Больше алгоритмов. Был интерес к другим алгоритмам, особенно к Deep Q-Networks.
• Январь 2020: вышло обновление Spinning Up для PyTorch!
• Будущее: крупных обновлений Spinning Up сейчас не планируется. Если нам покажется разумным выпустить ещё одно обновление, то, по итогам полугодового обзора, следующие по приоритету возможности — больше открытых сред RL и новые алгоритмы.

Кроме того, как говорилось в блог-посте, Spinning Up вошёл в программу наших стажировок Scholars и Fellows.

---

Алгоритмы

Что включено

В пакете Spinning Up реализованы следующие алгоритмы:

• Vanilla Policy Gradient (VPG) — «простой» градиент политики;
• Trust Region Policy Optimization (TRPO) — оптимизация политики в доверительной области;
• Proximal Policy Optimization (PPO) — проксимальная оптимизация политики;
• Deep Deterministic Policy Gradient (DDPG) — глубокий детерминированный градиент политики;
• Twin Delayed DDPG (TD3) — DDPG с двумя критиками и отложенными обновлениями;
• Soft Actor-Critic (SAC) — «мягкий» актор-критик.

Все они реализованы с актор-критиками на основе MLP (не рекуррентных сетей). Поэтому они подходят для полностью наблюдаемых сред RL без изображений на входе, например для сред Gym MuJoCo.

У каждого алгоритма в Spinning Up две реализации (кроме TRPO): одна использует нейросетевую библиотеку PyTorch, другая — Tensorflow v1. (TRPO пока есть только на Tensorflow.)

Почему эти алгоритмы?

Мы выбрали для пакета базовые алгоритмы глубокого RL так, чтобы они отражали полезную последовательность идей из недавней истории области. Её вершина — два алгоритма, PPO и SAC: среди алгоритмов, которые учат политику, они близки к лучшим по надёжности и эффективности использования данных (sample efficiency). Кроме того, они показывают некоторые компромиссы, на которые приходится идти при разработке и применении алгоритмов глубокого RL.

Алгоритмы on-policy

Vanilla Policy Gradient — самый базовый, начальный алгоритм в глубоком RL: он появился задолго до глубокого RL как такового. Основные элементы VPG восходят к концу 80-х — началу 90-х годов. С него началась линия исследований, которая в итоге привела к более сильным алгоритмам: сначала к TRPO, а вскоре после него — к PPO.

Ключевая особенность этой линии в том, что все её алгоритмы on-policy: они не используют старые данные, поэтому слабее по эффективности использования данных. Но на то есть веская причина: эти алгоритмы напрямую оптимизируют то, что вас интересует, — качество политики, и математически получается, что для расчёта обновлений нужны данные on-policy (собранные текущей политикой). Так что это семейство жертвует эффективностью использования данных ради стабильности — но видно, как последовательность приёмов (от VPG к TRPO и PPO) постепенно сокращает это отставание.

Алгоритмы off-policy

DDPG — такой же основополагающий алгоритм, как VPG, хотя гораздо моложе: теория детерминированных градиентов политики, из которой вырос DDPG, опубликована только в 2014 году. DDPG тесно связан с алгоритмами Q-learning: он одновременно учит Q-функцию и политику, которые обновляются так, чтобы улучшать друг друга.

Алгоритмы вроде DDPG и Q-learning — off-policy, поэтому они очень эффективно переиспользуют старые данные. Это преимущество они получают, используя уравнения оптимальности Беллмана: Q-функцию можно обучить им удовлетворять на любых данных взаимодействия со средой (если в них достаточно опыта из областей среды с высокой наградой).

Но вот проблема: нет никаких гарантий, что хорошее выполнение уравнений Беллмана даёт высокое качество политики. На практике качество бывает отличным — и тогда эффективность использования данных прекрасна, — но отсутствие гарантий делает алгоритмы этого класса потенциально хрупкими и нестабильными. TD3 и SAC — потомки DDPG, которые используют ряд идей, чтобы смягчить эти проблемы.

Формат кода

Все реализации в Spinning Up следуют стандартному шаблону. Каждая разбита на два файла: файл алгоритма, где лежит основная логика, и файл core, где собраны вспомогательные функции, нужные для запуска алгоритма.

Файл алгоритма всегда начинается с определения класса буфера опыта (experience buffer) — объекта, в котором хранятся данные о взаимодействии агента со средой. Дальше идёт одна функция, которая запускает алгоритм. Эта функция следует примерно одинаковому шаблону в версиях на PyTorch и на Tensorflow, но мы разберём каждую отдельно. Наконец, в каждом файле алгоритма есть поддержка запуска прямо из командной строки в средах Gym (хотя это не рекомендуемый способ запуска — как правильно, описано на странице Running Experiments).

Функция алгоритма: версия на PyTorch

Функция алгоритма в реализации на PyTorch выполняет следующие действия (примерно в таком порядке):

1. Настройка логгера.
2. Установка зерна генератора случайных чисел (random seed).
3. Создание среды.
4. Построение модуля актор-критика на PyTorch через функцию actor_critic, переданную функции алгоритма аргументом.
5. Создание буфера опыта.
6. Подготовка вызываемых функций потерь, которые заодно выдают диагностику, специфичную для алгоритма.
7. Создание оптимизаторов PyTorch.
8. Настройка сохранения модели через логгер.
9. Подготовка функции обновления, которая выполняет одну эпоху оптимизации или один шаг спуска.
10. Главный цикл алгоритма:
    1. запустить агента в среде;
    2. периодически обновлять параметры агента по основным уравнениям алгоритма;
    3. логировать ключевые метрики качества и сохранять агента.

Функция алгоритма: версия на Tensorflow

Функция алгоритма в реализации на Tensorflow выполняет следующие действия (примерно в таком порядке):

1. Настройка логгера.
2. Установка зерна генератора случайных чисел.
3. Создание среды.
4. Создание плейсхолдеров для вычислительного графа.
5. Построение вычислительного графа актор-критика через функцию actor_critic, переданную функции алгоритма аргументом.
6. Создание буфера опыта.
7. Построение вычислительного графа для функций потерь и диагностики, специфичной для алгоритма.
8. Создание операций обучения (training ops).
9. Создание сессии TF и инициализация параметров.
10. Настройка сохранения модели через логгер.
11. Определение функций, нужных для главного цикла алгоритма (например, основной функции обновления, функции получения действия и функции тестирования агента — в зависимости от алгоритма).
12. Главный цикл алгоритма:
    1. запустить агента в среде;
    2. периодически обновлять параметры агента по основным уравнениям алгоритма;
    3. логировать ключевые метрики качества и сохранять агента.

Файл core

Файлы core следуют шаблону не так строго, как файлы алгоритмов, но приблизительная структура у них есть:

1. Только Tensorflow: функции для создания плейсхолдеров и работы с ними.
2. Функции, которые строят части вычислительного графа, относящиеся к методу actor_critic конкретного алгоритма.
3. Прочие полезные функции.
4. Реализации MLP-актор-критика, совместимого с алгоритмом: и политика, и функция (или функции) ценности представлены простыми MLP.

---

Примечание переводчика: как работать со Spinning Up сегодня

Код Spinning Up заморожен в 2020 году. В его setup.py закреплены Python 3.6+, torch==1.3.1, tensorflow>=1.8.0,<2.0, gym~=0.15.3 и mpi4py. Современные Python, PyTorch и Gymnasium с этими версиями несовместимы, поэтому на странице «Учимся у создателей» мы советуем код читать, а не запускать. Практичный план:

1. Теория — три части «Introduction to RL» (наши переводы 1, 2, 3) вместе с модулем 6.0 курса.
2. Первый код — учебные примеры spinup/examples/pytorch/pg_math/ (градиент политики на 128 строк). Они почти не зависят от пакета; в части 3 мы приводим версию для современного Gymnasium — она запускается на CPU за пару минут.
3. Полные реализации — читайте spinup/algos/pytorch/ppo/ppo.py и spinup/algos/pytorch/sac/sac.py рядом с переводами страниц VPG и PPO и TRPO, DDPG, TD3, SAC. Чтобы запускать PPO на современном стеке, удобнее взять CleanRL — одиночные файлы в том же духе — или лабораторную PPO на CartPole из урока 6.0.3.

Если всё же хотите поставить исходный пакет, оригинальная инструкция такая (Linux или macOS, отдельное окружение conda с Python 3.6):

# Окружение с Python 3.6 — новее пакет не поддерживает
conda create -n spinningup python=3.6
conda activate spinningup

# OpenMPI нужен для параллельного запуска (Ubuntu; на macOS: brew install openmpi)
sudo apt-get update && sudo apt-get install libopenmpi-dev

# Сам Spinning Up
git clone https://github.com/openai/spinningup.git
cd spinningup
pip install -e .

# Проверка: PPO в среде LunarLander-v2, около 10 минут
python -m spinup.run ppo --hid "[32,32]" --env LunarLander-v2 --exp_name installtest --gamma 0.999

# Посмотреть видео обученной политики и построить график обучения
python -m spinup.run test_policy data/installtest/installtest_s0
python -m spinup.run plot data/installtest/installtest_s0

Инструкция говорит, что физическому движку MuJoCo нужна платная лицензия. Это устарело: в 2021 году MuJoCo стал бесплатным, в 2022-м — открытым. Но старые среды *-v2 из упражнений требуют пакета mujoco-py, который с современными системами ставится с трудом. Для учёбы хватает бесплатных сред Classic Control и Box2D (CartPole, LunarLander).