Deep RL Course: юниты 5 и 7 и бонусы

В курсе Hugging Face есть «основная линия» — юниты 1–4, 6 и 8, которые мы перевели полностью (см. путеводитель по курсу), — и «игровая» часть: агенты в игровых движках Unity и Godot, мультиагентное обучение и обзор продвинутых тем. Здесь собрано главное из этой части: ключевые разделы теории переведены, практика описана так, чтобы было понятно, что запускать и зачем.

На чём основана страница

Путеводитель составлен по исходникам курса на GitHub (лицензия Apache-2.0): units/en/unit5, unit7, unitbonus1, unitbonus2, unitbonus3, unitbonus5. Разделы, отмеченные «перевод», переведены близко к тексту; остальное — краткий пересказ и наш комментарий. Награды сред Pyramids и SoccerTwos, которые в курсе даны картинками, приведены по документации ML-Agents.

Карта

Юнит	О чём	Практика	Связь с курсом ChinaAI	Важность для LLM-трека
Бонус 1	Собака Хагги учится приносить палку	ML-Agents, PPO, Colab	закрепление юнита 1	★
Бонус 2	Автоподбор гиперпараметров с Optuna	видео и ноутбук Антонена Раффена	подбор гиперпараметров — ступень 2	★
5	Unity ML-Agents; любопытство как внутренняя награда	SnowballTarget, Pyramids	исследование и использование — 6.0.2	★
7	Мультиагентное RL, self-play, рейтинг Эло, MA-POCA	SoccerTwos (2 на 2)	мультиагентные LLM-системы — 8.3.3	★
Бонус 3	RL с моделью, офлайн-RL, обобщение, RLHF, Decision Transformer, языковые модели в RL, учебные программы	нет	RLHF — 6.3.2; RL для агентов — 8.3.4	★★
Бонус 5	Имитационное обучение (BC + GAIL) в Godot RL Agents	свой проект в Godot	—	★

Если вы идёте по LLM-треку

Из этой страницы для языковых моделей полезнее всего три раздела: RLHF, языковые модели в RL и офлайн и онлайн RL. Ещё стоит прочитать про self-play и рейтинг Эло: Эло сегодня используют для сравнения чат-моделей на «аренах», где люди голосуют за лучший ответ.

Бонус 1. Собака Хагги

Бонусный юнит 1 закрепляет юнит 1: вы обучаете собаку Хагги (Huggy) приносить брошенную палку, а потом играете с ней прямо в браузере.

Как устроен Хагги (перевод)

Хагги — среда глубокого обучения с подкреплением, сделанная в Hugging Face на основе Puppo the Corgi — проекта команды Unity ML-Agents. Среда создана в игровом движке Unity с помощью ML-Agents.

Цель — научить Хагги приносить палку, которую мы бросаем. Для этого ему нужно правильно двигаться к палке.

Пространство состояний — что воспринимает Хагги. Хагги не «видит» среду. Вместо этого мы сообщаем ему:

• положение цели (палки);
• положение цели относительно него самого;
• ориентацию его лап.

По этой информации Хагги с помощью своей политики решает, какое действие совершить, чтобы достичь цели.

Пространство действий — какие движения может совершать Хагги. Лапы Хагги приводят в движение моторы суставов. Значит, чтобы добраться до цели, Хагги должен научиться правильно вращать моторы суставов каждой лапы, чтобы двигаться.

Функция награды устроена так, чтобы Хагги достиг цели — принёс палку. Вспомните гипотезу о награде: цель можно описать как максимизацию ожидаемой накопленной награды. Здесь мы хотим, чтобы Хагги шёл к палке, но не крутился слишком сильно. Поэтому функция награды состоит из частей:

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

Обучение идёт в среде, где палка появляется в случайном месте; когда Хагги до неё добирается, палка появляется в другом месте. Для обучения сделано несколько копий среды: это ускоряет обучение, давая больше разнообразного опыта.

Практика

Ноутбук бонуса 1 клонирует ML-Agents, скачивает готовую сборку среды Хагги под Linux, задаёт конфигурацию PPO (Huggy.yaml) и запускает mlagents-learn. По оценке авторов, обучение занимает 30–45 минут в зависимости от машины. Потом модель выкладывают на Hub и играют с Хагги в Space прямо в браузере. Как работает ML-Agents, объясняет юнит 5 (ниже).

Бонус 2. Optuna

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

Сам юнит — это два видео из доклада Антонена Раффена (одного из основателей Stable-Baselines и RL-Baselines3-Zoo) на конференции ICRA 2022: теория подбора гиперпараметров и практическое руководство по Optuna, плюс ноутбук. Видео на английском.

Задания из курса (перевод):

1. Улучшите результаты своего агента для LunarLander-v2, подобрав гиперпараметры с Optuna. Можно попробовать и другие среды, например MountainCar-v0 и CartPole-v1.
2. Улучшите результаты своего агента для Space Invaders.

Примечание переводчика

Optuna пригодится и вне RL: тот же поиск (сэмплер TPE, ранняя остановка неудачных попыток) подходит для любых гиперпараметров. В RL он особенно полезен, потому что алгоритмы чувствительны к скорости обучения, размеру батча и коэффициентам. Учтите, что каждая попытка — это отдельное обучение агента: на тяжёлых средах подбор займёт часы.

Юнит 5. Unity ML-Agents

Введение (перевод)

Одна из трудностей обучения с подкреплением — создание сред. К счастью, для этого можно использовать игровые движки: Unity, Godot или Unreal Engine — программы для создания видеоигр. Они отлично подходят для создания сред: в них есть физика, 2D- и 3D-отрисовка и многое другое.

Один из них, Unity, создал Unity ML-Agents Toolkit — плагин для движка Unity, который позволяет использовать движок Unity как конструктор сред для обучения агентов. Именно им мы пользовались в первом бонусном юните, чтобы научить Хагги ловить палку.

В Unity ML-Agents Toolkit много отличных готовых сред: футбол, обучение ходьбе, прыжки через высокие стены. В этом юните мы научимся пользоваться ML-Agents, но не беспокойтесь, если не умеете работать в движке Unity: для обучения агентов он не нужен.

Сегодня мы обучим двух агентов:

• первый научится бросать снежки в появляющиеся мишени;
• второй должен нажать кнопку, чтобы появилась пирамида, дойти до пирамиды, повалить её и добраться до золотого кирпича наверху. Для этого ему придётся исследовать среду, и мы применим технику под названием «любопытство» (curiosity).

Как работает Unity ML-Agents (перевод)

Unity ML-Agents — набор инструментов для движка Unity, который позволяет создавать среды в Unity или использовать готовые среды для обучения агентов. Его разрабатывает Unity Technologies — создатели Unity, одного из самых известных игровых движков (на нём сделаны Firewatch, Cuphead и Cities: Skylines).

В Unity ML-Agents шесть основных компонентов:

• обучающая среда (Learning Environment) — сцена Unity (среда) и элементы среды (игровые персонажи);
• низкоуровневый Python API — низкоуровневый интерфейс Python для взаимодействия со средой и управления ею. Через него запускается обучение;
• внешний коммуникатор (External Communicator) — соединяет обучающую среду (на C#) с низкоуровневым Python API (на Python);
• тренеры на Python — алгоритмы обучения с подкреплением на PyTorch (PPO, SAC…);
• обёртка Gym — чтобы упаковать среду RL в обёртку gym;
• обёртка PettingZoo — PettingZoo — мультиагентная версия обёртки gym.

Внутри обучающей среды два важных элемента:

• компонент агента — действующее лицо сцены. Мы обучаем агента, оптимизируя его политику (которая говорит, какое действие совершить в каждом состоянии). Политику здесь называют мозгом (Brain);
• академия (Academy) — этот компонент управляет агентами и процессом принятия ими решений. Считайте академию учителем, который обрабатывает запросы Python API.

Академия отдаёт приказы агентам и следит, чтобы они действовали синхронно:

1. собрать наблюдения;
2. выбрать действие своей политикой;
3. совершить действие;
4. сбросить среду, если достигнуто максимальное число шагов или эпизод закончился.

flowchart LR
subgraph U["Unity (C#)"]
  AC["Академия"] --> AG["Агенты"]
end
U <-->|"внешний коммуникатор"| P["Python API"]
P --> T["Тренеры на PyTorch: PPO, SAC"]
P --> W["Обёртки Gym и PettingZoo"]

Компоненты Unity ML-Agents (в оригинале — схема из документации ML-Agents)

Среда SnowballTarget (перевод с сокращениями)

SnowballTarget — среда, созданная в Hugging Face. Агент — медвежонок Жюльен 🐻; его учат попадать снежками в мишени. Цель — поразить как можно больше мишеней за ограниченное время (1000 шагов). Для этого нужно правильно встать относительно мишени и выстрелить. Чтобы агент не «спамил» снежками на каждом шаге, у Жюльена есть перезарядка: после выстрела нужно подождать 0,5 секунды.

Функция награды и проблема конструирования наград. Функция награды простая: среда даёт +1 каждый раз, когда снежок агента попадает в мишень. Можно было бы сделать функцию сложнее (например, со штрафом, подгоняющим агента). Но при проектировании среды нужно избегать проблемы конструирования наград (reward engineering problem) — слишком сложной функции награды, которая заставляет агента вести себя так, как хотите вы. Почему? Потому что так можно упустить интересные стратегии, которые агент нашёл бы с более простой функцией награды.

Наблюдения. Вместо обычного зрения (кадров) используются лучи (raycasts) — представьте их как лазеры, которые определяют, проходят ли они через объект. У агента несколько наборов лучей, а также булево наблюдение «могу ли я стрелять». Пространство действий дискретное.

Среда Pyramids (перевод с сокращениями)

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

Награда (по документации ML-Agents): +2 за то, что агент добрался до золотого кирпича, минус 0,001 за каждый шаг. Чтобы обучить агента, который ищет кнопку, а затем пирамиду, используется сочетание двух видов наград:

• внешней (extrinsic) — её даёт среда;
• внутренней (intrinsic) — её называют любопытством. Она подталкивает агента быть любопытным, то есть лучше исследовать среду.

Наблюдения — 148 лучей, каждый из которых распознаёт объекты (кнопку, кирпичи, золотой кирпич и стены), плюс булева переменная состояния кнопки и вектор скорости агента. Действия — дискретные, четыре варианта (повороты и движение вперёд и назад).

Что такое любопытство в глубоком RL (перевод)

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

Например, в ViZDoom, наборе сред на основе Doom, в среде «DoomMyWayHome» агент получает награду, только если найдёт бронежилет. Но бронежилет далеко от старта, поэтому почти все награды будут нулевыми. Без полезной обратной связи (плотных наград) агент будет гораздо дольше учиться оптимальной политике и может долго крутиться на месте, так и не найдя цель.

Вторая большая проблема — внешняя функция награды делается вручную: в каждой среде человек должен реализовать функцию награды. Но как масштабировать это на большие и сложные среды?

Так что же такое любопытство? Решение этих проблем — создать функцию награды, внутреннюю для агента, то есть порождаемую самим агентом. Агент становится самоучкой: он и ученик, и сам себе источник обратной связи.

Такой механизм внутренней награды называют любопытством, потому что эта награда подталкивает агента исследовать новые, незнакомые состояния. Для этого агент получает высокую награду, когда исследует новые траектории. Эта награда навеяна поведением людей: у нас есть естественное внутреннее желание исследовать среду и открывать новое.

Внутреннюю награду можно считать по-разному. Классический подход (любопытство через предсказание следующего состояния) — считать любопытство как ошибку агента в предсказании следующего состояния по текущему состоянию и совершённому действию:

$$r^{\text{вн}}_t = \big\lVert \hat{s}_{t+1} - s_{t+1} \big\rVert^2, \qquad \hat{s}_{t+1} = f(s_t, a_t)$$

Идея любопытства — поощрять действия, которые уменьшают неопределённость агента в предсказании последствий своих действий (неопределённость выше там, где агент провёл мало времени, или там, где сложная динамика). Если агент много времени провёл в каких-то состояниях, он хорошо предсказывает следующее состояние (любопытство низкое). А в новом, неисследованном состоянии предсказать следующее трудно (любопытство высокое). Значит, любопытство подталкивает агента к переходам с большой ошибкой предсказания и, как следствие, к лучшему исследованию среды.

Есть и другие способы вычислять любопытство. В конфигурации Pyramids в ML-Agents используется более продвинутый — любопытство через дистилляцию случайной сети (random network distillation, RND); отсюда и название файла PyramidsRND.yaml. Подробнее — в двух статьях автора курса: Curiosity-Driven Learning through Next State Prediction и Random Network Distillation.

Примечание переводчика: формула и связь с LLM

Формулы в этом разделе оригинала нет, она добавлена для наглядности: $f$ — обучаемая модель, предсказывающая следующее состояние, а награда — квадрат её ошибки. Разреженная награда — главная беда и в RL для языковых моделей: в задачах с проверяемым ответом (урок 6.4.2) модель получает 1 или 0 только в конце длинного рассуждения. Там спасает не любопытство, а то, что предобученная модель уже часто решает задачу правильно.

Практика юнита 5

Ноутбук ставит ML-Agents из репозитория (в Colab для этого создают окружение с Python 3.10.12), скачивает сборки сред под Linux и запускает обучение командой mlagents-learn:

mlagents-learn ./config/ppo/SnowballTarget.yaml --env=./training-envs-executables/linux/SnowballTarget/SnowballTarget --run-id="SnowballTarget1" --no-graphics

Гиперпараметры PPO задаются в YAML-файле: epsilon: 0.2 — диапазон обрезки, lambd: 0.95 — λ для GAE, beta: 0.005 — коэффициент энтропии, num_epoch: 3 — эпох на батч. Это те же величины, что в юните 8, только под другими именами. Для Pyramids берут готовый PyramidsRND.yaml, уменьшив max_steps до 1 000 000: по словам авторов, порог средней награды 1,75 достигается за 1 млн шагов. Время обучения, по оценке авторов, — 10–35 минут для SnowballTarget и 30–45 минут для Pyramids. Обученного агента выкладывают командой mlagents-push-to-hf и смотрят в браузере в Spaces Hugging Face.

Юнит 7. Мультиагентное RL и игры «ИИ против ИИ»

Состязания не работают

По словам авторов, функция «ИИ против ИИ» сейчас не работает, а лидерборд футбольного состязания закрыт. Обучить команду и посмотреть, как она играет, по-прежнему можно.

Введение в мультиагентное RL (перевод)

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

В мультиагентном обучении с подкреплением (multi-agent reinforcement learning, MARL) несколько агентов делят общую среду и взаимодействуют в ней. Например, на складе несколько роботов перемещаются, загружая и разгружая посылки. Или на дороге несколько беспилотных автомобилей.

Среды бывают разных типов:

• кооперативные: агенты должны максимизировать общую выгоду. Например, на складе роботы должны сообща загружать и разгружать посылки как можно быстрее;
• соревновательные (состязательные): агент хочет максимизировать свою выгоду, минимизируя выгоду соперника. Например, в теннисе каждый агент хочет обыграть другого;
• смешанные: как в нашей среде SoccerTwos, где два агента входят в команду (синюю или фиолетовую): они должны сотрудничать друг с другом и обыграть команду соперника.

Как проектировать мультиагентные системы (перевод)

Этот раздел курса построен вокруг видео Брайана Дугласа Introduction to Multi-Agent Reinforcement Learning (на английском) на примере нескольких роботов-пылесосов. Есть два решения.

Децентрализованный подход. Каждого агента обучают независимо от других. Каждый пылесос учится убирать как можно больше, не обращая внимания на то, что делают другие пылесосы. Плюс в том, что агенты не обмениваются информацией, поэтому их можно проектировать и обучать так же, как одиночных агентов: обучаемый агент считает остальных агентов частью динамики среды, а не агентами. Большой минус — среда становится нестационарной: лежащий в основе MDP меняется со временем, потому что другие агенты тоже действуют в среде. А многие алгоритмы RL не могут достичь глобального оптимума в нестационарной среде.

Централизованный подход. Есть процесс верхнего уровня, который собирает опыт всех агентов (буфер опыта), и по этому опыту обучается общая политика. В примере с пылесосами наблюдение — карта уборки и положение всех пылесосов; по этому общему опыту обучают политику, которая двигает всех трёх роботов наиболее выгодно для всей группы. Среда становится стационарной: все агенты считаются одной большой сущностью и знают об изменениях политик других (они такие же, как у них).

Итог:

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

Self-play (перевод)

Правильно обучать агентов в состязательной игре довольно сложно. С одной стороны, нужно где-то взять хорошо обученного соперника. С другой — если соперник очень силён, как агенту улучшать политику?

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

Лучшее решение — соперник того же уровня, что и агент, который растёт вместе с ним. Если соперник слишком силён, мы ничему не научимся; если слишком слаб — переучимся на поведение, бесполезное против сильного соперника.

Это решение называется self-play (игра с самим собой). В self-play агент использует в качестве соперника свои прежние копии (копии своей политики). Так агент играет против соперника своего уровня (трудно, но не слишком), получает возможность постепенно улучшать политику, а по мере роста обновляет соперника. Это способ «вырастить» соперника и постепенно усложнять игру — так же учатся и люди: сначала с соперником своего уровня, потом, набравшись навыков, — с более сильными.

Теория self-play не нова: её использовала программа игры в шашки Артура Сэмюэла в 1950-х и TD-Gammon Джеральда Тезауро в 1995 году.

Self-play в ML-Agents управляется несколькими гиперпараметрами. Главное, как сказано в документации, — компромисс между уровнем и универсальностью итоговой политики и стабильностью обучения. Обучение против медленно меняющихся или неизменных соперников с малым разнообразием стабильнее, но если они меняются слишком медленно, есть риск переобучения. Поэтому нужно управлять:

• как часто менять соперников — параметры swap_steps и team_change;
• сколько соперников хранить — параметр window: чем он больше, тем разнообразнее пул соперников (в нём остаются политики с более ранних этапов обучения);
• вероятностью играть против текущей версии себя, а не против соперника из пула, — play_against_latest_model_ratio;
• числом шагов обучения до сохранения нового соперника — save_steps: чем больше, тем шире разброс уровней и, возможно, стилей игры соперников.

Рейтинг Эло для оценки агента (перевод)

В состязательных играх накопленная награда — не всегда осмысленная мера прогресса: она зависит только от уровня соперника. Вместо неё используют рейтинг Элорейтинг ЭлоEN Elo ratingШахматный рейтинг, который пересчитывают по исходам попарных партий. В Chatbot Arena его заменили оценкой модели Брэдли–Терри по всем голосам сразу. (в честь Арпада Эло), который считает относительный уровень двух игроков из некоторой популяции в игре с нулевой суммой. В игре с нулевой суммой один агент выигрывает, а другой проигрывает: выигрыш одного участника ровно уравновешен проигрышем других.

Рейтинг Эло (обычно стартует с 1200) поначалу может падать, но во время обучения должен постепенно расти. Он выводится из поражений и ничьих в играх с другими игроками: рейтинг зависит от рейтингов соперников и результатов против них. Центральная идея — считать силу игры игрока случайной величиной с нормальным распределением. Разница рейтингов двух игроков предсказывает исход матча. Если игрок побеждает, но вероятность его победы была высокой, он заберёт у соперника лишь немного очков.

После каждой партии:

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

Если у игроков A и B рейтинги $R_A$ и $R_B$, ожидаемые результаты равны:

$$E_A = \frac{1}{1 + 10^{(R_B - R_A)/400}}, \qquad E_B = \frac{1}{1 + 10^{(R_A - R_B)/400}}$$

В конце партии рейтинг обновляют линейно, пропорционально тому, насколько игрок сыграл лучше или хуже ожидаемого. Максимальное изменение за партию задаёт коэффициент $K$: $K = 16$ для мастеров, $K = 32$ для более слабых игроков. Если игрок A ожидал $E_A$ очков, а набрал $S_A$ (1 — победа, 0,5 — ничья, 0 — поражение), его рейтинг обновляется так:

$$R_A' = R_A + K\,(S_A - E_A)$$

Пример. У игрока A рейтинг 2600, у игрока B — 2300.

• Ожидаемые результаты: $E_A = \frac{1}{1 + 10^{(2300 - 2600)/400}} = 0{,}849$, $E_B = \frac{1}{1 + 10^{(2600 - 2300)/400}} = 0{,}151$.
• Если $K = 16$ и побеждает A: $2600 + 16 \cdot (1 - 0{,}849) \approx 2602$, $2300 + 16 \cdot (0 - 0{,}151) \approx 2298$.
• Если $K = 16$ и побеждает B: $2600 + 16 \cdot (0 - 0{,}849) \approx 2586$, $2300 + 16 \cdot (1 - 0{,}151) \approx 2314$.

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

Примечание переводчика: Эло и чат-модели

Та же формула (или её родственница — модель Брэдли–Терри) используется на «аренах» чат-моделей: люди сравнивают два ответа, а рейтинг моделей пересчитывается по победам. Модель Брэдли–Терри разобрана в уроке 6.3.2: вероятность того, что ответ A лучше B, — $\sigma(r_A - r_B)$, то есть та же логистическая кривая от разницы «рейтингов», только с натуральной экспонентой вместо $10^{x/400}$.

MA-POCA и практика юнита 7

Почему не хватает self-play. Self-play отлично подходит для игры один на один. Но в SoccerTwos играют двое на двое, и награду за гол получает вся команда, даже если игроки внесли разный вклад, — агенту трудно понять, что делать ему самому. Команда Unity ML-Agents предложила тренер MA-POCA (Multi-Agent POsthumous Credit Assignment): централизованный критик («тренер») видит состояния всех агентов команды и оценивает вклад каждого, а каждый агент принимает решения только по своим локальным наблюдениям. Это схема «централизованное обучение, децентрализованное исполнение». В практике self-play сочетают с тренером MA-POCA (trainer_type: poca).

Среда SoccerTwos (по документации ML-Agents): четыре агента в футболе 2 на 2. Наблюдение — вектор из 336 чисел: 11 лучей вперёд в секторе 120° и 3 луча назад в секторе 90°, каждый распознаёт 6 типов объектов (мяч, синие и фиолетовые ворота, стену, синего и фиолетового агента). Награда — $1 - \text{штраф за время}$ за гол в чужие ворота и −1 за гол в свои. Действия — три дискретные ветки (вперёд-назад, вбок, поворот).

Практика. Обучение запускают на своём компьютере (не в Colab): по оценке авторов, нужно от 4 до 8 часов, а 5 млн шагов (рекомендованное значение) занимают 5–8 часов в зависимости от железа. Конфигурация config/poca/SoccerTwos.yaml содержит блок self_play (save_steps: 50000, team_change: 200000, swap_steps: 2000, window: 10, play_against_latest_model_ratio: 0.5, initial_elo: 1200.0). Авторы предупреждают: до 2 млн шагов рейтинг Эло может почти не расти и даже опускаться ниже 1200 — агенты сначала просто бегают по полю случайно.

Примечание переводчика: мультиагентность в LLM

В мире языковых моделей «мультиагентная система» обычно значит другое: несколько LLM с разными ролями (оркестратор и исполнители) общаются текстом и не обучаются совместно — это урок 8.3.3. Но словарь из юнита 7 — нестационарность, распределение заслуг (credit assignment), централизованный критик — встречается и в статьях о совместном RL-обучении нескольких агентов-LLM.

Бонус 3. Продвинутые темы

Этот юнит — коллективная работа нескольких сотрудников Hugging Face; у каждого раздела свой автор. Перевод введения: «Поздравляем с окончанием курса! Теперь у вас прочная база в глубоком обучении с подкреплением. Но курс был только началом пути: есть ещё множество разделов. В этом необязательном юните мы даём материалы, чтобы изучить разные понятия и исследовательские темы обучения с подкреплением».

Раздел	Автор	О чём
Model-Based RL	Натан Ламберт	агент учит модель динамики среды и планирует по ней
Offline vs. Online RL	Томас Симонини	обучение на готовом наборе данных без взаимодействия со средой
Generalisation in RL	—	устойчивость к изменениям среды и перенос на новые задачи
RLHF	Натан Ламберт	обучение с подкреплением на отзывах людей
Decision Transformers	Эдвард Бичинг	RL как моделирование последовательностей трансформером
Language models in RL	Клеман Ромак	языковые модели как источник знаний для агентов
(Automatic) Curriculum Learning	Клеман Ромак	порядок задач от простых к сложным, автоматический подбор
Interesting environments to try	—	DIAMBRA Arena, MineRL, DonkeyCar, StarCraft II
Unreal Learning Agents, Godot RL	—	RL в движках Unreal и Godot
Students projects	—	проекты выпускников курса
RL documentation	—	Reward Reports — документация наград для RL-систем

RL с моделью среды (перевод)

Model-based RL отличается от обучения без модели только тем, что агент учит модель динамики (dynamics model), но это сильно меняет то, как принимаются решения. Модель динамики обычно описывает переходы среды $s_{t+1} = f_\theta(s_t, a_t)$, но в этом подходе используют и модели обратной динамики (из состояний в действия) или модели награды (предсказывающие награды).

Простое определение:

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

Академическое определение. Агент действует в MDP с функцией переходов $s_{t+1} = f(s_t, a_t)$ и наградой $r(s_t, a_t)$ на каждом шаге. По собранному набору $D = \{s_i, a_i, s_{i+1}, r_i\}$ агент учит модель $s_{t+1} = f_\theta(s_t, a_t)$, минимизируя отрицательное логарифмическое правдоподобие переходов. Затем по выученной модели применяется управление с прогнозирующей моделью (model-predictive control, MPC) на основе выборки: оно оптимизирует ожидаемую награду на конечном горизонте, рекурсивно предсказанном моделью, перебирая действия, сэмплированные из равномерного распределения. Дальше: пост об отладке MBRL и обзорная статья.

Офлайн и онлайн RL (перевод)

Агенты глубокого RL учатся на батчах опыта. Вопрос в том, как этот опыт собирать.

• В онлайн-RL — его мы изучали весь курс — агент собирает данные сам: набирает батч опыта, взаимодействуя со средой, и сразу (или через буфер воспроизведения) учится на нём. Но тогда нужно либо обучать агента прямо в реальном мире, либо иметь симулятор. Если симулятора нет, его надо построить, а это может быть очень сложно (как отразить сложную реальность в среде?), дорого и небезопасно (если в симуляторе есть изъяны, дающие преимущество, агент их использует).
• В офлайн-RL агент использует только данные, собранные другими агентами или людьми (демонстрации). Он не взаимодействует со средой. Процесс: создать набор данных одной или несколькими политиками и/или действиями людей, затем запустить на нём офлайн-RL, чтобы выучить политику.

У этого метода есть недостаток — проблема контрфактических запросов: что делать, если агент решит сделать то, для чего у нас нет данных? Например, повернуть направо на перекрёстке, а такой траектории в данных нет. Дальше: доклад Сергея Левина об офлайн-RL и обзор Offline Reinforcement Learning: Tutorial, Review, and Perspectives on Open Problems.

Примечание переводчика: офлайн и онлайн в обучении LLM

Та же граница проходит в пост-трейнинге языковых моделей. DPO (урок 6.3.3) учится на заранее собранных парах ответов — это офлайн-подход. PPO в RLHF и GRPO генерируют ответы текущей моделью на каждом шаге — это онлайн-RL. А «контрфактические запросы» в LLM выглядят так: модель после обучения пишет ответы, которых не было в наборе пар, и оценить их по этому набору нельзя.

Обобщение в RL (перевод)

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

RLHF (перевод)

Обучение с подкреплением на основе отзывов людей (RLHFобучение с подкреплением на основе отзывов людей (RLHF)EN reinforcement learning from human feedback (RLHF)) — это методология, встраивающая разметку, сделанную людьми, в процесс оптимизации на основе RL. Её мотивирует трудность моделирования человеческих предпочтений: для многих вопросов, даже если попытаться записать уравнение для одного идеала, у разных людей разные предпочтения. Обновлять модели по измеренным данным — способ смягчить эти по сути человеческие проблемы машинного обучения.

С чего начать (по курсу):

1. Прочитать введение Illustrating Reinforcement Learning from Human Feedback (RLHF).
2. Посмотреть запись трансляции, где Натан Ламберт рассказывает основы RLHF и как эта технология используется в инструментах вроде ChatGPT: обзор связанных моделей, основы NLP и RL, RLHF для больших языковых моделей и открытые вопросы (видео, на английском).
3. Почитать другие посты, например Closed-API vs Open-source continues: RLHF, ChatGPT, data moats.

В разделе приведён список ключевых статей (скопирован из поста Illustrating RLHF). Работы до эпохи языковых моделей: TAMER (Knox, Stone, 2008) — люди оценивают действия агента, по оценкам учится модель награды; COACH (MacGlashan et al., 2017) — отзывы людей настраивают функцию преимущества в actor-critic; Deep RL from Human Preferences (Christiano et al., 2017) — RLHF на предпочтениях между траекториями Atari; Deep TAMER (Warnell et al., 2018). Работы о языковых моделях: Fine-Tuning Language Models from Human Preferences (Ziegler et al., 2019), Learning to summarize with human feedback (Stiennon et al., 2020), WebGPT (2021), InstructGPT (2022), GopherCite, Sparrow, ChatGPT (2022), Scaling Laws for Reward Model Overoptimization (Gao et al., 2022), Training a Helpful and Harmless Assistant with RLHF (Anthropic, 2022), Red Teaming Language Models (Ganguli et al., 2022), NLPO (Ramamurthy, Ammanabrolu et al., 2022) — альтернатива PPO.

Примечание переводчика: что читать по-русски

Раздел курса — только введение и список статей (2022–2023 годов). Сам RLHF с reward model, моделью Брэдли–Терри, PPO по токенам и reward hacking разобран в уроке 6.3.2, а что пришло на смену — DPO и GRPO — в уроках 6.3.3 и 6.4.1.

Decision Transformer (перевод)

Модель Decision Transformer предложена в статье Decision Transformer: Reinforcement Learning via Sequence Modeling (Chen et al.). Она сводит обучение с подкреплением к задаче условного моделирования последовательностей.

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

Это полная смена парадигмы RL: обычные алгоритмы заменяет генеративное моделирование траекторий (совместного распределения последовательности состояний, действий и наград). В Decision Transformer мы не максимизируем отдачу, а генерируем последовательность будущих действий, достигающих желаемой отдачи. Команда 🤗 Transformers добавила Decision Transformer — метод офлайн-RL — в библиотеку и на Hub. Подробнее — в посте Introducing Decision Transformers on Hugging Face и в руководстве Train your first Decision Transformer (учим «полугепарда» бегать).

flowchart LR
R1["желаемая отдача R̂₁"] --> T["Трансформер (причинное внимание)"]
S1["состояние s₁"] --> T
A1["действие a₁"] --> T
R2["R̂₂"] --> T
S2["s₂"] --> T
T --> A2["следующее действие a₂"]

Decision Transformer: траектория как последовательность токенов «отдача — состояние — действие»

Языковые модели в RL (перевод)

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

Естественный вопрос, который недавно изучали: могут ли такие знания помочь агентам, например роботам, решать повседневные задачи? Эти работы показали интересные результаты, но у предложенных агентов не было никакого метода обучения. Это ограничение не даёт таким агентам приспосабливаться к среде (например, исправлять неверные знания) или учиться новым навыкам.

Языковые модели и RL. Поэтому есть потенциальная синергия между языковыми моделями, которые приносят знания о мире, и RL, которое может согласовать и исправить эти знания, взаимодействуя со средой. Особенно это интересно с точки зрения RL, потому что RL в основном опирается на постановку tabula rasa — агент учит всё с нуля, что приводит к:

1. низкой эффективности по данным;
2. неожиданному с точки зрения людей поведению.

Первой попыткой стала статья «Grounding Large Language Models with Online Reinforcement Learning»: в ней языковую модель адаптировали (согласовывали) к текстовой среде с помощью PPO. Авторы показали, что знания, заложенные в языковую модель, позволяют быстро приспособиться к среде (это путь к RL-агентам, эффективным по данным), а после согласования модель лучше обобщает на новые задачи.

Другое направление изучено в статье «Guiding Pretraining in Reinforcement Learning with Large Language Models»: языковую модель оставляют замороженной, но используют её знания, чтобы направлять исследование среды RL-агентом. Такой метод ведёт агента к осмысленному для людей и, вероятно, полезному поведению без человека в цикле обучения.

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

Примечание переводчика: что произошло дальше

Раздел написан в начале 2023 года. С тех пор направление «языковая модель как политика, обучаемая RL в среде» стало главным способом учить агентов: модели обучают RL на задачах с инструментами, кодом и браузером, где награду даёт среда. Это agentic RL из урока 8.3.4. А RL на задачах с проверяемым ответом (DeepSeek-R1) — урок 6.4.2.

Автоматические учебные программы (перевод с сокращениями)

Методы RL из курса хорошо работают на практике, но иногда сами по себе не справляются — например, когда задача трудная и требует постепенного освоения навыков (двуногому агенту, чтобы преодолевать сложные препятствия, нужно сначала научиться стоять, потом ходить, потом, может быть, прыгать) или когда среда меняется и агент должен быть к этому устойчив. Тогда агенту предлагают разные задачи в таком порядке, чтобы навыки осваивались постепенно. Это обучение по учебной программе (curriculum learning); обычно программу составляют вручную — например, управляют генерацией среды, начальными состояниями или уровнем соперников в self-play.

Поскольку составить программу непросто, область автоматических учебных программ (Automatic Curriculum Learning, ACL) предлагает методы, которые сами учатся упорядочивать задачи так, чтобы максимизировать качество агента. Портелас и соавторы определяют ACL как «семейство механизмов, которые автоматически адаптируют распределение обучающих данных, учась подбирать учебные ситуации под возможности RL-агентов». Пример — рандомизация домена (domain randomization): OpenAI вносили случайные изменения в среду, чтобы рука-робот научилась собирать кубик Рубика. Поиграть с устойчивостью агентов можно в демо бенчмарка TeachMyAgent, меняя параметры среды и даже рисуя рельеф.

Остальные разделы бонуса 3 (кратко)

• Интересные среды — DIAMBRA Arena (файтинги), MineRL (Minecraft), симулятор DonkeyCar, StarCraft II.
• Unreal Learning Agents и Godot RL Agents — как обучать агентов в движках Unreal Engine и Godot; раздел о Godot — пошаговое создание своей среды и экспорт модели в игру.
• Проекты студентов — игры и агенты, сделанные выпускниками курса.
• Документация RL-систем — Reward Reports: «живые» документы для RL-систем, работающих с людьми, по образцу карточек моделей и описаний датасетов. Их главная часть — журнал изменений: что меняли разработчики (параметры, данные) и что заметили пользователи (вредное поведение, неожиданные ответы).

Бонус 5. Имитационное обучение в Godot RL Agents

Бонусный юнит 5 (автор — Иван Додич) — проект: обучить робота пройти уровень мини-игры с помощью имитационного обучения (imitation learning) по демонстрациям, записанным человеком. Робот должен потянуть рычаг, чтобы поднялась лестница во вторую комнату, дойти до ключа и взять его, не упав в ловушки, воду или за пределы карты, вернуться к сундуку в первой комнате и открыть его.

Что понадобится (по курсу): желательно сначала пройти раздел о Godot RL Agents из бонуса 3, немного знать Godot (писать на gdscript не нужно), Godot с поддержкой .NET (проверено на 4.3.dev5), pip install godot-rl и библиотеку imitation; время — около 1–2 часов. Порядок работы: реализовать в узле AIController3D методы наблюдений и награды, записать экспертные демонстрации (автор записал 23 эпизода примерно за 10 минут), затем запустить скрипт sb3_imitation.py: сначала клонирование поведения (behavior cloning, BC) — обучение с учителем на демонстрациях, — потом GAIL, где дискриминатор отличает действия агента от действий эксперта, а агент учится его обманывать. У автора предобучение BC заняло около 5,5 минут, а GAIL — около 41 минуты на CPU. Результат экспортируют в ONNX и запускают прямо в игре.

Примечание переводчика: связь с SFT

Клонирование поведения — это то же самое, что SFT языковой модели (урок 6.1.2): обучение с учителем «повторять действия эксперта». А схема «сначала имитация, потом RL» — та же, что в пост-трейнинге LLM: SFT, затем RLHF или GRPO.

Что запускать на своей машине

Практика	Что нужно	Время по оценке авторов	Совет
Бонус 1 (Хагги)	ML-Agents, сборка Unity под Linux	30–45 мин	по желанию; играть с готовым Хагги можно в браузере
Бонус 2 (Optuna)	Optuna + SB3	зависит от числа попыток	начните с CartPole: одна попытка — секунды
Юнит 5	ML-Agents, Python 3.10	10–35 и 30–45 мин	по желанию
Юнит 7	ML-Agents, сборка SoccerTwos	5 млн шагов — 5–8 ч	оставить на ночь или пропустить
Бонус 5	Godot .NET, godot-rl, imitation	≈1–2 ч	по желанию, если интересен геймдев

ML-Agents требует определённой версии Python (в курсе — 3.10.12); создайте для него отдельное окружение (conda или venv), чтобы не сломать окружение курса ChinaAI. Клон репозитория ML-Agents весит около 2,6 ГБ.

Словарик

English	Русский
game engine (Unity, Godot, Unreal)	игровой движок
Learning Environment, Academy, Brain	обучающая среда, академия, мозг (политика)
raycast	луч (лучевой датчик)
reward engineering problem	проблема конструирования наград
extrinsic / intrinsic reward	внешняя / внутренняя награда
curiosity, random network distillation (RND)	любопытство, дистилляция случайной сети
sparse / dense reward	разреженная / плотная награда
multi-agent RL (MARL)	мультиагентное обучение с подкреплением
cooperative / competitive / mixed environment	кооперативная / соревновательная / смешанная среда
decentralized / centralized approach	децентрализованный / централизованный подход
non-stationary environment	нестационарная среда
self-play	self-play, игра с самим собой
Elo rating, K-factor, zero-sum game	рейтинг Эло, коэффициент K, игра с нулевой суммой
credit assignment, centralized critic	распределение заслуг, централизованный критик
model-based RL, dynamics model, MPC	RL с моделью среды, модель динамики, управление с прогнозирующей моделью
offline / online RL, counterfactual queries	офлайн / онлайн RL, контрфактические запросы
Decision Transformer	Decision Transformer
curriculum learning, domain randomization	обучение по учебной программе, рандомизация домена
imitation learning, behavior cloning, GAIL	имитационное обучение, клонирование поведения, GAIL