Deep RL Course, юнит 1, практика: сажаем лунный модуль

Перевод практического занятия первого юнита курса Hugging Face: знакомство с Gymnasium, среда LunarLander, обучение агента PPO в Stable-Baselines3, оценка, публикация на Hub и загрузка чужой модели.

Это перевод практического занятия юнита 1 курса Hugging Face Deep RL Course (ноутбук notebooks/unit1/unit1.ipynb). Теория юнита — на странице «Юнит 1: введение в глубокое обучение с подкреплением», карта курса — в путеводителе.

Здесь вы впервые запускаете настоящего агента, но алгоритм (PPO) работает «чёрным ящиком»: что внутри, станет ясно только в уроке 6.0.3 и в юните 8. Из этой практики сейчас важно другое: как устроен цикл «среда — действие — награда» в Gymnasium (те же понятия, что в уроке 6.0.1) и как читать описание среды: наблюдения, действия, награды. Вернитесь к ноутбуку после юнита 8 — гиперпараметры gamma, gae_lambda, n_epochs и ent_coef тогда станут понятны.

В свежих версиях Gymnasium (1.x) среды LunarLander-v2 больше нет: gym.make("LunarLander-v2") выдаёт ошибку DeprecatedEnv с советом взять LunarLander-v3. Заменяйте v2 на v3 во всём коде ниже; остальное работает без изменений (мы проверили создание среды и модели PPO с Gymnasium 1.3 и Stable-Baselines3 2.9).
Сеть агента маленькая (MLP), поэтому обучение идёт и на CPU. По оценке авторов, 1 млн шагов — около 20 минут в Colab. Для первого знакомства хватит 100–200 тысяч шагов: награда уже заметно растёт, хотя до 200 очков ещё далеко.
Ячейки с apt и виртуальным дисплеем нужны только в Colab и на машинах без экрана. Публикация на Hub необязательна: лидерборд курса выключен.

Обучите своего первого агента глубокого обучения с подкреплением 🤖

Теперь, когда вы изучили основы обучения с подкреплением, вы готовы обучить своего первого агента и поделиться им с сообществом через Hub 🔥: агента «лунный модуль», который научится правильно садиться на Луну 🌕.

И наконец, вы загрузите обученного агента на Hugging Face Hub 🤗 — бесплатную открытую платформу, где люди делятся моделями машинного обучения, датасетами и демо.

Благодаря нашему лидерборду вы сможете сравнить свои результаты с однокурсниками и обменяться приёмами, улучшающими счёт агента. Кто выиграет состязание юнита 1 🏆?

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

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

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

Юнит 1: обучите своего первого агента глубокого обучения с подкреплением 🤖

В этом ноутбуке вы обучите своего первого агента глубокого обучения с подкреплением — лунный модуль, который научится правильно садиться на Луну 🌕, — с помощью Stable-Baselines3, библиотеки глубокого обучения с подкреплением, поделитесь им с сообществом и поэкспериментируете с разными настройками.

Среда 🎮: LunarLander-v2.

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

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

Цели ноутбука 🏆

К концу ноутбука вы сможете:

пользоваться Gymnasium — библиотекой сред;
пользоваться Stable-Baselines3 — библиотекой глубокого обучения с подкреплением;
выложить обученного агента на Hub с красивым видео игры и оценкой качества 🔥.

Этот ноутбук — из курса Deep Reinforcement Learning

В этом бесплатном курсе вы:

📖 изучите глубокое обучение с подкреплением в теории и на практике;
🧑‍💻 научитесь пользоваться известными библиотеками Deep RL: Stable Baselines3, RL Baselines3 Zoo, CleanRL и Sample Factory 2.0;
🤖 обучите агентов в необычных средах;
🎓 получите сертификат об окончании, выполнив 80% заданий.

И многое другое! Программа курса — здесь. Лучший способ оставаться на связи и задавать вопросы — присоединиться к нашему Discord-серверу: discord.gg/ydHrjt3WP5.

Что нужно заранее 🏗️

🔲 📝 Прочитать юнит 0 — там вся информация о курсе 🤗 (главное — в нашем путеводителе).
🔲 📚 Разобраться в основах обучения с подкреплением (MC, TD, гипотеза о награде…), прочитав юнит 1 (перевод).

Краткое повторение глубокого обучения с подкреплением 📚

Повторим, что мы узнали в первом юните.

Обучение с подкреплением — вычислительный подход к обучению на собственных действиях. Мы строим агента, который учится у среды, взаимодействуя с ней методом проб и ошибок и получая награды (отрицательные или положительные) как обратную связь.
Цель любого агента RL — максимизировать ожидаемую накопленную награду (её называют также ожидаемой отдачей), потому что RL основано на гипотезе о награде: любую цель можно описать как максимизацию ожидаемой накопленной награды.
Процесс RL — это петля, которая выдаёт последовательность «состояние, действие, награда, следующее состояние».
Чтобы посчитать ожидаемую накопленную награду (ожидаемую отдачу), мы дисконтируем награды: награды, которые приходят раньше (в начале игры), вероятнее, потому что они предсказуемее, чем далёкие будущие награды.
Чтобы решить задачу RL, нужно найти оптимальную политику. Политика — «мозг» ИИ: она говорит, какое действие выбрать в данном состоянии. Оптимальная политика даёт действия, максимизирующие ожидаемую отдачу.

Найти оптимальную политику можно двумя способами:

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

Наконец, мы говорим о глубоком RL, потому что вводим глубокие нейросети, чтобы оценивать действие (в методах на основе политики) или ценность состояния (в методах на основе ценности); отсюда и слово «глубокое».

Обучим первого агента глубокого обучения с подкреплением и выложим его на Hub 🚀

Включаем GPU 💪

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

Устанавливаем зависимости и создаём виртуальный экран 🔽

Первый шаг — установить зависимости. Их несколько:

gymnasium[box2d] — содержит среду LunarLander-v2 🌛;
stable-baselines3[extra] — библиотека глубокого обучения с подкреплением;
huggingface_sb3 — дополнительный код для Stable-Baselines3, чтобы загружать модели на Hugging Face 🤗 Hub и скачивать их оттуда.

Для удобства мы сделали скрипт, который ставит все эти зависимости.

apt install swig cmake

pip install -r https://raw.githubusercontent.com/huggingface/deep-rl-class/main/notebooks/unit1/requirements-unit1.txt

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

sudo apt-get update
apt install python3-opengl
apt install ffmpeg
apt install xvfb
pip3 install pyvirtualdisplay

Чтобы новые библиотеки точно подхватились, иногда нужно перезапустить среду выполнения ноутбука. Следующая ячейка намеренно «роняет» среду выполнения: переподключитесь и продолжайте с этого места. Благодаря этому трюку виртуальный экран заработает.

import os

os.kill(os.getpid(), 9)

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

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

Импортируем пакеты 📦

Дополнительно импортируем huggingface_hub, чтобы загружать обученные модели на Hub и скачивать их оттуда.

Hugging Face Hub 🤗 — центральное место, где любой может делиться моделями и датасетами и искать их. В нём есть версии, метрики, визуализации и другие возможности для совместной работы. Все модели глубокого обучения с подкреплением на Hub — здесь.

import gymnasium

from huggingface_sb3 import load_from_hub, package_to_hub
from huggingface_hub import (
    notebook_login,
)  # чтобы войти в аккаунт Hugging Face и загружать модели на Hub

from stable_baselines3 import PPO
from stable_baselines3.common.env_util import make_vec_env
from stable_baselines3.common.evaluation import evaluate_policy
from stable_baselines3.common.monitor import Monitor

Разбираемся, как устроен Gymnasium 🤖

🏋 Библиотека с нашей средой называется Gymnasium. Вы будете часто пользоваться Gymnasium в глубоком обучении с подкреплением. Gymnasium — новая версия библиотеки Gym, которую поддерживает Farama Foundation.

Библиотека Gymnasium даёт две вещи:

интерфейс, который позволяет создавать среды RL;
набор сред (gym-control, atari, box2D…).

Посмотрим на пример, но сначала вспомним петлю RL. На каждом шаге:

агент получает от среды состояние $S_0$ — первый кадр игры;
на основе состояния $S_0$ агент совершает действие $A_0$ — идёт вправо;
среда переходит в новое состояние $S_1$ — новый кадр;
среда выдаёт агенту награду $R_1$ — мы не погибли (положительная награда +1).

С Gymnasium:

1️⃣ создаём среду через gymnasium.make();

2️⃣ сбрасываем среду в начальное состояние: observation = env.reset().

На каждом шаге:

3️⃣ получаем действие от модели (в нашем примере — случайное);

4️⃣ через env.step(action) выполняем это действие в среде и получаем:

observation — новое состояние ( $s_{t+1}$ );
reward — награду за выполненное действие;
terminated — закончился ли эпизод (агент попал в терминальное состояние);
truncated — появилось в новой версии: эпизод оборван, например, по лимиту времени или потому, что агент вышел за границы среды;
info — словарь с дополнительной информацией (зависит от среды).

Подробнее — в документации Env.step.

Если эпизод закончился, сбрасываем среду в начальное состояние: observation = env.reset().

flowchart LR
M["gym.make"] --> R["env.reset: начальное наблюдение"]
R --> A["выбрать действие"]
A --> S["env.step: наблюдение, награда, terminated, truncated, info"]
S -->|"эпизод идёт"| A
S -->|"terminated или truncated"| R

Цикл работы со средой в Gymnasium

Посмотрим на пример! Обязательно прочитайте код.

import gymnasium as gym

# Сначала создаём среду LunarLander-v2
env = gym.make("LunarLander-v2")

# Затем сбрасываем среду
observation, info = env.reset()

for _ in range(20):
    # Выбираем случайное действие
    action = env.action_space.sample()
    print("Action taken:", action)

    # Выполняем действие в среде и получаем
    # следующее состояние, награду, terminated, truncated и info
    observation, reward, terminated, truncated, info = env.step(action)

    # Если игра закончилась (в нашем случае — сели или разбились) или оборвана (тайм-аут)
    if terminated or truncated:
        # Сбрасываем среду
        print("Environment is reset")
        observation, info = env.reset()

env.close()

Создаём среду LunarLander 🌛 и разбираемся, как она устроена

Среда 🎮

В этом первом занятии мы обучим агента — лунный модуль — правильно садиться на Луну. Для этого агенту нужно научиться подстраивать скорость и положение (по горизонтали, по вертикали и по углу), чтобы сесть правильно.

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

Посмотрим, как выглядит среда:

# Создаём среду: gym.make("<название_среды>")
env = gym.make("LunarLander-v2")
env.reset()
print("_____OBSERVATION SPACE_____ \n")
print("Observation Space Shape", env.observation_space.shape)
print("Sample observation", env.observation_space.sample())  # случайное наблюдение

По Observation Space Shape (8,) видно, что наблюдение — вектор из 8 чисел, каждое из которых несёт свою информацию о модуле:

координата по горизонтали (x);
координата по вертикали (y);
скорость по горизонтали (x);
скорость по вертикали (y);
угол;
угловая скорость;
касается ли земли левая опора (булево значение);
касается ли земли правая опора (булево значение).

print("\n _____ACTION SPACE_____ \n")
print("Action Space Shape", env.action_space.n)
print("Action Space Sample", env.action_space.sample())  # случайное действие

Пространство действий (множество действий, доступных агенту) дискретное, действий 4 🎮:

действие 0 — ничего не делать;
действие 1 — включить левый двигатель ориентации;
действие 2 — включить главный двигатель;
действие 3 — включить правый двигатель ориентации.

Функция награды (функция, которая выдаёт награду на каждом шаге) 💰:

После каждого шага выдаётся награда. Полная награда эпизода — сумма наград за все шаги эпизода.

На каждом шаге награда:

растёт или падает, когда модуль приближается к посадочной площадке или удаляется от неё;
растёт или падает, когда модуль движется медленнее или быстрее;
уменьшается, чем сильнее модуль наклонён (угол не горизонтальный);
увеличивается на 10 очков за каждую опору, касающуюся земли;
уменьшается на 0,03 очка за каждый кадр работы бокового двигателя;
уменьшается на 0,3 очка за каждый кадр работы главного двигателя.

Эпизод получает дополнительную награду −100 или +100 очков за крушение или за безопасную посадку соответственно.

Эпизод считается решённым, если набрал не меньше 200 очков.

Векторизованная среда

Создадим векторизованную среду (способ объединить несколько независимых сред в одну) из 16 сред: так во время обучения опыт будет разнообразнее.

# Создаём среду
env = make_vec_env("LunarLander-v2", n_envs=16)

Создаём модель 🤖

Мы изучили среду и поняли задачу: научиться правильно сажать модуль на площадку, управляя левым, правым и главным двигателями. Теперь соберём алгоритм, которым будем решать эту задачу 🚀.

Для этого воспользуемся первой библиотекой глубокого RL — Stable Baselines3 (SB3). SB3 — набор надёжных реализаций алгоритмов обучения с подкреплением на PyTorch.

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

Чтобы решить эту задачу, возьмём PPO из SB3. PPO (Proximal Policy Optimization) — один из лучших (SOTA) алгоритмов глубокого обучения с подкреплением; вы изучите его в этом курсе.

PPO — это сочетание:

метода RL на основе ценности: обучения функции ценности действия, которая говорит, какое действие ценнее всего в данном состоянии;
метода RL на основе политики: обучения политики, которая выдаёт распределение вероятностей по действиям.

Stable-Baselines3 настраивается просто:

1️⃣ создаёте среду (у нас это уже сделано выше);

2️⃣ задаёте модель, которую хотите использовать, и создаёте её: model = PPO("MlpPolicy");

3️⃣ обучаете агента через model.learn, указав число шагов обучения.

# Создаём среду
env = gym.make('LunarLander-v2')

# Создаём агента
model = PPO('MlpPolicy', env, verbose=1)
# Обучаем агента
model.learn(total_timesteps=int(2e5))

# TODO: задайте архитектуру PPO MlpPolicy
# Берём многослойный перцептрон (MlpPolicy), потому что на входе вектор;
# если бы на входе были кадры, мы взяли бы CnnPolicy
model =

Решение

# РЕШЕНИЕ
# Мы добавили несколько параметров, чтобы ускорить обучение
model = PPO(
    policy="MlpPolicy",
    env=env,
    n_steps=1024,
    batch_size=64,
    n_epochs=4,
    gamma=0.999,
    gae_lambda=0.98,
    ent_coef=0.01,
    verbose=1,
)

Обучаем агента PPO 🏃

Обучим агента на 1 000 000 шагов; не забудьте включить GPU в Colab. Это займёт примерно 20 минут, но если хотите просто попробовать, можно взять меньше шагов.
Пока идёт обучение, сделайте перерыв на ☕ — вы его заслужили 🤗

# TODO: обучите модель на 1 000 000 шагов

# TODO: задайте имя файла модели и сохраните модель в файл
model_name = "ppo-LunarLander-v2"

Решение

# РЕШЕНИЕ
# Обучаем на 1 000 000 шагов
model.learn(total_timesteps=1000000)
# Сохраняем модель
model_name = "ppo-LunarLander-v2"
model.save(model_name)

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

Не забудьте обернуть среду в Monitor.
Агент обучен 🚀 — теперь нужно проверить его качество.
В Stable-Baselines3 для этого есть метод evaluate_policy.
Чтобы заполнить эту часть, загляните в документацию.
На следующем шаге мы увидим, как автоматически оценить агента и выложить его на лидерборд, а пока сделаем это сами.

💡 Оценивая агента, не используйте среду, на которой он обучался: создайте отдельную среду для оценки.

# TODO: оцените агента
# Создайте новую среду для оценки
eval_env =

# Оцените модель на 10 эпизодах с deterministic=True
mean_reward, std_reward =

# Выведите результаты

Решение

eval_env = Monitor(gym.make("LunarLander-v2"))
mean_reward, std_reward = evaluate_policy(model, eval_env, n_eval_episodes=10, deterministic=True)
print(f"mean_reward={mean_reward:.2f} +/- {std_reward}")

У меня после обучения на 1 млн шагов получилась средняя награда 200.20 +/- 20.80: значит, наш лунный модуль готов садиться на Луну 🌛🥳.

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

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

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

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

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

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

2️⃣ Войдите и сохраните токен авторизации с сайта Hugging Face: создайте новый токен (huggingface.co/settings/tokens) с правом записи (write), скопируйте его, запустите ячейку ниже и вставьте токен.

notebook_login()
!git config --global credential.helper store

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

3️⃣ Теперь всё готово, чтобы выложить обученного агента на Hub 🤗 🔥 функцией package_to_hub(). Заполним её аргументы:

model — обученная модель;
model_name — имя обученной модели, которое мы задали при сохранении;
model_architecture — архитектура модели, у нас PPO;
env_id — название среды, у нас LunarLander-v2;
eval_env — среда для оценки, заданная в eval_env;
repo_id — название репозитория на Hugging Face Hub, который будет создан или обновлён (repo_id = {username}/{repo_name}).

💡 Хорошее имя — {username}/{model_architecture}-{env_id}.

commit_message — сообщение коммита.

import gymnasium as gym
from stable_baselines3.common.vec_env import DummyVecEnv
from stable_baselines3.common.env_util import make_vec_env

from huggingface_sb3 import package_to_hub

## TODO: задайте repo_id
## repo_id — id репозитория модели на Hugging Face Hub (repo_id = {organization}/{repo_name}, например ThomasSimonini/ppo-LunarLander-v2)
repo_id =

# TODO: задайте название среды
env_id =

# Создаём среду для оценки с render_mode="rgb_array"
eval_env = DummyVecEnv([lambda: gym.make(env_id, render_mode="rgb_array")])


# TODO: укажите архитектуру модели
model_architecture = ""

## TODO: задайте сообщение коммита
commit_message = ""

# метод сохраняет модель, оценивает её, создаёт карточку модели и записывает видео игры агента, а затем отправляет репозиторий на Hub
package_to_hub(model=model, # обученная модель
               model_name=model_name, # имя обученной модели
               model_architecture=model_architecture, # архитектура модели: у нас PPO
               env_id=env_id, # название среды
               eval_env=eval_env, # среда для оценки
               repo_id=repo_id, # id репозитория модели на Hugging Face Hub (repo_id = {organization}/{repo_name}, например ThomasSimonini/ppo-LunarLander-v2)
               commit_message=commit_message)

Решение

import gymnasium as gym

from stable_baselines3 import PPO
from stable_baselines3.common.vec_env import DummyVecEnv
from stable_baselines3.common.env_util import make_vec_env

from huggingface_sb3 import package_to_hub

# ВСТАВЬТЕ переменные, которые вы задали двумя ячейками выше
# Название среды
env_id = "LunarLander-v2"

# Архитектура модели
model_architecture = "PPO"

## repo_id — id репозитория модели на Hugging Face Hub (repo_id = {organization}/{repo_name}, например ThomasSimonini/ppo-LunarLander-v2)
## ЗАМЕНИТЕ НА СВОЙ REPO ID
repo_id = "ThomasSimonini/ppo-LunarLander-v2"  # замените на свой repo id: в мой загрузить не получится 😄

## Сообщение коммита
commit_message = "Upload PPO LunarLander-v2 trained agent"

# Создаём среду для оценки с render_mode="rgb_array"
eval_env = DummyVecEnv([lambda: Monitor(gym.make(env_id, render_mode="rgb_array"))])

# ВСТАВЬТЕ сюда заполненный вызов package_to_hub
package_to_hub(
    model=model,  # обученная модель
    model_name=model_name,  # имя обученной модели
    model_architecture=model_architecture,  # архитектура модели: у нас PPO
    env_id=env_id,  # название среды
    eval_env=eval_env,  # среда для оценки
    repo_id=repo_id,  # id репозитория модели на Hugging Face Hub
    commit_message=commit_message,
)

Поздравляем 🥳, вы только что обучили и выложили своего первого агента глубокого обучения с подкреплением. Скрипт выше должен был вывести ссылку на репозиторий модели вида https://huggingface.co/osanseviero/test_sb3. Перейдя по ней, вы можете:

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

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

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

Загружаем сохранённую модель LunarLander с Hub 🤗

Спасибо ironbar за этот раздел.

Загрузить сохранённую модель с Hub очень просто. Откройте список всех моделей Stable-Baselines3.

Выберите модель и скопируйте её repo_id.
Вызовите load_from_hub, передав:
- repo_id;
- filename — имя сохранённой модели в репозитории вместе с расширением (*.zip).

Модель, которую я скачиваю с Hub, обучена с Gym (предыдущей версией Gymnasium), поэтому нужно поставить shimmy — инструмент преобразования API, который поможет правильно запустить среду. Документация Shimmy: github.com/Farama-Foundation/Shimmy.

pip install shimmy

from huggingface_sb3 import load_from_hub

repo_id = "Classroom-workshop/assignment2-omar"  # repo_id
filename = "ppo-LunarLander-v2.zip"  # имя файла модели .zip

# Если модель обучали на Python 3.8, протокол pickle — 5,
# а Python 3.6 и 3.7 используют протокол 4.
# Для совместимости нужно:
# 1. Поставить pickle5 (мы сделали это в начале ноутбука)
# 2. Создать пустой объект и передать его в PPO.load()
custom_objects = {
    "learning_rate": 0.0,
    "lr_schedule": lambda _: 0.0,
    "clip_range": lambda _: 0.0,
}

checkpoint = load_from_hub(repo_id, filename)
model = PPO.load(checkpoint, custom_objects=custom_objects, print_system_info=True)

Оценим этого агента:

eval_env = Monitor(gym.make("LunarLander-v2"))
mean_reward, std_reward = evaluate_policy(model, eval_env, n_eval_episodes=10, deterministic=True)
print(f"mean_reward={mean_reward:.2f} +/- {std_reward}")

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

Лучший способ учиться — пробовать самому! Как вы видели, нынешний агент играет не блестяще. Для начала можно учить его дольше: с 1 000 000 шагов мы видели отличные результаты!

На лидерборде есть ваши агенты. Сможете пробиться наверх? Несколько идей:

учить дольше;
попробовать другие гиперпараметры PPO — их список есть в документации;
заглянуть в документацию Stable-Baselines3 и попробовать другую модель, например DQN;
выложить новую обученную модель на Hub 🔥.

Посадка на Луну наскучила? Попробуйте сменить среду: почему бы не взять MountainCar-v0, CartPole-v1 или CarRacing-v0? Посмотрите, как они устроены, в документации gym, и развлекайтесь 🎉.

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

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

В следующий раз, в бонусном юните 1, вы научите собаку Хагги приносить палку (описание — в путеводителе по юнитам 5, 7 и бонусам); следующий большой юнит — Q-learning.

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

Словарик

English	Русский
hands-on, notebook	практическое занятие, ноутбук
Gymnasium (Gym), Farama Foundation	Gymnasium (бывший Gym), фонд Farama
`reset()`, `step()`	сброс среды, шаг в среде
terminated / truncated	эпизод закончился / оборван (по лимиту времени и т. п.)
observation space / action space	пространство наблюдений / пространство действий
landing pad, main engine, orientation engine	посадочная площадка, главный двигатель, двигатель ориентации
vectorized environment	векторизованная среда
MlpPolicy / CnnPolicy	политика-перцептрон / свёрточная политика
evaluation environment, `evaluate_policy`	среда для оценки, функция оценки
deterministic evaluation	детерминированная оценка (без случайности в выборе действий)
model card, repo_id	карточка модели, id репозитория

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