Deep RL Course, юнит 3: Deep Q-Learning и игры Atari

Полный перевод третьего юнита курса Hugging Face: почему Q-таблица не справляется с Atari, архитектура DQN, предобработка кадров, replay buffer, фиксированная целевая сеть, Double DQN и практика с RL Baselines3 Zoo на Space Invaders.

Это перевод третьего юнита курса Hugging Face Deep RL Course: теория, глоссарий, практическое занятие (ноутбук notebooks/unit3/unit3.ipynb), тест и заключение. Предыдущий юнит — Q-learning, карта курса — в путеводителе.

Юнит 3 соответствует разделу «От таблицы к нейросети: DQN» урока 6.0.2 «Монте-Карло, TD и Q-learning». Удобный порядок: урок 6.0.2 до этого раздела → теория юнита 3 → локальный DQN на CartPole из урока (он идёт на CPU за минуты). Практику юнита на Atari запускайте, только если хочется увидеть агента в игре: обучение долгое, а готовых агентов можно скачать с Hub (см. раздел «Загружаем сильную обученную модель»). Для языковых моделей DQN почти не используют, но его словарь — replay buffer, целевая сеть, переоценка — встречается в статьях постоянно.

Введение

В прошлом юните мы изучили первый алгоритм обучения с подкреплением — Q-learning, реализовали его с нуля и обучили в двух средах: FrozenLake-v1 ☃️ и Taxi-v3 🚕.

С этим простым алгоритмом мы получили отличные результаты, но среды были довольно простыми: пространство состояний было дискретным и маленьким (16 состояний у FrozenLake-v1 и 500 у Taxi-v3). Для сравнения: в играх Atari пространство состояний может содержать от $10^{9}$ до $10^{11}$ состояний.

Но, как мы увидим, в средах с большим пространством состояний строить и обновлять Q-таблицу становится неэффективно.

Поэтому в этом юните мы изучим первого агента глубокого обучения с подкреплением — Deep Q-Learning. Вместо Q-таблицы Deep Q-Learning использует нейросеть: она получает состояние и приближает Q-значения каждого действия в этом состоянии.

И мы обучим его играть в Space Invaders и другие игры Atari с помощью RL Zoo — фреймворка для обучения RL на основе Stable-Baselines. В нём есть скрипты для обучения и оценки агентов, подбора гиперпараметров, построения графиков и записи видео. В оригинале здесь анимация: агенты играют в несколько игр Atari.

Итак, начнём! 🚀

От Q-learning к Deep Q-Learning

Мы узнали, что Q-learning — это алгоритм, которым мы обучаем Q-функцию, то есть функцию ценности действия (action-value function): она определяет ценность того, чтобы находиться в конкретном состоянии и совершить в нём конкретное действие.

Q(s, a) \;=\; \text{ожидаемая отдача, если в состоянии } s \text{ совершить действие } a \text{ и дальше следовать политике}

Буква Q — от «Quality», «качество» действия в этом состоянии.

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

Проблема в том, что Q-learning — табличный метод (tabular method). Это становится проблемой, если пространства состояний и действий недостаточно малы, чтобы эффективно хранить их в массивах и таблицах. Иначе говоря, метод не масштабируется. Q-learning хорошо работал в средах с маленьким пространством состояний:

во FrozenLake было 16 состояний;
в Taxi-v3 было 500 состояний.

А теперь представьте, что мы будем делать сегодня: обучать агента игре Space Invaders — игре посложнее, где на вход подаются кадры экрана.

Как заметил Никита Мелкозёров, у сред Atari пространство наблюдений имеет форму (210, 160, 3)* и содержит значения от 0 до 255. Это даёт $256^{210 \times 160 \times 3} = 256^{100800}$ возможных наблюдений (для сравнения, в наблюдаемой Вселенной примерно $10^{80}$ атомов).

* Один кадр Atari — это картинка 210 × 160 пикселей. Картинка цветная (RGB), поэтому каналов три — отсюда форма (210, 160, 3). Значение каждого пикселя — от 0 до 255.

Значит, пространство состояний гигантское, и создавать и обновлять Q-таблицу для такой среды неэффективно. Лучшая идея в таком случае — приближать Q-значения параметризованной Q-функцией $Q_{\theta}(s,a)$ .

Эта нейросеть по состоянию будет приближать Q-значения всех возможных в нём действий. Именно это и делает Deep Q-Learning.

flowchart LR
subgraph QL["Q-learning"]
  direction LR
  S1["Состояние"] --> T["Q-таблица"]
  A1["Действие"] --> T
  T --> V1["Q-значение"]
end
subgraph DQL["Deep Q-Learning"]
  direction LR
  S2["Состояние"] --> N["Нейросеть"]
  N --> V2["Q-значение действия 1"]
  N --> V3["Q-значение действия 2"]
  N --> V4["…"]
end

Q-learning ищет ценность пары в таблице, Deep Q-Learning получает ценности всех действий сразу из нейросети

Теперь, когда мы понимаем идею Deep Q-Learning, разберём подробнее глубокую Q-сеть.

Глубокая Q-сеть (DQN)

Вот архитектура нашей сети Deep Q-Learning:

flowchart LR
F["4 кадра 84×84, оттенки серого"] --> C1["Свёрточный слой 1"]
C1 --> C2["Свёрточный слой 2"]
C2 --> C3["Свёрточный слой 3"]
C3 --> FC1["Полносвязный слой"]
FC1 --> FC2["Полносвязный слой"]
FC2 --> Q["Q-значение для каждого действия"]

Архитектура DQN: стопка из четырёх кадров → три свёрточных слоя → полносвязные слои → вектор Q-значений

На вход как состояние подаётся стопка из 4 кадров, а на выходе получается вектор Q-значений всех возможных в этом состоянии действий. Дальше, как и в Q-learning, достаточно ε-жадной политики, чтобы выбрать действие.

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

Предобработка входа и временно́е ограничение

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

Для этого мы уменьшаем кадр до 84 × 84 и переводим его в оттенки серого. Так можно делать, потому что цвета в играх Atari не несут важной информации. Это большой выигрыш: три цветовых канала (RGB) превращаются в один.

В некоторых играх можно обрезать часть экрана, если там нет важной информации. Затем мы складываем четыре кадра в стопку.

В оригинале здесь схема: цветной кадр 210 × 160 × 3 превращается в серый 84 × 84 × 1, а четыре таких кадра складываются в стопку 84 × 84 × 4.

Зачем складывать четыре кадра в стопку? Это помогает справиться с проблемой временно́го ограничения (temporal limitation). Возьмём для примера игру Pong. Вы видите вот такой кадр: мяч и две ракетки.

Можете сказать, куда летит мяч? Нет: по одному кадру не понять, есть ли движение! А если добавить ещё три кадра? Теперь видно, что мяч летит вправо.

Поэтому, чтобы уловить информацию о времени, мы складываем вместе четыре кадра.

Затем стопку кадров обрабатывают три свёрточных слоя. Эти слои позволяют улавливать и использовать пространственные связи на изображениях. А поскольку кадры сложены вместе, можно использовать и некоторые временны́е свойства этих кадров.

Если вы не знаете, что такое свёрточные слои, не беспокойтесь: можно посмотреть урок 4 бесплатного курса Udacity по глубокому обучению.

Наконец, несколько полносвязных слоёв выдают Q-значение для каждого возможного в этом состоянии действия.

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

Алгоритм Deep Q-Learning

Мы узнали, что Deep Q-Learning приближает Q-значения всех возможных в состоянии действий глубокой нейросетью (оценка функции ценности).

Отличие в том, что во время обучения мы не обновляем Q-значение пары «состояние — действие» напрямую, как в Q-learning:

Q(S_t, A_t) \leftarrow Q(S_t, A_t) + \alpha\left[R_{t+1} + \gamma \max_a Q(S_{t+1}, a) - Q(S_t, A_t)\right]

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

\underbrace{y_t = R_{t+1} + \gamma \max_{a} Q(S_{t+1}, a)}_{\text{Q-цель}}, \qquad \underbrace{\big(y_t - Q_\theta(S_t, A_t)\big)^2}_{\text{потери}}

У алгоритма обучения Deep Q-Learning две фазы:

Сэмплирование (sampling): совершаем действия и сохраняем наблюдаемые кортежи опыта в память воспроизведения (replay memory).
Обучение (training): случайно выбираем небольшой батч кортежей и учимся на нём шагом градиентного спуска.

flowchart LR
A["Сэмплирование: действуем в среде"] -->|"кортежи (s, a, r, s')"| B[("Память воспроизведения D")]
B -->|"случайный мини-батч"| C["Обучение: шаг градиентного спуска"]
C -->|"обновлённые веса"| A

Две фазы Deep Q-Learning чередуются

Это не единственное отличие от Q-learning. Обучение Deep Q-Learning может быть нестабильным — в основном из-за сочетания нелинейной функции Q-значений (нейросети) и бутстрэпа (когда цели обновляются по имеющимся оценкам, а не по настоящей полной отдаче).

Чтобы стабилизировать обучение, применяют три решения:

Воспроизведение опыта (experience replay) — чтобы эффективнее использовать опыт.
Фиксированная Q-цель (fixed Q-target) — чтобы стабилизировать обучение.
Double Deep Q-Learning — чтобы справиться с переоценкой Q-значений.

Разберём их по очереди!

Воспроизведение опыта: эффективнее использовать опыт

Зачем мы создаём память воспроизведения?

У воспроизведения опыта в Deep Q-Learning две функции.

Воспроизведение опыта помогает использовать опыт обучения эффективнее. Мы заводим буфер воспроизведения (replay buffer), который хранит примеры опыта, чтобы использовать их повторно во время обучения.

⇒ Так агент может учиться на одном и том же опыте много раз.

2. Не забывать прошлый опыт (так называемая катастрофическая интерференция, или катастрофическое забывание) и уменьшить корреляцию между примерами опыта.

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

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

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

В псевдокоде Deep Q-Learning мы инициализируем буфер памяти воспроизведения D ёмкостью N (N — гиперпараметр, который задаёте вы). Затем мы сохраняем опыт в память и выбираем из неё батч опыта, чтобы подать его глубокой Q-сети на фазе обучения.

Фиксированная Q-цель: стабилизируем обучение

Чтобы посчитать TD-ошибку (то есть потери), мы считаем разность между TD-целью (Q-целью) и текущим Q-значением (оценкой Q).

Но настоящей TD-цели мы не знаем. Её нужно оценить. Из уравнения Беллмана мы видели, что TD-цель — это просто награда за действие в этом состоянии плюс дисконтированное наибольшее Q-значение следующего состояния:

y_t = R_{t+1} + \gamma \max_{a} Q(S_{t+1}, a)

Проблема в том, что одни и те же параметры (веса) используются для оценки и TD-цели, и Q-значения. Поэтому между TD-целью и параметрами, которые мы меняем, сильная корреляция.

Значит, на каждом шаге обучения сдвигаются и наши Q-значения, и целевые значения. Мы приближаемся к цели, но цель тоже движется. Это погоня за движущейся мишенью! Из-за этого обучение может сильно колебаться.

Представьте, что вы ковбой (оценка Q) и хотите поймать корову (Q-цель). Ваша задача — подобраться поближе (уменьшить ошибку).

На каждом шаге вы пытаетесь приблизиться к корове, а она на каждом шаге тоже сдвигается (потому что вы используете одни и те же параметры).

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

Вместо этого в псевдокоде мы:

используем отдельную сеть с фиксированными параметрами, чтобы оценивать TD-цель;
каждые C шагов копируем в неё параметры нашей глубокой Q-сети, чтобы обновить целевую сеть (target network).

В оригинале псевдокод — картинка с алгоритмом из статьи DeepMind о DQN (Mnih et al., Nature, 2015). Вот он целиком: сюда входят и память воспроизведения, и целевая сеть $\hat{Q}$ с весами $\theta^-$ .

Инициализировать память воспроизведения D ёмкостью N
Инициализировать функцию ценности действия Q случайными весами θ
Инициализировать целевую функцию Q̂ весами θ⁻ = θ
Для эпизода = 1 … M:
    Получить первое состояние s₁ и предобработать его: φ₁ = φ(s₁)
    Для t = 1 … T:
        С вероятностью ε выбрать случайное действие aₜ,
        иначе aₜ = argmaxₐ Q(φₜ, a; θ)
        Выполнить aₜ в эмуляторе, получить награду rₜ и кадр xₜ₊₁
        Получить sₜ₊₁ и предобработать: φₜ₊₁ = φ(sₜ₊₁)
        Сохранить переход (φₜ, aₜ, rₜ, φₜ₊₁) в D
        Выбрать из D случайный мини-батч переходов (φⱼ, aⱼ, rⱼ, φⱼ₊₁)
        yⱼ = rⱼ, если эпизод закончился на шаге j+1,
        иначе yⱼ = rⱼ + γ · maxₐ' Q̂(φⱼ₊₁, a'; θ⁻)
        Сделать шаг градиентного спуска по (yⱼ − Q(φⱼ, aⱼ; θ))² по параметрам θ
        Каждые C шагов: Q̂ ← Q

Награда за действие здесь обозначена $r_t$ , как в статье; в тексте курса — $R_{t+1}$ . Сдвинут только индекс.

Double DQN

Double DQN, или нейросети Double Deep Q-Learning, предложил Хадо ван Хасселт. Этот метод справляется с переоценкой Q-значений (overestimation).

Чтобы понять проблему, вспомните, как мы считаем TD-цель:

y_t = R_{t+1} + \gamma \max_{a} Q(S_{t+1}, a)

Здесь есть простая проблема: откуда мы знаем, что лучшее действие в следующем состоянии — это действие с наибольшим Q-значением?

Мы знаем, что точность Q-значений зависит от того, какие действия мы пробовали, и от того, какие соседние состояния исследовали.

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

Решение: при вычислении Q-цели использовать две сети, чтобы разделить выбор действия и вычисление целевого Q-значения. Мы:

сетью DQN выбираем лучшее действие для следующего состояния (действие с наибольшим Q-значением);
целевой сетью считаем целевое Q-значение этого действия в следующем состоянии.

y_t^{\text{Double}} = R_{t+1} + \gamma\, Q_{\theta^-}\!\Big(S_{t+1},\ \arg\max_{a} Q_{\theta}(S_{t+1}, a)\Big)

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

С тех пор к Deep Q-Learning добавили много улучшений, например приоритизированное воспроизведение опыта (Prioritized Experience Replay) и Dueling Deep Q-Learning. Они выходят за рамки курса, но если интересно — ссылки есть в списке дополнительного чтения.

Глоссарий

Это глоссарий, созданный сообществом. Предложения приветствуются!

Табличный метод (tabular method): тип задач, в которых пространства состояний и действий достаточно малы, чтобы функции ценности можно было хранить в виде массивов и таблиц. Q-learning — пример табличного метода: ценности пар «состояние — действие» хранятся в таблице.
Deep Q-Learning: метод, который обучает нейросеть по состоянию приближать Q-значения всех возможных в нём действий. Применяется, когда пространство наблюдений слишком велико для табличного Q-learning.
Временно́е ограничение (temporal limitation): трудность, возникающая, когда состояние среды представлено кадрами. Один кадр не несёт информации о времени. Чтобы её получить, нужно сложить в стопку несколько кадров.
Фазы Deep Q-Learning:
- Сэмплирование: совершаются действия, а наблюдаемые кортежи опыта сохраняются в память воспроизведения.
- Обучение: случайно выбираются батчи кортежей, и нейросеть обновляет веса градиентным спуском.
Решения, стабилизирующие Deep Q-Learning:
- Воспроизведение опыта: создаётся память воспроизведения, где хранятся примеры опыта для повторного использования при обучении. Так агент учится на одном и том же опыте много раз. Это также помогает агенту не забывать прошлый опыт при получении нового.
- Случайный выбор из буфера воспроизведения убирает корреляцию в последовательностях наблюдений и не даёт ценностям действий колебаться или катастрофически расходиться.
- Фиксированная Q-цель: чтобы посчитать Q-цель, нужно оценить дисконтированное оптимальное Q-значение следующего состояния по уравнению Беллмана. Проблема в том, что Q-цель и Q-значение считаются одними и теми же весами сети. Значит, всякий раз, когда меняется Q-значение, сдвигается и Q-цель. Чтобы этого избежать, TD-цель оценивают отдельной сетью с фиксированными параметрами. Целевую сеть обновляют, копируя в неё параметры глубокой Q-сети каждые C шагов.
- Double DQN: метод борьбы с переоценкой Q-значений. Использует две сети, чтобы разделить выбор действия и вычисление целевого значения:
  - сеть DQN выбирает лучшее действие для следующего состояния (с наибольшим Q-значением);
  - целевая сеть считает целевое Q-значение этого действия в следующем состоянии.
  Такой подход уменьшает переоценку Q-значений, помогает учиться быстрее и стабильнее.

Если хотите улучшить курс, можно открыть пул-реквест. Глоссарий составлен благодаря Дарио Паэсу.

Практика: агент Deep Q-Learning играет в Space Invaders

Ноутбук рассчитан на Google Colab с GPU: ячейки с ! и apt — команды для Colab. На своей машине запускайте команды в терминале без !, в отдельном виртуальном окружении.
Обучение долгое: 1 млн шагов — около 90 минут на GPU P100 (оценка автора), 10 млн — около 9 часов. Буфер на 100 000 переходов из стопок по 4 кадра 84 × 84 занимает около 5,6 ГБ оперативной памяти. Если хочется только увидеть DQN в деле — переходите сразу к разделу «Загружаем сильную обученную модель»: там скачивается готовый агент.
Лидерборд курса выключен, поэтому публикация на Hub необязательна.
В новых версиях Gymnasium игры Atari ставятся пакетом ale-py; если rl_zoo3 не находит среду по имени, сверьте имя с документацией Gymnasium.

Теперь, когда вы изучили теорию Deep Q-Learning, вы готовы обучить своего агента Deep Q-Learning играть в игры Atari. Начнём со Space Invaders, но вы сможете взять любую игру Atari 🔥

Мы используем интеграцию RL-Baselines-3 Zoo — базовую версию Deep Q-Learning без расширений вроде Double-DQN, Dueling-DQN или Prioritized Experience Replay.

А если после этого занятия захотите реализовать Deep Q-Learning сами, обязательно посмотрите реализацию CleanRL: dqn_atari.py.

Чтобы это занятие засчиталось для сертификата, нужно выложить обученную модель на Hub и получить результат ≥ 200. Чтобы узнать результат, найдите свою модель на лидерборде: результат = средняя награда − стандартное отклонение награды. Если модели не видно, прокрутите страницу вниз и нажмите кнопку обновления. Подробнее о сертификации — в разделе курса, а свой прогресс можно проверить здесь.

Чтобы начать, нажмите кнопку «Open In Colab»: ноутбук unit3.ipynb в Colab.

Юнит 3: Deep Q-Learning для игр Atari 👾 с RL Baselines3 Zoo

В этом ноутбуке вы обучите агента Deep Q-Learning играть в Space Invaders с помощью RL Baselines3 Zoo — фреймворка для обучения на основе Stable-Baselines3. В нём есть скрипты для обучения и оценки агентов, подбора гиперпараметров, построения графиков и записи видео.

Мы используем интеграцию RL-Baselines-3 Zoo — базовую версию Deep Q-Learning без расширений вроде Double-DQN, Dueling-DQN и Prioritized Experience Replay.

🎮 Среда: SpacesInvadersNoFrameskip-v4. Чем отличаются версии Space Invaders, можно посмотреть здесь.

📚 Библиотека RL: RL-Baselines3-Zoo.

Цели занятия 🏆. К концу занятия вы:

глубже поймёте, как устроен RL Baselines3 Zoo;
сможете выложить обученного агента и код на Hub с красивым видео игры и оценкой качества 🔥.

Что нужно заранее 🏗️: 🔲 📚 изучить Deep Q-Learning по юниту 3 🤗

Мы постоянно улучшаем наши руководства, поэтому, если найдёте проблемы в этом занятии, откройте issue в репозитории на GitHub.

Обучим агента Deep Q-Learning играть в Space Invaders 👾 и выложим его на Hub

Мы настоятельно рекомендуем выполнять практические задания в Google Colab, а не на личном компьютере. С Colab вы сосредоточитесь на учёбе и экспериментах и не будете отвлекаться на техническую настройку окружения.

Лучше запускать копию ноутбука из своего Google Drive: тогда, если сессия оборвётся по тайм-ауту, сохранённый ноутбук останется у вас и не придётся заполнять всё заново. Для этого нажмите Ctrl + S или File > Save a copy in Google Drive. Мы будем обучать агента 90 минут, 1 млн шагов; команда !nvidia-smi покажет, какая у вас GPU. Обучение на 10 млн шагов займёт около 9 часов, и Colab, скорее всего, оборвёт сессию — тогда лучше запускать на своём компьютере (или где-то ещё).

Включаем GPU 💪

Чтобы ускорить обучение агента, используем GPU. Для этого откройте Runtime > Change Runtime type и выберите Hardware Accelerator > GPU.

Устанавливаем RL-Baselines3 Zoo и зависимости 📚

Если вы видите ERROR: pip's dependency resolver does not currently take into account all the packages that are installed., это нормально и не критично: это конфликт версий, но нужные пакеты установлены.

# Пока ставим вот эту версию RL-Baselines3 Zoo — прямо из репозитория
pip install git+https://github.com/DLR-RM/rl-baselines3-zoo

apt-get install swig cmake ffmpeg

Чтобы использовать игры Atari в Gymnasium, нужен пакет atari, а accept-rom-license — чтобы скачать файлы ROM (файлы самих игр).

pip install gymnasium[atari]
pip install gymnasium[accept-rom-license]

Создаём виртуальный дисплей 🔽

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

apt install python-opengl
apt install ffmpeg
apt install xvfb
pip3 install pyvirtualdisplay

# Виртуальный дисплей
from pyvirtualdisplay import Display

virtual_display = Display(visible=0, size=(1400, 900))
virtual_display.start()

Обучаем агента Deep Q-Learning играть в Space Invaders 👾

Чтобы обучить агента в RL-Baselines3-Zoo, нужно сделать всего две вещи.

1. Создать файл конфигурации dqn.yml с гиперпараметрами обучения. Вот пример-шаблон:

SpaceInvadersNoFrameskip-v4:
  env_wrapper:
    - stable_baselines3.common.atari_wrappers.AtariWrapper
  frame_stack: 4
  policy: 'CnnPolicy'
  n_timesteps: !!float 1e7
  buffer_size: 100000
  learning_rate: !!float 1e-4
  batch_size: 32
  learning_starts: 100000
  target_update_interval: 1000
  train_freq: 4
  gradient_steps: 1
  exploration_fraction: 0.1
  exploration_final_eps: 0.01
  # Если True, нужно отключить handle_timeout_termination
  # в replay_buffer_kwargs
  optimize_memory_usage: False

Здесь видно, что:

мы используем обёртку AtariWrapper, которая предобрабатывает вход (уменьшение кадра, оттенки серого, стопка из 4 кадров);
мы используем CnnPolicy, потому что кадры обрабатываются свёрточными слоями;
мы обучаем агента 10 миллионов шагов (n_timesteps);
размер памяти (воспроизведения опыта) — 100 000, то есть столько шагов опыта хранится, чтобы снова учить на них агента.

💡 Мой совет — уменьшить число шагов обучения до 1 млн: это около 90 минут на P100. !nvidia-smi покажет, какая у вас GPU. 10 миллионов шагов займут около 9 часов. Такое лучше запускать на своём компьютере (или где-то ещё): нажмите File > Download.

Что касается подбора гиперпараметров, советую сосредоточиться на трёх:

learning_rate;
buffer_size (размер памяти опыта);
batch_size.

Хорошая практика — заглянуть в документацию и понять, что делает каждый гиперпараметр: параметры DQN в SB3.

2. Запустить обучение и сохранить модели в папку logs 📁. Укажите алгоритм после --algo, папку для модели после -f и файл конфигурации гиперпараметров после -c.

python -m rl_zoo3.train --algo ________ --env SpaceInvadersNoFrameskip-v4  -f _________  -c _________

Решение

python -m rl_zoo3.train --algo dqn  --env SpaceInvadersNoFrameskip-v4 -f logs/ -c dqn.yml

Оцениваем агента 👀

В RL-Baselines3-Zoo есть enjoy.py — скрипт на Python для оценки агента. В большинстве библиотек RL скрипт оценки называют enjoy.py.
Оценим агента на 5000 шагах 🔥

python -m rl_zoo3.enjoy  --algo dqn  --env SpaceInvadersNoFrameskip-v4  --no-render  --n-timesteps _________  --folder logs/

Решение

python -m rl_zoo3.enjoy  --algo dqn  --env SpaceInvadersNoFrameskip-v4  --no-render  --n-timesteps 5000  --folder logs/

Публикуем обученную модель на Hub 🚀

Мы убедились, что после обучения результаты хорошие, и теперь можем одной строкой кода опубликовать модель на Hub 🤗. В оригинале здесь анимация: обученный агент играет в Space Invaders.

С rl_zoo3.push_to_hub вы оцениваете агента, записываете видео игры, создаёте карточку модели и выкладываете всё на Hub. Так вы можете:

показать свою работу 🔥;
посмотреть, как играет агент 👀;
поделиться с сообществом агентом, которым могут пользоваться другие 💾;
попасть на лидерборд 🏆 и сравнить своего агента с агентами однокурсников: Deep RL Leaderboard.

Чтобы поделиться моделью с сообществом, нужно сделать ещё три шага.

1️⃣ (Если ещё нет) создайте аккаунт на HF: huggingface.co/join.

2️⃣ Войдите и сохраните токен авторизации с сайта Hugging Face:

создайте новый токен (huggingface.co/settings/tokens) с правом записи (write);
скопируйте токен;
запустите ячейку ниже и вставьте токен.

from huggingface_hub import notebook_login  # чтобы войти в аккаунт Hugging Face и загружать модели на Hub
notebook_login()
!git config --global credential.helper store

Если вы не пользуетесь Google Colab или Jupyter Notebook, используйте вместо этого команду huggingface-cli login.

3️⃣ Теперь всё готово, чтобы выложить обученного агента на Hub 🤗 🔥. Запустим push_to_hub:

--repo-name — название репозитория;
-orga — ваше имя пользователя на Hugging Face;
-f — где лежит папка с обученной моделью (у нас logs).

python -m rl_zoo3.push_to_hub  --algo dqn  --env SpaceInvadersNoFrameskip-v4  --repo-name _____________________ -orga _____________________ -f logs/

Решение

python -m rl_zoo3.push_to_hub  --algo dqn  --env SpaceInvadersNoFrameskip-v4  --repo-name dqn-SpaceInvadersNoFrameskip-v4  -orga ThomasSimonini  -f logs/

Поздравляем 🥳, вы только что обучили и выложили своего первого агента Deep Q-Learning с помощью RL-Baselines-3 Zoo. Скрипт выше должен был вывести ссылку на репозиторий модели вида https://huggingface.co/ThomasSimonini/dqn-SpaceInvadersNoFrameskip-v4. Перейдя по ней, вы можете:

посмотреть видео игры агента справа;
нажать «Files and versions», чтобы увидеть все файлы репозитория;
нажать «Use in stable-baselines3», чтобы получить фрагмент кода для загрузки модели;
прочитать карточку модели (файл README.md) — описание модели и использованных гиперпараметров.

Внутри Hub использует репозитории на основе git (не страшно, если вы не знаете, что такое git). Это значит, что по мере экспериментов и улучшения агента можно выкладывать новые версии модели.

Сравните результаты своих агентов с однокурсниками на лидерборде 🏆.

Загружаем сильную обученную модель 🔥

Команда Stable-Baselines3 выложила на Hub больше 150 обученных агентов глубокого обучения с подкреплением. Они собраны здесь: huggingface.co/sb3. Несколько примеров:

Asteroids: sb3/dqn-AsteroidsNoFrameskip-v4
Beam Rider: sb3/dqn-BeamRiderNoFrameskip-v4
Breakout: sb3/dqn-BreakoutNoFrameskip-v4
Road Runner: sb3/dqn-RoadRunnerNoFrameskip-v4

Загрузим агента, который играет в Beam Rider: sb3/dqn-BeamRiderNoFrameskip-v4. В ноутбуке здесь показывается видео его игры.

Скачиваем модель с помощью rl_zoo3.load_from_hub и кладём её в новую папку, назовём её rl_trained:

# Скачать модель и сохранить её в папку rl_trained/
python -m rl_zoo3.load_from_hub --algo dqn --env BeamRiderNoFrameskip-v4 -orga sb3 -f rl_trained/

Оценим её на 5000 шагах:

python -m rl_zoo3.enjoy --algo dqn --env BeamRiderNoFrameskip-v4 -n 5000  -f rl_trained/ --no-render

Почему бы не попробовать обучить своего агента Deep Q-Learning для BeamRiderNoFrameskip-v4? 🏆 Если захотите, загляните в карточку модели: там указаны гиперпараметры обученного агента.

Но подбирать гиперпараметры — дело непростое. К счастью, в следующем юните мы увидим, как подбирать гиперпараметры с помощью Optuna 🔥.

Дополнительные задания 🏆

Лучший способ учиться — пробовать самому! На лидерборде есть ваши агенты. Сможете пробиться наверх?

Вот среды, в которых можно попробовать обучить агента:

BeamRiderNoFrameskip-v4
BreakoutNoFrameskip-v4
EnduroNoFrameskip-v4
PongNoFrameskip-v4

А если захотите реализовать Deep Q-Learning сами, обязательно посмотрите реализацию CleanRL: dqn_atari.py.

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

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

Этот курс мы делаем вместе с вами 👷🏿‍♀️. Мы хотим постепенно улучшать курс по вашим отзывам. Если они есть, заполните, пожалуйста, форму. Увидимся в бонусном юните 2! 🔥 Продолжайте учиться и оставайтесь крутыми 🤗

Тест

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

Вопрос 1. Мы сказали, что Q-learning — табличный метод. Что такое табличные методы?

Ответ

Табличные методы — тип задач, где пространства состояний и действий достаточно малы, чтобы функции ценности можно было хранить в виде массивов и таблиц. Например, Q-learning — табличный метод: ценности пар «состояние — действие» мы храним в таблице.

Тест к юниту 32 вопроса

1 Вопрос 2. Почему классическим Q-learning нельзя решить игру Atari?Среды Atari слишком быстрые для Q-learningУ сред Atari огромное пространство наблюдений, поэтому создавать и обновлять Q-таблицу неэффективно

2 Вопрос 4. Какие две фазы есть у Deep Q-Learning?Можно выбрать несколько ответовСэмплированиеПеремешиваниеПереранжированиеОбучение

Вопрос 3. Зачем в Deep Q-Learning складывать в стопку четыре кадра, когда вход — кадры?

Ответ

Это помогает справиться с проблемой временно́го ограничения: одного кадра недостаточно, чтобы получить информацию о времени. Например, в Pong агент не сможет понять, куда летит мяч, если получит только один кадр.

Вопрос 5. Зачем в Deep Q-Learning нужна память воспроизведения?

Ответ

1. Эффективнее использовать опыт во время обучения. Обычно в онлайн-обучении с подкреплением агент взаимодействует со средой, получает опыт (состояние, действие, награду и следующее состояние), учится на нём (обновляет нейросеть) и выбрасывает его. Это неэффективно. А с воспроизведением опыта мы заводим буфер, который хранит примеры опыта для повторного использования при обучении.

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

Вопрос 6. Как применяется Double Deep Q-Learning?

Ответ

При вычислении Q-цели мы используем две сети, чтобы разделить выбор действия и вычисление целевого Q-значения:

сетью DQN выбираем лучшее действие для следующего состояния (действие с наибольшим Q-значением);
целевой сетью считаем целевое Q-значение этого действия в следующем состоянии.

Поздравляем с окончанием теста 🥳! Если что-то упустили, перечитайте главу и подкрепите (😏) знания.

Заключение

Поздравляем с окончанием главы! Информации было много. И поздравляем с окончанием практического занятия: вы только что обучили своего первого агента Deep Q-Learning и поделились им на Hub 🥳.

Не спешите и как следует разберитесь в материале, прежде чем идти дальше.

Не стесняйтесь обучать агента в других средах (Pong, Seaquest, QBert, Ms Pac Man). Лучший способ учиться — пробовать самому!

В следующем юните мы познакомимся с Optuna. Одна из важнейших задач в глубоком обучении с подкреплением — найти хороший набор гиперпараметров обучения. Optuna — библиотека, которая помогает автоматизировать поиск. Бонусный юнит 2 об Optuna описан в путеводителе по юнитам 5, 7 и бонусам, а следующий большой юнит — градиент политики.

Авторы курса будут рады узнать ваше мнение о курсе и о том, как его улучшить — для этого есть форма обратной связи.

Продолжайте учиться и оставайтесь крутыми 🤗

Дополнительное чтение

Это необязательные материалы для тех, кто хочет копнуть глубже.

Foundations of Deep RL Series, L2: Deep Q-Learning — Питер Аббил (видео).
Playing Atari with Deep Reinforcement Learning — первая статья о DQN.
Double Q-learning — статья Хадо ван Хасселта.
Prioritized Experience Replay.
Dueling Deep Q-Learning.

Словарик

English	Русский
Deep Q-Learning, Deep Q-Network (DQN)	глубокое Q-обучение, глубокая Q-сеть
tabular method	табличный метод
parametrized Q-function $Q_\theta$	параметризованная Q-функция
frame stacking	стопка кадров
temporal limitation	временно́е ограничение
convolutional layer / fully connected layer	свёрточный слой / полносвязный слой
sampling / training phase	фаза сэмплирования / обучения
experience replay, replay buffer (memory)	воспроизведение опыта, буфер (память) воспроизведения
catastrophic forgetting (interference)	катастрофическое забывание (интерференция)
TD target, Q-target	TD-цель, Q-цель
fixed Q-target, target network	фиксированная Q-цель, целевая сеть
overestimation	переоценка
Double DQN	Double DQN (двойной DQN)
Prioritized Experience Replay, Dueling DQN	приоритизированное воспроизведение опыта, Dueling DQN

Перевод выполнен по лицензии оригинала (Apache-2.0); автор оригинала — Hugging Face (Томас Симонини; глоссарий — Дарио Паэс). Нашли неточность — сверяйтесь с оригиналом по ссылке выше. · обновлено 2026-10-04