Deep Reinforcement Learning: Создание ИИ для игр

Введение в Reinforcement Learning: Агент, Среда и Марковские процессы принятия решений

Добро пожаловать в курс по Deep Reinforcement Learning (глубокому обучению с подкреплением). Если вы когда-либо видели, как ИИ обыгрывает чемпионов мира в Go, Dota 2 или StarCraft II, и хотели понять, как это работает — вы попали по адресу. В этой первой статье мы разберем фундамент, на котором строятся все современные алгоритмы: от простых табличных методов до сложных нейросетей.

Что такое обучение с подкреплением?

Обучение с подкреплением (Reinforcement Learning, RL) — это раздел машинного обучения, где мы учим агента принимать решения, взаимодействуя со средой. В отличие от обучения с учителем (Supervised Learning), где у нас есть правильные ответы (датасет с метками), в RL правильных ответов заранее нет. Агент должен сам найти выигрышную стратегию методом проб и ошибок.

Представьте, что вы учите собаку команде «сидеть». Вы не объясняете ей законы физики или биомеханику движения лап. Вы говорите команду, и если собака садится, вы даете ей лакомство. Если она прыгает — вы ничего не даете. Со временем собака понимает: «Ага, если я сяду после этого звука, мне будет вкусно». Это и есть суть RL.

Основные компоненты RL

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

Агент (Agent) — это наш ИИ, игрок, пилот или робот. Тот, кто принимает решения.

Среда (Environment) — это мир, в котором живет агент. Это может быть уровень в игре Super Mario, шахматная доска или симулятор биржевой торговли.

!Циклический процесс взаимодействия агента и среды

Процесс взаимодействия происходит пошагово:

Агент наблюдает текущее состояние среды ().

На основе состояния агент выбирает действие ().

Среда реагирует на действие, переходит в новое состояние () и выдает агенту награду ().

Цикл повторяется.

Разберем эти термины на примере игры Super Mario:

* Состояние (): Пиксели на экране (где находится Марио, где враги, где трубы). * Действие (): Нажать кнопку «вправо», «прыжок» или «бежать». * Награда (): +100 очков за монетку, +1000 за завершение уровня, -1000 за смерть (падение в яму).

Цель агента: Гипотеза о вознаграждении

Чего хочет агент? Он не хочет просто «выжить» или «победить» в человеческом понимании. В мире RL цель определяется математически.

> Гипотеза о вознаграждении: Все цели могут быть описаны как максимизация ожидаемого кумулятивного (суммарного) вознаграждения.

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

Формально это выглядит как простая сумма:

где: * — суммарный возврат (Return) начиная с момента времени . * — награды, полученные на каждом последующем шаге. * — последний шаг эпизода (например, конец игры).

Проблема бесконечности и Дисконтирование

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

Для решения этих проблем вводится коэффициент дисконтирования (гамма).

где: * — дисконтированный возврат. * — коэффициент дисконтирования, число в диапазоне . * — награда на шаге в будущем.

Как влияет на поведение агента?

* Если : Агент «близорук». Его волнует только мгновенная награда . * Если : Агент «дальновиден». Он готов терпеть убытки сейчас ради огромной награды в будущем.

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

Марковский процесс принятия решений (MDP)

Чтобы научить компьютер решать задачи RL, нам нужно формализовать среду математически. Для этого используется Марковский процесс принятия решений (Markov Decision Process, MDP).

Название происходит от свойства Маркова: «Будущее зависит только от настоящего, а не от прошлого». Это значит, что текущее состояние содержит абсолютно всю необходимую информацию для принятия решения. Историю того, как мы попали в это состояние, помнить не нужно.

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

Формально MDP определяется как кортеж из 5 элементов:

где: * — Множество состояний (State Space). Все возможные ситуации, в которых может оказаться агент. * — Множество действий (Action Space). Все, что агент может сделать. * — Функция перехода (Transition Probability). Это «физика» мира. Она показывает вероятность попасть в состояние из состояния , совершив действие . Записывается как . * — Функция награды (Reward Function). Показывает, какую награду мы получим, перейдя в состояние из с помощью действия . * — Коэффициент дисконтирования, который мы обсудили выше.

!Графическое представление Марковского процесса принятия решений

Политика (Policy)

Мы определили среду (MDP) и цель (максимизация ). Но как агенту выбирать действия? Здесь вступает в игру понятие Политики.

Политика — это «мозг» или стратегия агента. Она определяет поведение агента в конкретном состоянии. Обозначается греческой буквой (пи).

Политики бывают двух видов:

Детерминированная политика: Для каждого состояния жестко задано одно действие.

где — действие, которое нужно совершить в состоянии .

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

где — вероятность выбрать действие , находясь в состоянии .

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

Value Function и Q-Function

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

1. Функция ценности состояния (State-Value Function, )

Она отвечает на вопрос: «Насколько хорошо находиться в этом состоянии ?».

где: * — ценность состояния при следовании политике . * — математическое ожидание (среднее значение) при следовании политике . * — будущий дисконтированный возврат.

Если велико, значит, из этого состояния мы ожидаем получить много наград. В шахматах это эквивалентно оценке позиции (например, «у белых преимущество +2 пешки»).

2. Функция ценности действия (Action-Value Function, )

Она отвечает на вопрос: «Насколько хорошо совершить действие в состоянии ?».

где: * — ценность пары «состояние-действие» (Q-value).

Именно Q-функция является центральным элементом многих алгоритмов, таких как Q-Learning и DQN (Deep Q-Network), которые мы будем изучать в следующих статьях. Буква Q означает Quality (качество) действия.

Итоги

Сегодня мы заложили фундамент для создания игрового ИИ:

* RL — это обучение через пробы и ошибки. * Агент взаимодействует со Средой, получая Награды. * Цель агента — максимизировать сумму дисконтированных наград (). * MDP — математическая модель среды. * Политика () — стратегия выбора действий. * V-функция и Q-функция помогают оценивать ситуации и действия.

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

Глубокое Q-обучение (DQN): Как научить нейросеть играть в игры Atari

В предыдущей статье мы познакомились с основами обучения с подкреплением (RL), узнали, что такое агент, среда и Q-функция. Мы выяснили, что Q-функция (функция ценности действия) — это своего рода «шпаргалка», которая говорит агенту, какую награду он получит, если совершит определенное действие в определенном состоянии.

Сегодня мы сделаем огромный шаг вперед. Мы перейдем от теоретических основ к одной из самых знаменитых технологий в истории ИИ — Deep Q-Network (DQN). Именно этот алгоритм, разработанный компанией DeepMind в 2013 году, позволил компьютеру научиться играть в игры Atari 2600 (Breakout, Pong, Space Invaders) на уровне сверхчеловека, используя только пиксели экрана как входные данные.

Проблема табличного Q-обучения

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

Представьте игру «Крестики-нолики». Количество состояний там невелико, и мы легко можем создать таблицу для всех возможных позиций. Но что делать с видеоигрой, например, Space Invaders?

Состояние в видеоигре определяется картинкой на экране. Экран Atari имеет разрешение пикселей. Если каждый пиксель может быть одного из 256 цветов, то количество возможных состояний равно:

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

Здесь на сцену выходят нейронные сети.

Нейросеть как аппроксиматор функции

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

Мы заменяем Q-таблицу на Q-сеть (Q-Network). Это глубокая нейронная сеть, которая работает следующим образом:

Вход: Пиксели игрового экрана (текущее состояние ).

Скрытые слои: Сверточные слои (Convolutional Layers), которые распознают образы (мяч, ракетка, враги).

Выход: Значения Q для каждого возможного действия (например, «Вверх», «Вниз», «Огонь»).

!Архитектура Deep Q-Network: от пикселей к оценке действий

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

Проблемы обучения и их решения

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

1. Experience Replay (Воспроизведение опыта)

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

Чтобы решить эту проблему, DQN использует буфер воспроизведения опыта (Replay Buffer).

* Агент играет в игру и сохраняет каждый шаг (переход) в память. Переход выглядит как кортеж: . * Для обучения нейросети мы берем не последний шаг, а случайную выборку (batch) из этого буфера.

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

2. Target Network (Целевая сеть)

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

где: * — полученная награда. * — коэффициент дисконтирования. * — максимальная предсказанная ценность следующего состояния.

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

Решение DQN: использовать две нейросети.

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

Target Network (Целевая сеть, ): Копия основной сети. Её веса «заморожены» и обновляются редко (например, каждые 1000 шагов копируются из основной сети).

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

!Схема обучения с использованием Target Network

Функция потерь (Loss Function)

Как именно мы обновляем веса? Мы используем метод градиентного спуска, чтобы минимизировать ошибку между предсказанием нашей сети и целью, вычисленной с помощью Target Network.

Функция потерь (Loss) выглядит как среднеквадратичная ошибка (MSE):

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

Предобработка данных: Что видит нейросеть?

Игры Atari цветные, но цвет часто не важен для геймплея. Чтобы упростить задачу нейросети, входные данные проходят предобработку:

Grayscale: Картинка переводится в черно-белый формат.

Resizing: Уменьшение разрешения (обычно до ).

Frame Stacking (Стек кадров): Это критически важный момент. По одному статичному кадру невозможно понять, куда летит мяч — влево или вправо. Поэтому на вход нейросети подается не один кадр, а пачка из 4 последних кадров.

Таким образом, вход нейросети имеет размерность . Это позволяет ИИ «видеть» движение, скорость и ускорение объектов.

Алгоритм DQN: Полная картина

Соберем все вместе. Вот как выглядит цикл обучения DQN:

Инициализируем буфер воспроизведения (Replay Buffer).

Инициализируем основную сеть и целевую сеть.

Цикл игры:

* Агент получает состояние (стек из 4 кадров). * С вероятностью (эпсилон) выбирает случайное действие (исследование), иначе выбирает действие с максимальным Q-значением (эксплуатация). * Совершает действие, получает награду и новое состояние . * Сохраняет переход в буфер.

Цикл обучения:

* Берем случайный пакет переходов из буфера. * Вычисляем цель, используя Target Network. * Вычисляем предсказание, используя основную сеть. * Считаем ошибку и обновляем веса основной сети (Backpropagation). * Каждые шагов обновляем веса Target Network.

Заключение

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

В следующей статье мы рассмотрим улучшения DQN, такие как Double DQN и Dueling DQN, которые делают обучение еще более эффективным.

Методы градиента политики (Policy Gradient) и архитектура Actor-Critic

В предыдущих статьях мы изучили Q-обучение и алгоритм DQN. Эти методы относятся к семейству Value-based (основанных на ценности). Их логика такова: «Давайте выучим карту ценности всех состояний (-функцию), и тогда мы будем знать, какое действие лучшее». Агент выбирает действие с максимальным -значением.

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

Сегодня мы переходим к семейству методов Policy Gradient (градиент политики) и разберем одну из самых мощных архитектур в современном RL — Actor-Critic.

Ограничения методов на основе ценности (DQN)

Хотя DQN отлично справляется с играми Atari, у него есть фундаментальные ограничения:

Непрерывные пространства действий. В играх типа Pong у нас есть дискретные действия: «вверх», «вниз», «стоять». Но представьте, что вы учите робота ходить или управлять автомобилем. Угол поворота руля — это непрерывное число (например, 34.5 градуса). DQN должен найти по всем возможным . Если действий бесконечно много, найти максимум становится вычислительно невозможно.

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

Методы градиента политики решают эти проблемы.

Что такое параметризованная политика?

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

Обозначим нашу политику как .

где: * — политика (нейросеть). * — параметры (веса) этой нейросети. * — действие. * — состояние. * — вероятность того, что агент выберет действие в состоянии .

Наша цель — найти такие веса , которые максимизируют ожидаемую награду .

!Сравнение подходов: Value-Based оценивает действия, Policy-Based выбирает их напрямую.

Градиент политики (Policy Gradient)

Как нам обучать такую сеть? В Supervised Learning у нас есть правильные ответы, и мы минимизируем ошибку. Здесь правильных ответов нет. Но у нас есть возврат (Return) — сумма наград за эпизод.

Интуиция алгоритма REINFORCE (базовый метод Policy Gradient) проста:

Позволяем агенту сыграть эпизод, используя текущую политику.

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

Если наград мало (низкий или отрицательный ), мы уменьшаем вероятность этих действий.

Математически это выражается через градиентный подъем. Мы хотим максимизировать функцию . Формула градиента выглядит так:

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

Суть формулы: Мы берем направление, которое повышает вероятность действия (), и умножаем его на «силу» награды (). Если большое и положительное, мы сильно толкаем веса в эту сторону. Если отрицательное, мы толкаем веса в обратную сторону.

Проблема REINFORCE: Высокая дисперсия

Представьте, что агент сыграл в игру и получил +100 очков. Значит ли это, что все его действия были гениальными? Возможно, он сделал 99 глупых ходов и 1 гениальный, или просто ему повезло. Метод REINFORCE «наивен»: он подкрепляет все действия в удачном эпизоде.

Это приводит к огромной дисперсии (шуму) в обучении. Чтобы усреднить этот шум и найти истинный сигнал, нужно сыграть миллионы эпизодов. Обучение идет очень медленно.

Введение Базовой линии (Baseline)

Чтобы уменьшить шум, мы можем сравнивать полученную награду не с нулем, а со средним значением. Если агент получил +10 очков в ситуации, где обычно получает +5, это хорошо. А если получил +10 там, где обычно получает +50 — это плохо, даже если число положительное.

Мы вводим Baseline (базовую линию) . Обычно в качестве используют функцию ценности состояния .

Теперь мы обновляем веса пропорционально не , а Преимуществу (Advantage):

где: * — функция преимущества. Она показывает, насколько действие оказалось лучше, чем среднее ожидание в состоянии . * — реальный полученный результат. * — предсказанная ценность состояния (средний ожидаемый результат).

Но откуда взять , если наша нейросеть учит только политику ? Нам нужна вторая нейросеть!

Архитектура Actor-Critic (Актер-Критик)

Мы пришли к одной из самых эффективных концепций в RL. Мы используем две нейросети, которые работают в тандеме:

Actor (Актер, ): Эта сеть решает, что делать. Она принимает состояние и выдает действия. Это наш «спортсмен».

Critic (Критик, ): Эта сеть оценивает, насколько хороша ситуация. Она принимает состояние и выдает одно число — . Это наш «тренер».

!Актер взаимодействует со средой, а Критик оценивает действия Актера и помогает ему учиться.

Как происходит обучение?

Процесс выглядит как цикл обратной связи:

Шаг Актера: Актер наблюдает состояние и выбирает действие .

Реакция Среды: Среда возвращает награду и новое состояние .

Оценка Критика: Критик смотрит на то, что произошло, и вычисляет ошибку предсказания (TD-ошибку), которая служит оценкой преимущества:

где: * — ошибка временной разности (TD error), которая используется как оценка преимущества . * — полученная награда. * — коэффициент дисконтирования. * — функция ценности, предсказываемая Критиком с весами .

Обновление Критика: Критик обновляет свои веса , чтобы точнее предсказывать (минимизирует квадрат ).

Обновление Актера: Актер обновляет свои веса , используя подсказку от Критика (значение ) вместо сырого возврата :

где: * — скорость обучения (learning rate). * — оценка того, насколько действие было лучше ожидаемого (сигнал от Критика).

Почему это круто?

* Снижение дисперсии: Критик сглаживает шумные награды среды. Актер учится стабильнее. * Обучение онлайн: В отличие от REINFORCE, которому нужно ждать конца эпизода, чтобы посчитать , Actor-Critic может учиться на каждом шаге (используя TD-ошибку).

A2C и A3C

На практике часто используются модификации этого алгоритма:

* A2C (Advantage Actor-Critic): Синхронная версия. Несколько копий агента играют в параллельных средах, собирают данные, усредняют градиенты и обновляют одну общую нейросеть. * A3C (Asynchronous Advantage Actor-Critic): Асинхронная версия, где каждый агент обновляет глобальную сеть независимо. Это было прорывом от DeepMind в 2016 году, но сейчас чаще используют A2C из-за простоты реализации и эффективности использования GPU.

Заключение

Мы перешли от методов, которые просто запоминают ценность состояний (DQN), к методам, которые учат поведение (Policy Gradient), и объединили их в мощную архитектуру Actor-Critic. Актер учится действовать, а Критик учит Актера, оценивая его действия.

Эта архитектура лежит в основе самых современных алгоритмов, таких как PPO (Proximal Policy Optimization) и SAC (Soft Actor-Critic), которые используются сегодня для обучения роботов Boston Dynamics и ИИ в Dota 2. О них мы поговорим в будущих, продвинутых модулях курса.

Современные алгоритмы: Proximal Policy Optimization (PPO) и Soft Actor-Critic (SAC)

В предыдущей статье мы разобрали архитектуру Actor-Critic, где две нейросети работают в тандеме: одна выбирает действия, а другая оценивает их качество. Это был большой шаг вперед по сравнению с простым DQN или REINFORCE. Однако классический Actor-Critic (например, A2C) имеет свои недостатки: он может быть нестабильным, чувствительным к настройкам гиперпараметров и требовать огромного количества данных для обучения.

Сегодня мы познакомимся с «золотым стандартом» современного Deep RL. Если вы спросите инженера OpenAI или DeepMind: «С какого алгоритма мне начать?», вам почти наверняка ответят: PPO. А если вам нужно управлять роботом в реальном мире, где каждый шаг стоит дорого, вам посоветуют SAC.

Эти два алгоритма — Proximal Policy Optimization и Soft Actor-Critic — являются рабочими лошадками современной индустрии ИИ.

Проблема доверия: Почему обучение ломается?

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

* Если шаг слишком маленький: Обучение будет идти вечность. Агент будет топтаться на месте. Если шаг слишком большой: Мы рискуем «сломать» политику. Нейросеть может случайно прыгнуть в зону параметров, где стратегия ужасна. А так как данные для обучения мы собираем самой же этой стратегией*, агент начнет совершать глупые действия, получать плохие данные и деградировать еще сильнее. Это называется коллапсом производительности.

Представьте, что вы учитесь играть в гольф. Тренер говорит: «Чуть измени хват». Это маленький шаг. А если он скажет: «Полностью поменяй стойку, возьми клюшку другой рукой и закрой глаза» — это большой шаг. После такого вы, скорее всего, вообще перестанете попадать по мячу и не сможете понять, что именно пошло не так.

!Иллюстрация риска слишком большого шага обучения: агент может упасть с «обрыва» оптимальности.

Proximal Policy Optimization (PPO)

Алгоритм PPO, разработанный OpenAI в 2017 году, решает эту проблему элегантно и просто. Главная идея: «Давай обновлять политику, но не слишком сильно отличаться от предыдущей версии».

Как это работает: Clipping (Обрезание)

PPO использует механизм Trust Region (доверительный регион), но реализует его через простое математическое ограничение (clipping).

Мы смотрим на отношение вероятности действия в новой политике к вероятности в старой политике:

Где: * — отношение вероятностей (ratio). — вероятность действия согласно новой* (обновляемой) политике. — вероятность действия согласно старой* политике (которой мы собирали данные).

Если , значит, политики идентичны. Если , действие стало более вероятным. Если — менее вероятным.

PPO вводит специальную целевую функцию, которая игнорирует изменения, если уходит слишком далеко от единицы (например, становится больше 1.2 или меньше 0.8).

Формула целевой функции PPO (упрощенно):

Где: * — целевая функция, которую мы максимизируем. * — математическое ожидание (среднее по пакету данных). * — отношение новой и старой вероятностей. * — оценка преимущества (Advantage). Насколько действие было хорошим. * (эпсилон) — гиперпараметр, обычно равен 0.2. Он задает коридор допустимых изменений (от 0.8 до 1.2). * — функция обрезки, которая удерживает значение в диапазоне .

Суть: Если действие было хорошим (), мы хотим повысить его вероятность. Но функция clip не даст нам повысить её слишком сильно (больше чем на 20%). Это предохранитель, который гарантирует стабильность обучения.

Преимущества PPO:

Стабильность: Сложно «сломать» агента неудачным обновлением.

Простота: Легче реализовать, чем более сложные методы вроде TRPO.

Универсальность: Работает и для дискретных действий (Atari, Mario), и для непрерывных (роботы).

Именно PPO использовался для создания OpenAI Five (бота, победившего чемпионов в Dota 2).

Soft Actor-Critic (SAC)

Если PPO — это осторожный и стабильный ученик, то SAC — это любопытный исследователь, который хочет выжать максимум из каждого кусочка данных.

PPO является On-policy алгоритмом. Это значит, что данные, собранные старой версией нейросети, становятся бесполезными после обновления весов. Мы выбрасываем их и собираем новые. Это очень расточительно, если сбор данных стоит дорого (например, реальный робот изнашивается).

SAC (Soft Actor-Critic) — это Off-policy алгоритм. Он использует Replay Buffer (как в DQN), что позволяет учиться на старом опыте многократно. Но главная фишка SAC не в этом, а в энтропии.

Максимизация энтропии

Обычно в RL мы хотим максимизировать только сумму наград. SAC добавляет вторую цель: максимизировать энтропию политики.

> Энтропия в данном контексте — это мера случайности или непредсказуемости поведения агента.

Целевая функция SAC выглядит так:

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

Зачем агенту хотеть быть случайным?

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

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

!Слева — детерминированная политика, справа — политика с высокой энтропией, сохраняющая вариативность.

Представьте, что вы идете в ресторан. Обычный агент найдет одно вкусное блюдо и будет заказывать только* его всю жизнь. * Агент SAC будет заказывать любимое блюдо часто, но иногда будет пробовать и другие позиции меню, чтобы убедиться, что не упускает чего-то еще более вкусного, или просто чтобы иметь запасной вариант.

Преимущества SAC:

Эффективность данных (Sample Efficiency): Требует в разы меньше взаимодействий со средой, чем PPO, благодаря использованию буфера опыта.

Робастность: Меньше зависит от начальных условий и гиперпараметров.

Идеален для робототехники: Отлично работает с непрерывными действиями.

PPO или SAC: Что выбрать?

Выбор алгоритма зависит от вашей задачи.

| Характеристика | PPO (Proximal Policy Optimization) | SAC (Soft Actor-Critic) | | :--- | :--- | :--- | | Тип | On-Policy (нужны свежие данные) | Off-Policy (использует буфер опыта) | | Сложность реализации | Средняя | Высокая | | Скорость обучения (время) | Быстро считает, но нужно много данных | Долго считает, но нужно мало данных | | Пространство действий | Дискретное и Непрерывное | Преимущественно Непрерывное | | Главный плюс | Стабильность и простота | Эффективность использования данных |

Рекомендация: * Если вы делаете бота для компьютерной игры (Dota, StarCraft, Mario), где симуляция быстрая и дешевая — начинайте с PPO. * Если вы учите физического робота или сложный физический симулятор (MuJoCo, PyBullet), где каждый шаг занимает время — выбирайте SAC.

Заключение

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

Понимание этих алгоритмов открывает вам двери к решению самых сложных задач: от управления термоядерным синтезом (да, DeepMind делали и это с помощью RL) до создания NPC в играх нового поколения.

В следующих материалах мы углубимся в практическую реализацию этих методов и разберем библиотеки, которые позволяют запустить PPO и SAC в несколько строчек кода.

Практическая разработка: Создание игровых ботов с использованием OpenAI Gym и Unity ML-Agents

В предыдущих модулях мы прошли долгий путь от теоретических основ Марковских процессов до передовых алгоритмов PPO и SAC. Теперь у вас есть «мозг» (алгоритм), но ему нужно «тело» и «мир», в котором он будет жить. В этой статье мы переходим от формул к коду и инструментам.

Чтобы обучить ИИ, нам нужна среда (Environment) — симуляция, которая выдает состояния и награды, и принимает действия. Сегодня стандартом индустрии для создания таких сред являются две библиотеки: OpenAI Gym (ныне поддерживается как Gymnasium) и Unity ML-Agents.

OpenAI Gym: Стандартный интерфейс для RL

Когда исследователи из OpenAI начали заниматься обучением с подкреплением, они столкнулись с проблемой: каждый использовал свои собственные симуляторы с разными интерфейсами. Сравнить алгоритмы было невозможно. Чтобы решить это, они создали Gym — библиотеку, которая унифицировала взаимодействие между агентом и средой.

Философия цикла «Агент-Среда»

Gym работает по принципу классического цикла RL, который мы обсуждали в первой лекции. Вне зависимости от того, учите ли вы робота ходить или играете в Pac-Man, код взаимодействия выглядит практически одинаково.

!Схематическое изображение программного цикла взаимодействия агента и среды в библиотеке Gym

Основные методы Gym

Любая среда в Gym — это класс, который обязан иметь два главных метода:

reset(): Сбрасывает среду в начальное состояние (например, ставит фигурки на стартовые позиции) и возвращает первое наблюдение.

step(action): Совершает один шаг симуляции.

Рассмотрим математическую модель функции шага:

Где: * — действие, которое агент выбрал на текущем шаге. * — Observation (Наблюдение). Новое состояние среды после действия (пиксели экрана, координаты робота). * — Reward (Награда). Число, показывающее успешность действия (например, +1 или -10). * — Done (Флаг завершения). Булево значение (True/False). Если True, значит эпизод закончен (агент умер или победил), и нужно вызвать reset(). * — Info (Информация). Словарь с дополнительными данными для отладки (не используется для обучения).

Пример кода

Вот как выглядит простейший цикл запуска случайного агента в среде CartPole (балансировка шеста):

Пространства действий и наблюдений

Gym строго определяет, какие данные могут входить и выходить:

* Discrete Space: Набор конкретных кнопок (например, Discrete(3) означает действия 0, 1, 2). * Box Space: Непрерывный диапазон чисел (например, Box(low=-1.0, high=1.0, shape=(3,)) означает вектор из 3 чисел от -1 до 1). Это используется для управления физическими суставами или рулем автомобиля.

Unity ML-Agents: Когда нужна красивая физика

Gym отлично подходит для простых 2D-игр (Atari) или абстрактных задач. Но что, если вы хотите создать сложного бота для современного 3D-шутера, симулятор дрона в реалистичном городе или научить персонажа паркуру?

Здесь на сцену выходит Unity ML-Agents Toolkit. Это плагин для популярного игрового движка Unity, который превращает любую игру в тренировочную площадку для ИИ.

Архитектура ML-Agents

В отличие от Gym, который полностью работает в Python, ML-Agents имеет гибридную архитектуру. Обучение нейросети (PPO или SAC) происходит в Python (с использованием PyTorch), а сама симуляция физики и рендеринг происходят внутри Unity (C#).

!Архитектура взаимодействия между игровым движком Unity и обучающим скриптом на Python

Ключевые компоненты в Unity

Чтобы сделать игру обучаемой, вам нужно добавить к игровому объекту (например, танку) скрипт, наследуемый от класса Agent. В нем нужно переопределить три метода:

OnEpisodeBegin(): Аналог reset() в Gym. Здесь мы расставляем врагов и сбрасываем здоровье.

CollectObservations(VectorSensor sensor): Здесь мы «скармливаем» нейросети данные. Мы можем передать позицию врага, свое здоровье, скорость или даже картинку с камеры.

OnActionReceived(ActionBuffers actions): Аналог step(). Здесь мы превращаем числа от нейросети в движение персонажа (например, transform.Translate).

Преимущества Unity ML-Agents

Визуальная сложность: Вы можете обучать агентов, используя фотореалистичную графику.

Сложная физика: Unity использует движок PhysX, что позволяет симулировать столкновения, гравитацию и трение.

Curriculum Learning (Обучение по расписанию): Вы можете усложнять задачу по мере обучения агента (сначала стена низкая, потом высокая).

Self-Play (Игра против самого себя): Встроенная поддержка обучения соревновательных агентов (как в AlphaGo).

Сравнение инструментов

Какой инструмент выбрать для вашего проекта?

| Характеристика | OpenAI Gym (Gymnasium) | Unity ML-Agents | | :--- | :--- | :--- | | Сложность старта | Низкая (просто установи pip install) | Средняя (нужно знать движок Unity) | | Графика | Примитивная (2D или простая 3D) | Современная (AAA-уровень) | | Скорость симуляции | Очень высокая | Зависит от сложности сцены | | Основное применение | Исследование алгоритмов, простые игры | Робототехника, сложные игровые боты, VR | | Языки | Python | C# (среда) + Python (обучение) |

Создание собственной среды (Custom Environment)

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

Вам нужно будет определить:

* self.action_space: Какие рычаги есть у агента? * self.observation_space: Что видит агент? * Логику метода step(), который будет рассчитывать физику вашего мира и выдавать награду.

Главное правило при дизайне награды: она должна быть плотной и информативной. Если агент получает +1 только в самом конце игры (как в шахматах), ему будет очень сложно учиться. Лучше давать небольшие награды за промежуточные успехи (съел пешку, занял центр).

Заключение

Мы рассмотрели инструменты, которые связывают абстрактную математику RL с конкретными задачами. OpenAI Gym — это идеальная «песочница» для экспериментов и изучения алгоритмов. Unity ML-Agents — это мощный «полигон» для создания сложных, визуально богатых миров.

В следующем модуле мы объединим знания: возьмем алгоритм PPO, среду Gym и напишем полноценный код для обучения агента, который научится проходить игру Lunar Lander.