Self-Play и порождение знаний без внешних данных (на примере AlphaZero)

Материал из MachineLearning.

Статья написана с использованием LLM ChatGPT (GPT-5.6 Sol Medium) и проверена участником Valeriia Berdnikova 16:09, 19 июля 2026 (MSD). Промпт приводится полностью в Обсуждение:Self-Play и порождение знаний без внешних данных (на примере AlphaZero).

Содержание

1 Основная идея self-play
2 История развития
- 2.1 Ранние игровые программы
- 2.2 Развитие поиска по дереву Монте-Карло
- 2.3 AlphaGo
- 2.4 AlphaGo Zero
- 2.5 AlphaZero
3 Математические основы
- 3.1 Марковский процесс принятия решений
- 3.2 Марковские игры
- 3.3 Политика
- 3.4 Функция ценности
- 3.5 Исследование и использование
4 Порождение обучающих данных
5 Архитектура AlphaZero
- 5.1 Представление состояния
- 5.2 Остаточная нейронная сеть
- 5.3 Policy head
- 5.4 Value head
6 Поиск по дереву Монте-Карло
- 6.1 Структура дерева
- 6.2 Выбор узла
- 6.3 Расширение
- 6.4 Оценка состояния
- 6.5 Обратное распространение
- 6.6 Целевая политика
- 6.7 Число симуляций
7 Функция потерь AlphaZero
8 Общий алгоритм self-play
9 Псевдокод AlphaZero
10 Почему self-play порождает новые знания
- 10.1 Замкнутый цикл улучшения
- 10.2 Открытие стратегий
- 10.3 Самогенерируемые цели
11 Различия между AlphaGo, AlphaGo Zero и AlphaZero
12 Преимущества
- 12.1 Отсутствие человеческой разметки
- 12.2 Автоматическое повышение сложности
- 12.3 Возможность новых стратегий
- 12.4 Масштабирование вычислений
- 12.5 Минимальная предметная эвристика
13 Ограничения
- 13.1 Вычислительная стоимость
- 13.2 Зависимость от симулятора
- 13.3 Зависимость от функции награды
- 13.4 Накопление собственных ошибок
- 13.5 Ограниченная интерпретируемость
- 13.6 Ограничения переноса
14 Современные варианты self-play
- 14.1 Обучение с архивом соперников
- 14.2 Fictitious self-play
- 14.3 Лиги агентов
- 14.4 Асимметричный self-play
- 14.5 Самогенерируемые модели мира
15 Применения
- 15.1 Игровые системы
- 15.2 Многоагентное обучение
- 15.3 Робототехника
- 15.4 Автономные системы
- 15.5 Автоматические учебные программы
- 15.6 Научные и алгоритмические задачи
16 Сравнение с другими подходами
- 16.1 Обучение с учителем
- 16.2 Классическое обучение с подкреплением
- 16.3 Имитационное обучение
- 16.4 Генетические алгоритмы
- 16.5 Эволюционные стратегии
- 16.6 Самоконтролируемое обучение
- 16.7 Генеративные модели
17 Практическая применимость
18 См. также
19 Примечания
20 Литература

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

Наиболее известным примером является AlphaZero — алгоритм компании DeepMind, объединивший глубокую нейронную сеть, поиск по дереву Монте-Карло и self-play. AlphaZero обучался игре в го, шахматы и сёги без использования человеческих партий, экспертных оценок позиций и подготовленных дебютных баз.^[1]

Выражение «порождение знаний без внешних данных» не означает обучение без исходной информации вообще. Алгоритму заранее задаются:

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

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

Основная идея self-play

Пусть два агента обладают политиками $\pi_1$ и $\pi_2$ . Они взаимодействуют в одной среде, последовательно выбирая действия и получая итоговое вознаграждение. После завершения эпизода накопленная траектория используется для обновления одной или обеих политик.

Траектория имеет вид

$\tau=(s_0,a_0,r_1,s_1,a_1,r_2,\ldots,s_T),$

где $s_t$ — состояние среды, $a_t$ — выбранное действие, $r_{t+1}$ — полученное вознаграждение.

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

$a_t\sim\pi_\theta(a\mid s_t).$

После партии параметры $\theta$ изменяются так, чтобы повысить вероятность действий, приводящих к хорошему результату, и снизить вероятность неудачных действий.

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

История развития

Ранние игровые программы

Идеи обучения на партиях против самого себя применялись ещё в ранних исследованиях машинного обучения. В программе Артура Самуэля для игры в шашки оценочная функция улучшалась на основе результатов автоматически сыгранных партий.^[1]

В 1990-х годах программа TD-Gammon Джеральда Тезауро достигла высокого уровня игры в нарды, обучаясь преимущественно по партиям с самой собой методом временных различий.^[1]

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

Развитие поиска по дереву Монте-Карло

В 2000-х годах появились методы поиска по дереву Монте-Карло — Monte Carlo Tree Search, MCTS. Алгоритм UCT объединил поиск в дереве с принципом верхних доверительных границ для решения проблемы исследования и использования.^[1]

MCTS оказался особенно эффективным в играх с большим пространством состояний, где полный перебор дерева невозможен.

AlphaGo

AlphaGo объединил глубокие нейронные сети, обучение с подкреплением и MCTS. Сначала policy-сеть обучалась на партиях сильных игроков в го, затем улучшалась через self-play. Отдельная value-сеть оценивала позиции, а дополнительные rollout-политики использовались для быстрых симуляций.^[1]

Таким образом, AlphaGo не обучался полностью без человеческих партий.

AlphaGo Zero

AlphaGo Zero отказался от человеческих игровых данных. Одна остаточная нейронная сеть одновременно предсказывала политику и ценность позиции. Партии генерировались исключительно посредством self-play, а MCTS использовал выходы этой сети вместо отдельных rollout-моделей.^[1]

AlphaZero

AlphaZero обобщил схему AlphaGo Zero на несколько игр: го, шахматы и сёги. Основной алгоритм поиска и обучения оставался одинаковым, хотя представления состояний, множества допустимых действий и правила переходов зависели от конкретной игры.^[1]

AlphaZero не использовал:

человеческие партии;
экспертные оценки позиций;
дебютные книги;
эндшпильные таблицы;
специализированные игровые эвристики оценки.

При этом алгоритму были известны правила каждой игры и условие победы.

Математические основы

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

Стандартное обучение с подкреплением формулируется через Марковский процесс принятия решений:

${\cal M}=({\cal S},{\cal A},P,R,\gamma),$

где

${\cal S}$ — множество состояний;
${\cal A}$ — множество действий;
$P(s'\mid s,a)$ — вероятность перехода в состояние $s'$ ;
$R(s,a,s')$ — функция вознаграждения;
$\gamma\in[0,1]$ — коэффициент дисконтирования.

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

Возврат из момента времени $t$ определяется как

$G_t=\sum_{k=0}^{T-t-1}\gamma^k r_{t+k+1}.$

Цель агента состоит в максимизации математического ожидания возврата:

$J(\pi)={\bf E}_{\pi}[G_0].$

Марковские игры

Self-play с несколькими участниками естественнее описывать как марковскую игру. Для двух агентов переход зависит от совместного действия:

$P(s'\mid s,a^1,a^2).$

В двухсторонней игре с нулевой суммой вознаграждения удовлетворяют условию

$r^1=-r^2.$

AlphaZero рассматривает детерминированные игры с полной информацией и нулевой суммой. Непосредственное применение его математической схемы к частично наблюдаемым, стохастическим или кооперативным средам требует изменений.

Политика

Политика задаёт распределение вероятностей действий в состоянии:

$\pi(a\mid s)=P(a_t=a\mid s_t=s).$

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

$a=\pi(s).$

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

Функция ценности

Функция ценности состояния для политики $\pi$ равна ожидаемому возврату:

$V^\pi(s)={\bf E}_{\pi}[G_t\mid s_t=s].$

Функция ценности действия определяется как

$Q^\pi(s,a)={\bf E}_{\pi}[G_t\mid s_t=s,a_t=a].$

В конечной игре с исходами «победа», «ничья» и «поражение» ценность может принимать значения в диапазоне $[-1,1]$ .

Для AlphaZero целевой результат партии обычно обозначается через

$z\in\{-1,0,1\}.$

Знак результата определяется с точки зрения игрока, которому принадлежит ход в соответствующем обучающем состоянии.

Исследование и использование

Агент должен выбирать между:

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

Недостаточное исследование приводит к преждевременному закреплению слабой стратегии. Чрезмерное исследование увеличивает стоимость обучения и снижает качество текущей игры.

В AlphaZero баланс обеспечивают:

формула PUCT в дереве поиска;
случайный выбор ходов на основе числа посещений;
параметр температуры;
шум Дирихле в корневом узле во время генерации партий.

Порождение обучающих данных

В self-play обучающая выборка не фиксируется заранее. На каждом цикле агент создаёт новые траектории, играя с текущей или предыдущей версией политики.

Для партии AlphaZero формируется набор

${\cal D}_{\rm game}=\{(s_t,\pi_t,z_t)\}_{t=0}^{T-1},$

где

$s_t$ — состояние игры;
$\pi_t$ — улучшенная политика, полученная MCTS;
$z_t$ — итог партии с точки зрения текущего игрока.

Обучающая политика $\pi_t$ определяется не непосредственно выходом нейронной сети, а распределением посещений действий в дереве поиска.

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

$\pi_{k+1}\simeq{\rm MCTS}(f_{\theta_k}),$

$\theta_{k+1}=\mathop{\rm argmin}_{\theta}{\bf E}_{(s,\pi,z)\sim{\cal D}}l(\theta;s,\pi,z).$

Знание в данном случае существует не в виде явно записанных правил. Оно распределено между:

параметрами нейронной сети;
политикой выбора действий;
оценками ценности;
статистиками дерева поиска;
структурой самогенерируемых партий.

Архитектура AlphaZero

Представление состояния

Состояние игры преобразуется в набор входных плоскостей или тензор признаков:

$x(s)\in{\bf R}^{h\times w\times c},$

где $h$ и $w$ описывают игровое поле, а $c$ — каналы признаков.

Каналы могут кодировать:

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

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

Остаточная нейронная сеть

Основу модели составляет глубокая остаточная сеть с общим представлением и двумя выходными головами:

$(p,v)=f_\theta(s).$

Здесь

$p$ — вектор вероятностей допустимых действий;
$v$ — скалярная оценка ожидаемого результата позиции;
$\theta$ — параметры сети.

Общая часть сети выполняет извлечение представления состояния, после чего вычисления разделяются на policy head и value head.

Policy head

Policy head выдаёт априорное распределение действий:

$p_\theta(a\mid s).$

Эти вероятности направляют исследование дерева. Действия с высоким prior получают больше симуляций, но PUCT позволяет исследовать и менее вероятные варианты.

Выход policy head не является окончательным решением агента: он уточняется MCTS.

Value head

Value head оценивает позицию:

$v_\theta(s)\simeq{\bf E}[z\mid s].$

Значение $v_\theta(s)$ заменяет большое количество случайных доигрываний, использовавшихся в ранних вариантах MCTS.

Оценка ограничена качеством сети. Если сеть систематически ошибается, поиск может концентрироваться на неверных ветвях.

Поиск по дереву Монте-Карло

Структура дерева

Узлы MCTS соответствуют состояниям, а рёбра — действиям. Для пары $(s,a)$ хранятся статистики:

$N(s,a)$ — число посещений;
$W(s,a)$ — накопленная ценность;
$Q(s,a)$ — средняя ценность;
$P(s,a)$ — prior, предсказанный нейронной сетью.

Средняя ценность равна

$Q(s,a)=\frac{W(s,a)}{N(s,a)}$

при $N(s,a)>0$ .

Каждая симуляция включает четыре этапа:

выбор;
расширение;
оценку;
обратное распространение.

Выбор узла

Классический UCT выбирает действие по правилу

$a^*=\mathop{\rm argmax}_a\left(\bar X(s,a)+c\sqrt{\frac{\ln N(s)}{N(s,a)}}\right),$

где $\bar X(s,a)$ — средний результат действия, а второй член поощряет исследование редко посещавшихся ветвей.

В AlphaZero используется вариант PUCT:

$a^*=\mathop{\rm argmax}_a\left(Q(s,a)+U(s,a)\right),$

$U(s,a)=c_{\rm puct}P(s,a)\frac{\sqrt{\sum_b N(s,b)}}{1+N(s,a)}.$

Действие получает высокий приоритет, если оно:

имеет высокую оценку $Q(s,a)$ ;
рекомендовано policy head;
исследовалось относительно редко.

Расширение

Когда поиск достигает ранее не раскрытого состояния $s_L$ , нейронная сеть вычисляет

$(p,v)=f_\theta(s_L).$

Для допустимых действий создаются новые рёбра с начальными prior-вероятностями $P(s_L,a)$ . Недопустимые действия маскируются, после чего распределение нормируется.

Оценка состояния

Если состояние не терминальное, его ценность оценивается value head:

$v=v_\theta(s_L).$

Для терминального состояния используется фактический исход игры.

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

Обратное распространение

Полученная оценка передаётся по пути от листа к корню:

$N(s,a)\leftarrow N(s,a)+1,$

$W(s,a)\leftarrow W(s,a)+v,$

$Q(s,a)\leftarrow\frac{W(s,a)}{N(s,a)}.$

В игре с двумя соперниками знак ценности меняется при переходе между точками зрения игроков.

Целевая политика

После заданного числа симуляций MCTS целевая политика строится по числу посещений:

$\pi(a\mid s)=\frac{N(s,a)^{1/\tau}}{\sum_b N(s,b)^{1/\tau}},$

где $\tau$ — температура.

При высокой температуре распределение более равномерно. При $\tau\to0$ выбирается действие с наибольшим числом посещений.

Число симуляций

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

Качество поиска зависит не только от их количества, но и от:

точности policy head;
точности value head;
коэффициента $c_{\rm puct}$ ;
ветвления игры;
глубины тактических последовательностей;
вычислительного бюджета.

MCTS не гарантирует нахождение оптимального хода при конечном числе симуляций.

Функция потерь AlphaZero

Для обучающего примера $(s,\pi,z)$ нейронная сеть выдаёт $(p,v)$ . Функция потерь имеет вид

$l(\theta)=(z-v)^2-\sum_a\pi(a\mid s)\ln p(a\mid s)+c\|\theta\|_2^2.$

Она включает три компонента:

ошибку value head;
перекрёстную энтропию между политикой MCTS и policy head;
регуляризацию параметров.

Первый член обучает прогнозировать результат партии:

$l_v=(z-v)^2.$

Второй член обучает сеть имитировать улучшенную поиском политику:

$l_p=-\sum_a\pi(a\mid s)\ln p(a\mid s).$

Параметры обновляются методом стохастического градиентного спуска или его вариантом:

$\theta\leftarrow\theta-\eta\nabla_\theta l(\theta).$

Здесь учитель для policy head создаётся MCTS, а учитель для value head — итогом собственной партии.

Общий алгоритм self-play

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

1. Инициализировать параметры theta.
2. Создать множество возможных соперников.
3. Для каждой итерации:
   3.1. Выбрать соперника:
        текущую политику, её предыдущую версию
        или агента из популяции.
   3.2. Сыграть один или несколько эпизодов.
   3.3. Сохранить состояния, действия,
        вероятности и вознаграждения.
   3.4. Вычислить целевые возвраты
        или преимущества действий.
   3.5. Обновить параметры политики.
   3.6. При необходимости добавить новую
        политику в множество соперников.
4. Вернуть итоговую политику.

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

Псевдокод AlphaZero

Вход: правила игры, сеть f_theta,
      число симуляций MCTS, буфер данных D.
Выход: параметры theta.

1. Случайно инициализировать theta.
2. Пока критерий остановки не выполнен:
   2.1. Для каждой self-play партии:
        2.1.1. Инициализировать начальное состояние s_0.
        2.1.2. Пока партия не завершена:
               а) выполнить MCTS из состояния s_t,
                  используя f_theta;
               б) получить распределение pi_t
                  по числу посещений;
               в) выбрать действие a_t по pi_t;
               г) сохранить пару (s_t, pi_t);
               д) применить действие и получить s_{t+1}.
        2.1.3. Определить итог партии z.
        2.1.4. Для каждого сохранённого состояния
               добавить (s_t, pi_t, z_t) в D.
   2.2. Выбрать мини-пакет из D.
   2.3. Для каждого (s, pi, z):
        2.3.1. Вычислить (p, v) = f_theta(s).
        2.3.2. Вычислить функцию потерь.
   2.4. Обновить theta градиентным методом.
3. Вернуть f_theta.

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

Почему self-play порождает новые знания

Замкнутый цикл улучшения

AlphaZero реализует повторяющийся цикл:

нейронная сеть направляет поиск;
поиск строит более сильную политику;
новая политика создаёт более качественные партии;
партии используются для обновления сети;
улучшенная сеть усиливает следующий поиск.

При успешном обучении MCTS выполняет приближённое улучшение политики, а value head — приближённую оценку политики.

Открытие стратегий

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

Самогенерируемые цели

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

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

Различия между AlphaGo, AlphaGo Zero и AlphaZero

Система	Источник данных	Архитектура	Поиск	Область применения
AlphaGo	Человеческие партии и self-play	Отдельные policy- и value-сети, rollout-политика	MCTS с нейронными оценками и rollout	Го
AlphaGo Zero	Только self-play	Одна остаточная сеть с policy head и value head	MCTS без случайных rollout-партий	Го
AlphaZero	Только self-play	Общая схема сети с двумя головами	PUCT-MCTS	Го, шахматы и сёги

AlphaZero является алгоритмом, а self-play — более общим принципом генерации опыта. Не всякий self-play использует MCTS, глубокие сети или архитектуру AlphaZero.

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

Отсутствие человеческой разметки

Для игровых задач не требуется собирать и очищать экспертные партии. Итог партии автоматически создаёт сигнал обучения.

Это преимущество особенно важно, когда:

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

Автоматическое повышение сложности

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

Возможность новых стратегий

Отсутствие привязки к человеческим решениям позволяет исследовать нестандартные области пространства политик.

Масштабирование вычислений

Self-play партии можно генерировать параллельно на большом числе вычислительных устройств. MCTS также допускает несколько форм параллельного выполнения.

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

Минимальная предметная эвристика

AlphaZero использует единый принцип обучения в нескольких играх. Это снижает потребность в создании вручную сложных оценочных функций.

Полной предметной независимости при этом нет: правила, кодирование состояний и допустимые действия остаются специфичными для среды.

Ограничения

Вычислительная стоимость

Каждый ход требует многократных вызовов нейронной сети внутри MCTS. Для генерации одной партии выполняются тысячи или миллионы операций оценки.

Основные затраты связаны с:

self-play партиями;
симуляциями MCTS;
хранением буфера опыта;
обучением глубокой сети;
оценкой новых версий;
подбором гиперпараметров.

Зависимость от симулятора

Self-play особенно эффективен, когда среда:

быстро моделируется;
имеет точные правила;
допускает сброс состояния;
предоставляет однозначный результат.

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

Зависимость от функции награды

Агент оптимизирует заданное вознаграждение, а не неформальное намерение разработчика. Ошибочно спроектированная награда может привести к нежелательному поведению.

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

Накопление собственных ошибок

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

Возможны:

закрепление ошибочных оценок;
потеря разнообразия;
циклическое превосходство политик;
забывание старых стратегий;
переобучение на текущего соперника.

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

Ограниченная интерпретируемость

Нейронная сеть хранит стратегические знания в распределённом виде. Даже если отдельный ход можно объяснить с помощью дерева поиска, причины оценок policy head и value head часто остаются неочевидными.

Ограничения переноса

Успех AlphaZero опирается на свойства настольных игр:

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

Реальные среды часто не удовлетворяют этим условиям.

Современные варианты self-play

Обучение с архивом соперников

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

Fictitious self-play

Fictitious self-play приближает классическую фиктивную игру: агент обучает лучший ответ не на одного соперника, а на смесь его предыдущих политик.^[1]

Подход применим к играм с неполной информацией, где простое копирование текущей политики может быть нестабильным.

Лиги агентов

В league training одновременно существует популяция основных агентов, специализированных соперников и исторических контрольных точек. Подобный подход использовался в AlphaStar для StarCraft II.^[1]

Асимметричный self-play

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

Самогенерируемые модели мира

MuZero сохранил принцип self-play и поиска, но вместо известной модели переходов обучал внутреннее представление динамики, вознаграждения и ценности.^[1]

MuZero не требует, чтобы поиск напрямую использовал известные правила перехода, но всё ещё получает наблюдения и вознаграждения от среды.

Применения

Игровые системы

Self-play применяется в:

го;
шахматах;
сёги;
нардах;
покере;
стратегиях реального времени;
многопользовательских компьютерных играх.

OpenAI Five использовал масштабное обучение с подкреплением и self-play для Dota 2.^[1]

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

Многоагентное обучение

В многоагентном обучении агенты могут соревноваться, сотрудничать или одновременно выполнять обе роли.

Self-play используется для:

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

Робототехника

В робототехнике self-play может использоваться для обучения:

манипуляции объектами;
противодействия другому роботу;
навигации;
захвата и уклонения;
координации нескольких устройств.

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

Автономные системы

Self-play и соревновательное обучение применимы к моделированию:

транспортных конфликтов;
распределения ресурсов;
киберзащиты;
управления трафиком;
противодействия атакующему агенту.

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

Автоматические учебные программы

Конкурирующие агенты способны создавать друг для друга постепенно усложняющиеся задачи. В исследованиях многоагентных автокуррикулумов наблюдалось возникновение новых способов использования объектов среды.^[1]

Научные и алгоритмические задачи

Идея самогенерируемого опыта используется в поиске математических и алгоритмических конструкций. Например, AlphaTensor применяет обучение с подкреплением и поиск для обнаружения алгоритмов умножения матриц.^[1]

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

Сравнение с другими подходами

Обучение с учителем

В обучении с учителем используется фиксированная выборка

${\cal D}=\{(x_i,y_i)\}_{i=1}^{n},$

где $y_i$ задаётся внешним источником.

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

В self-play целевые значения изменяются вместе с агентом.

Классическое обучение с подкреплением

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

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

Self-play является способом организации среды и генерации опыта внутри обучения с подкреплением, а не его заменой.

Имитационное обучение

Имитационное обучение восстанавливает поведение по демонстрациям эксперта.

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

AlphaGo использовал экспертные партии, а AlphaGo Zero и AlphaZero — нет.

Генетические алгоритмы

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

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

Self-play определяет способ взаимодействия, тогда как генетический алгоритм определяет способ изменения популяции. Эти идеи могут объединяться.

Эволюционные стратегии

Эволюционные стратегии оптимизируют параметры политики через случайные возмущения и сравнение результатов.

Данные: итоговые значения приспособленности.
Стоимость: обычно высокая по числу симуляций.
Масштабируемость: высокая параллелизуемость.
Преимущество: простота распределённого выполнения.
Ограничение: игнорирование детальной структуры траекторий.

AlphaZero использует градиентное обучение нейронной сети, а не эволюцию её параметров.

Самоконтролируемое обучение

Самоконтролируемое обучение создаёт целевые значения из структуры неразмеченных данных.

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

Self-play создаёт новые наблюдения посредством действий в среде, а не только преобразует уже имеющиеся данные.

Генеративные модели

Генеративные модели обучаются приближать распределение данных или создавать новые примеры.

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

Self-play может использовать генеративную модель среды, но не является генеративным моделированием сам по себе.

Практическая применимость

Self-play наиболее оправдан, если:

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

Метод менее оправдан, если:

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

См. также

Примечания

Литература

Sutton R. S., Barto A. G. Reinforcement Learning: An Introduction. — Second Edition. — MIT Press, 2018.
Puterman M. L. Markov Decision Processes: Discrete Stochastic Dynamic Programming. — John Wiley & Sons, 1994.
Shapley L. S. Stochastic Games // Proceedings of the National Academy of Sciences. — 1953. — Т. 39. — № 10. — С. 1095—1100.
Samuel A. L. Some Studies in Machine Learning Using the Game of Checkers // IBM Journal of Research and Development. — 1959. — Т. 3. — № 3. — С. 210—229.
Tesauro G. Temporal Difference Learning and TD-Gammon // Communications of the ACM. — 1995. — Т. 38. — № 3. — С. 58—68.
Kocsis L., Szepesvári C. Bandit Based Monte-Carlo Planning // Machine Learning: ECML 2006. — 2006. — Т. 4212. — С. 282—293.
Coulom R. Efficient Selectivity and Backup Operators in Monte-Carlo Tree Search // Computers and Games. — 2007. — Т. 4630. — С. 72—83.
Silver D. et al. Mastering the Game of Go with Deep Neural Networks and Tree Search // Nature. — 2016. — Т. 529. — С. 484—489.
Silver D. et al. Mastering the Game of Go without Human Knowledge // Nature. — 2017. — Т. 550. — С. 354—359.
Silver D. et al. A General Reinforcement Learning Algorithm that Masters Chess, Shogi, and Go through Self-Play // Science. — 2018. — Т. 362. — № 6419. — С. 1140—1144.
Heinrich J., Lanctot M., Silver D. Fictitious Self-Play in Extensive-Form Games // Proceedings of the 32nd International Conference on Machine Learning. — 2015. — Т. 37. — С. 805—813.
Vinyals O. et al. Grandmaster Level in StarCraft II Using Multi-Agent Reinforcement Learning // Nature. — 2019. — Т. 575. — С. 350—354.
Berner C. et al. Dota 2 with Large Scale Deep Reinforcement Learning // arXiv preprint arXiv:1912.06680. — 2019.
Baker B. et al. Emergent Tool Use from Multi-Agent Autocurricula // International Conference on Learning Representations. — 2020.
Schrittwieser J. et al. Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model // Nature. — 2020. — Т. 588. — С. 604—609.
Fawzi A. et al. Discovering Faster Matrix Multiplication Algorithms with Reinforcement Learning // Nature. — 2022. — Т. 610. — С. 47—53.

Источник — «http://machinelearning.ru/wiki/index.php?title=Self-Play_%D0%B8_%D0%BF%D0%BE%D1%80%D0%BE%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B7%D0%BD%D0%B0%D0%BD%D0%B8%D0%B9_%D0%B1%D0%B5%D0%B7_%D0%B2%D0%BD%D0%B5%D1%88%D0%BD%D0%B8%D1%85_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85_%28%D0%BD%D0%B0_%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%D0%B5_AlphaZero%29»