Все алгоритмы, о которых мы говорили — регрессии, бустинг, CNN, диффузия — учатся на статичных данных. Датасет лежит в файле, модель читает примеры, корректирует веса. Но есть целый класс задач, где так учиться нельзя: там нужно действовать и учиться на последствиях.
Шахматы. Вождение автомобиля. Торговля на бирже. Вы не можете дать модели «датасет правильных ходов» — правильность хода зависит от позиции, а позиция зависит от ваших предыдущих ходов. Нужно разыгрывать партии, видеть, чем они заканчиваются, и понемногу понимать, какие действия ведут к победе. Это и есть обучение с подкреплением (RL) — последняя большая парадигма машинного обучения.
Эта статья закрывает серию «Основы машинного обучения». И — как и в диффузии — здесь нас ждёт знакомый паттерн: итеративное улучшение через обратную связь. Только если диффузия убирала шум шаг за шагом, то RL корректирует поведение шаг за шагом.
1. Постановка задачи: агент в среде
Формулировка RL строится вокруг пяти понятий. Представьте робота-пылесоса в комнате.
- Среда — всё, с чем взаимодействует агент. Комната с мебелью, мусором, кошкой.
- Состояние (state,
S) — что агент «видит» прямо сейчас. Положение пылесоса, наличие мусора в секторе. - Действие (action,
A) — что агент может сделать. Повернуть налево, проехать вперёд, начать уборку. - Награда (reward,
R) — обратная связь от среды. +1 за собранный мусор, −0.1 за потраченное время, −10 за наезд на кошку. - Политика (policy,
π) — правило, по которому агент выбирает действие в состоянии. Это то, что мы учим.
Жизнь агента — это цикл: увидеть состояние S_t → выбрать действие A_t по политике π → среда отвечает наградой R_{t+1} и новым состоянием S_{t+1} → повторить.
действие A_t
агент ───────────────────────► среда
▲ │
│ награда R_{t+1}, новое S_{t+1} │
└───────────────────────────────┘
Цель — найти политику π, которая максимизирует суммарную ожидаемую награду за долгое время. Не «получить +1 сейчас», а «действовать так, чтобы через тысячи шагов сумма наград была максимальной». Это отличие от обучения с учителем, где каждый пример снабжён правильным ответом: в RL правильного ответа нет, есть только последствия, и часто отсроченные.
2. Главная метафора: ребёнок учится ходить
Представьте годовалого ребёнка, который учится ходить. Никто не даёт ему «датасет правильных шагов». Он стоит, делает шаг, падает (маленькая «награда» за неудачу), поднимается, делает другой шаг, доходит до дивана, получает восторг родителей (большая награда). Через сотни попыток он корректирует свои движения — и через неделю ходит.
Именно так работает RL. Агент не знает «правильного» действия заранее. Он пробует, получает сигнал (награду/штраф), обновляет свои оценки ценности действий в каждом состоянии, и в следующий раз с большей вероятностью выбирает то, что раньше принесло награду. Это обучение через собственный опыт, а не через чужие примеры.
В этом — и сила, и слабость RL. Сила: агент может научиться тому, чего никто не умеет объяснить (как играть в Go лучше людей). Слабость: нужно очень много попыток, что в реальном мире дорого. Поэтому RL чаще всего обучают в симуляторе: игра, физический движок, модель рынка — там можно разыграть миллионы партий за часы.
3. Q-обучение: оценка ценности действий
Самый старый и понятимый алгоритм RL — Q-обучение. Идея: для каждой пары (состояние, действие) завести оценку Q(s, a) — «какую суммарную награду я получу, если буду в состоянии s сделаю действие a, а потом буду действовать оптимально».
Если Q-таблица заполнена, действовать просто: в состоянии s выбери действие a с максимальным Q(s, a). Политика = «жадная» по Q.
Но как заполнить таблицу, если в начале мы ничего не знаем? Через итеративное обновление по уравнению Беллмана. После каждого шага (сделал a в s, получил r, перешёл в s') обновляем:
Q(s, a) ← Q(s, a) + α · [r + γ·max_a' Q(s', a') − Q(s, a)]
└── целевое значение ──┘
Здесь α — learning rate, γ (discount factor) — насколько мы ценим будущие награды по сравнению с текущими. Магия в скобках: мы берём текущую оценку Q(s,a), сравниваем с новым пониманием (r сейчас + лучшее, что бывает из s'), и сдвигаем оценку в сторону нового понимания. Это снова итеративное улучшение — тот же принцип, что в градиентном спуске и бустинге, только в пространстве «ценностей действий».
Проблема exploration vs exploitation. Если всегда выбирать лучшее по Q, агент никогда не узнает, нет ли чего-то получше. Поэтому в Q-обучании используют ε-greedy: с вероятностью ε делаем случайное действие (исследуем), иначе — лучшее по Q (используем). Со временем ε уменьшается: сначала много изучаем, потом эксплуатируем накопленное.
Q-обучение прекрасно работает на маленьких пространствах: лабиринт, крестики-нолики, простой робот. Но что если состояний — как в шахматах (~10^40) или Atari-играх (пиксели экрана)? Таблицу такого размера не составить.
4. Deep Q-Network: Q как нейросеть
Решение пришло из глубокого обучения: заменить таблицу Q нейросетью. Вместо того чтобы хранить Q(s, a) для всех пар, сеть Q_θ(s, a) (с весами θ) аппроксимирует ценность. На входе — состояние (например, пиксели экрана игры), на выходе — оценки Q для каждого возможного действия.
В 2015 году DeepMind опубликовал DQN, который научился играть в 49 Atari-игр на уровне человека, используя одну и ту же архитектуру. На вход — 4 последовательных кадра экрана, на выходе — Q для 18 действий джойстика. Сеть училась через игру с самой собой в симуляторе — миллионы эпизодов.
Чтобы обучение стабилизировать, придумали два трюка. Replay buffer: храним все (s, a, r, s’) переходы в большом буфере и обучаемся на случайных батчах из него. Это разрушает корреляции между последовательными шагами и делает обучение похожим на классическое ML. Target network: отдельная «замороженная» копия сети для вычисления целевых значений, обновляемая раз в N шагов. Без этого сеть «гоняется за движущейся мишенью» — оценивает сама себя — и обучение разваливается.
DQN стал прорывом, но у него было ограничение: он работает только с дискретными действиями (конечный набор, как кнопки джойстика). Для непрерывных действий (угол поворота руля, сила нажатия педали) нужны были другие алгоритмы.
5. Policy Gradient и PPO: учить политику напрямую
Вместо того чтобы оценивать Q и из неё выводить политику, можно учить политику напрямую. Алгоритмы этого семейства (policy gradient methods) параметризуют политику π_θ(a|s) — обычно нейросетью, которая по состоянию s выдаёт распределение вероятностей действий — и корректируют θ так, чтобы увеличить вероятность действий, приведших к высокой награде.
Самый популярный алгоритм этого семейства сегодня — PPO (Proximal Policy Optimization, OpenAI 2017). Его ключевая идея: при обновлении политики ограничивать размер шага. Если новая политика слишком отличается от старой, мы «обрезаем» обновление. Это не даёт одному плохому эпизоду разрушить то, что сеть выучила за тысячи шагов.
новая_политика / старая_политика ∈ [1−ε, 1+ε] ← clip, не улетать далеко
Почему PPO стал стандартом? Он стабилен (старая проблема policy gradient — взрывные обновления), прост в реализации и эффективен. PPO — тот алгоритм, на котором обучают роботов OpenAI (рука, решающая кубик Рубика), и — что для нас важнее — именно PPO лежит в основе RLHF, о котором ниже.
6. AlphaGo: когда RL встречает поиск
В марте 2016 года AlphaGo победил Ли Седоля, чемпиона мира по Go, со счётом 4:1. Это событие многие считают моментом, когда AI перестал быть «лабораторией» и стал «индустрией». Go казался непреодолимым: слишком большое пространство поиска (~10^170 позиций — больше, чем атомов в наблюдаемой вселенной), никакой классический перебор не справлялся.
AlphaGo соединил три техники.
Глубокие нейросети. Две сети: «policy network» предсказывает, какой ход сыграет сильный игрок (сужает выбор кандидатов), «value network» оценивает позицию — кто выигрывает (позволяет не разыгрывать до конца).
Поиск по дереву Монте-Карло (MCTS). Вместо того чтобы перебирать все возможные continuations, AlphaGo разыгрывает тысячи случайных партий из текущей позиции и смотрит, какие ходы чаще ведут к победе. MCTS — это планирование через симуляцию: не нужно знать наперёд, нужно уметь оценить правдоподобные сценарии.
Обучение с подкреплением через самозапуск. Сначала сети учились на записях партий людей. Потом policy network стала играть сама с собой — миллионы игр, где каждая партия улучшала сеть. Это классический RL: агент (AlphaGo) взаимодействует со средой (правила Go + копия себя), получает награду (победа/поражение в конце партии), и корректирует политику.
Через год AlphaGo Zero и AlphaZero пошли дальше: они вообще не видели человеческих партий, учились с нуля через self-play. И через 40 дней обучения AlphaGo Zero превзошёл версию, победившую Ли Седоля. Это был сильный сигнал: в сложных играх RL через самозапуск не просто догоняет человеческое мастерство, а превосходит его.
7. RLHF: как это связано с ChatGPT
Здесь история делает поворот к LLM. Все современные ChatGPT, Claude, GLM прошли путь от «сырой» языковой модели, которая просто предсказывает следующий токен, к ассистенту, который следует инструкциям. И связующее звено — RL.
Базовая LLM обучена на терабайтах интернета. Спросите её «как починить кран?» — и она может продолжить вопрос («как починить кран? — Я не знаю, но…») вместо того, чтобы ответить. Базовая модель умеет генерировать текст, но не умеет быть полезной.
Эту проблему решает RLHF (Reinforcement Learning from Human Feedback) — техника, применённая в InstructGPT (2022) и ставшая основой ChatGPT. Три шага.
Шаг 1. Supervised fine-tuning. Берём базовую модель и дообучаем её на нескольких тысячах пар «инструкция → хороший ответ», написанных людьми. Модель учится формату ассистента.
Шаг 2. Reward model. Для новой инструкции модель генерирует несколько вариантов ответа, а люди их ранжируют (лучший, хуже, ещё хуже). На этих сравнениях обучается отдельная модель — reward model, которая учится предсказывать, какой ответ предпочли бы люди.
Шаг 3. RL с reward model. Теперь у нас есть автоматический «оценщик» — reward model. Запускаем RL (обычно PPO): модель генерирует ответы, reward model их оценивает, мы корректируем модель, чтобы получать более высокие оценки. Тысячи итераций — и модель учится генерировать ответы, которые людям нравятся.
Это цикл с обратной связью, ровно как в Q-обучении, только «средой» выступает reward model, а «наградой» — её оценка ответа. Без RLHF не было бы ChatGPT: именно этот шаг превратил «токен-предсказатель» в «ассистента». И именно поэтому базовые модели (Llama, Mistral в raw-форме) ведут себя странно, пока их не заRLHF-ят.
8. Почему RL редко используется на проде (и когда стоит)
При всей красоте RL имеет серьёзный практический недостаток: он дорогой и нестабильный.
Sample inefficiency. Чтобы RL научился, нужно миллионы взаимодействий со средой. В игре это дёшево (симулятор быстрый). В реальном мире — катастрофически. Нельзя «миллион раз обнулить торговый аккаунт, чтобы научиться торговать». Поэтому RL в проде чаще всего требует либо хорошего симулятора, либо огромного числа взаимодействий.
Reward shaping — искусство. Скажете «максимизировать прибыль» — модель найдёт легальный способ обнулить счёт через налоговые лазейки. Скажете «максимизировать вовлечённость» — получите рекомендательную систему, подсаживающую на экстремальный контент. Сформулировать награду так, чтобы она отражала то, что вы на самом деле хотите — сложнее, чем кажется. Это называется alignment problem, и он актуален не только для RL, но и для LLM.
Где RL всё-таки работает. В трёх сценариях. Игры — там, где есть точный симулятор и чёткая цель (победа). Робототехника — симуляторы физики позволяют учиться безопасно, а потом переносить на реального робота (sim2real). LLM-alignment — reward model заменяет «среду», и interaction — это генерация текста, что дёшево. За пределами этих зон RL в проде встречается редко: дешевле и надёжнее работают supervised-методы.
9. Знакомый паттерн: коррекция через обратную связь
Если окинуть взглядом все четыре алгоритма RL — Q-обучение, DQN, PPO, AlphaGo — в них видна одна и та же архитектурная идея.
- Q-обучение корректирует оценку
Q(s,a)после каждого шага, сдвигая её к новой информации. - DQN делает то же, но через нейросеть и replay buffer, что стабилизирует обновления.
- PPO корректирует политику маленькими шагами, обрезая большие скачки.
- AlphaGo корректирует политики и value-сети через миллионы self-play партий, где каждая — обратная связь.
Итеративная коррекция через обратную связь — это объединяющий принцип. Тот же принцип, что в бустинге (каждое дерево корректирует ошибку предыдущих), в диффузии (каждый шаг убирает немного шума), в fine-tuning (каждый батч корректирует веса). Разница — в том, откуда приходит обратная связь: из функции потерь (supervised), из совместной игры (GAN/бустинг), из взаимодействия со средой (RL).
Заключение
Обучение с подкреплением — последняя большая парадигма машинного обучения, и, пожалуй, самая амбициозная: учиться не по готовым примерам, а через собственный опыт. От Q-таблицы лабиринтов до AlphaGo и RLHF — путь в 30 лет, и каждый шаг в нём опирался на одну идею: корректируй поведение шаг за шагом, опираясь на обратную связь.
Этой статьёй мы закрываем серию «Основы машинного обучения». Карта, которую мы нарисовали: классическое ML подбирает функции под таблицы, свёрточные сети научились видеть, генеративные модели научились создавать, а обучение с подкреплением — действовать. Вместе с серией «Как работают LLM» (Self-Attention, RAG, инструменты и MCP) это покрывает большую часть фундамента современной индустрии AI.
Куда идти дальше — решать вам. Если хотите глубже в LLM — возвращайтесь к серии «Как работают LLM» и материалам глоссария. Если интересна инженерная сторона — у нас есть обзор 38 алгоритмов одним взглядом, чтобы не потеряться в деталях. Главное, что вы теперь видите: AI — не магия, а инженерия, и за каждым «чудом» стоит конкретный алгоритм, который можно понять.