Обучение с подкреплением и выравнивание

Динамическое программирование

Value iteration против policy iteration — 215 проходов против трёх итераций

Шаг 105 из 117 · ~26 мин

Два способа решить одно уравнение

Уравнение Беллмана можно решать двумя способами, и они устроены принципиально по-разному.

Vmaxa[R+γPV]против{Vπ решить точноπgreedy(Vπ)\htmlData{k=vi}{V \leftarrow \max_a\big[R + \gamma P V\big]} \qquad\text{против}\qquad \htmlData{k=pi}{\begin{cases} V^{\pi} \text{ решить точно} \\ \pi \leftarrow \text{greedy}(V^\pi)\end{cases}}

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

Измерение

Разница на случайном MDP с восемью состояниями и четырьмя действиями, γ=0.9\gamma = 0.9, точность 101010^{-10}:

алгоритмитераций
value iteration215215
policy iteration33

Обе дают одно и то же VV^* (совпадение до 10810^{-8}). Разница в семьдесят раз — не аномалия, а типичная картина, и объясняется она одним наблюдением из урока 020: политике нужен порядок величин, а не сами величины. Value iteration уточняет числа до десятого знака, хотя порядок установился давно; policy iteration переспрашивает только про порядок.

Но итерации у них разной цены:

стоимость одной итерации
проход value iterationO(S2A)O(\vert S\vert^2\vert A\vert)
точная оценка политикиO(S3)O(\vert S\vert^3) решением системы
приближённая оценкаO(kS2)O(k\vert S\vert^2) за kk проходов

При S=8|S| = 8, A=4|A| = 4 это 256256 против 512512 — то есть policy iteration дороже вдвое за итерацию и всё равно выигрывает в семьдесят раз по общей работе. При больших S|S| кубический член становится неприемлемым, и его заменяют несколькими проходами вместо точного решения. Так получается обобщённое policy iteration, частными случаями которого оказываются оба алгоритма:

kk проходов оценкичто получается
11value iteration
до сходимостиpolicy iteration
3103{-}10то, что используют на практике

Гарантия завершения

У policy iteration есть свойство, которого нет у value iteration: она заканчивается точно, за конечное число шагов. Причина комбинаторная — политик конечное число (AS|A|^{|S|}), каждая итерация строго улучшает политику (теорема из урока 030), а значит ни одна не повторяется.

Value iteration в общем случае сходится лишь в пределе: значения приближаются к VV^* геометрически и достигают её точно только в вырожденных случаях вроде детерминированной сетки из урока 010.

Практический вывод обратен интуиции: алгоритм, который «делает больше работы за итерацию», завершается за меньшее их число и с точным ответом.

0.620.730.8610.520.73-10.430.520.620.52-0.160.520.43

терминал стена

дисконт γ 0.9
проходов 5
цена шага -0.04
горизонт 1/(1−γ)
10
значение старта
-0.164
изменение за проход
5.6e-1
проходов до сходимости
7
Здесь два терминала: награда +1 и штраф −1 прямо под ней. Проследите за стрелками в правой колонке — они обходят ловушку, и это результат, который динамическое программирование получает без единого испытания. Увеличьте цену шага по модулю и посмотрите, в какой момент обход перестаёт окупаться.

Три оговорки

Нужна модель. Оба алгоритма содержат sP(ss,a)\sum_{s'} P(s'\mid s,a). Без знания переходов ни один не применим — и это ровно то ограничение, которое снимает следующий урок.

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

Нужна табличная форма. Значения хранятся как массив, по числу на состояние. Как только VV становится нейросетью, теория из урока 030 перестаёт применяться: оператор Беллмана в композиции с проекцией на пространство функций сети не обязан быть сжимающим, и расходимость становится возможной. Это известная «смертельная триада» — аппроксимация, бутстрэппинг и off-policy обучение вместе, — и урок 090 к ней вернётся.

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

Итог

  • Value iteration и policy iteration решают одно уравнение с разной стратегией.
  • Измерено: 215215 проходов против 33 итераций на одной задаче, при цене итерации вдвое выше.
  • Причина — политике нужен порядок величин, а не их точность.
  • Policy iteration завершается точно за конечное число шагов; value iteration — в пределе.
  • Обобщённая схема с несколькими проходами оценки покрывает оба алгоритма и используется на практике.
  • Всё это требует модели, перебора состояний и табличного представления.

Источники

Проверки

0 из 2
  1. Два алгоритма, одно уравнение

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

  2. Сравнить два алгоритма

    Возьмём ту же цепочку, что в уроке 030: nn состояний, действия «стоять» (награда 00, остаёмся) и «идти» (награда rewards[s], переход в s+1s+1; из последнего — в терминал с ценностью 00).

    Реализуйте compare_dp(rewards, gamma, tolerance) — верните [optimal_first_value, vi_sweeps, pi_iterations, agree]:

    • optimal_first_value — ценность состояния 00 в оптимуме;
    • vi_sweeps — сколько проходов value iteration понадобилось, считая проход, после которого изменение стало меньше tolerance. Начинайте с нулей;
    • pi_iterations — сколько итераций policy iteration понадобилось. Одна итерация — это точная оценка текущей политики плюс жадное улучшение; считайте итерации до той включительно, на которой политика не изменилась. Начинайте с политики «везде стоять»;
    • agree — единица, если оба алгоритма дали одинаковые значения (с точностью 10610^{-6}), иначе нуль.

    Оценку политики считайте итеративно, до изменения меньше 101410^{-14} — точное решение системы для этой цепочки не требуется.

    функция compare_dp

    Загрузка редактора…

    Ctrl/⌘ + Enter