Обучите ИИ решать проблемы с замерзшим озером

Цель этой статьи – научить ИИ решать задачи в ❄️замерзшем озере с помощью обучения с подкреплением. Вместо того, чтобы читать статьи в Википедии и объяснять формулы, мы начнем с нуля и попытаемся самостоятельно воссоздать алгоритм 🤖Q-обучения. Мы не только поймем, как это работает, но и, что более важно, почему это работает: почему это было разработано таким образом? Каковы скрытые предположения, детали, которые никогда не объясняются в обычных курсах и руководствах?

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

Начнем с установки среды ❄️Frozen Lake и импорта необходимых библиотек: gym для игры, random для генерации случайных чисел и numpy для выполнения математических операций.

❄️ I. Замерзшее озеро

Теперь давайте поговорим об игре, которую мы собираемся решать в этом уроке. ❄️Замерзшее озеро – это простая среда, состоящая из плиток, где ИИ должен перейти от исходной плитки к цели. Плитки могут быть безопасным замерзшим озером ✅ или дырой ❌, в которой вы застряли навсегда. У ИИ или агента есть 4 возможных действия: ◀️ВЛЕВО, 🔽ВНИЗ, ▶️ВПРАВО или 🔼ВВЕРХ. Агент должен научиться избегать дыр, чтобы достичь цели за минимальное количество действий. По умолчанию среда всегда имеет одну и ту же конфигурацию. В коде среды каждая плитка представлена ​​буквой следующим образом:

S F F F       (S: starting point, safe)
F H F H       (F: frozen surface, safe)
F F F H       (H: hole, stuck forever)
H F F G       (G: goal, safe)

Мы можем попытаться вручную решить приведенный выше пример, чтобы понять игру. Давайте посмотрим, является ли следующая последовательность действий правильным решением: ВПРАВО → ВПРАВО → ВПРАВО → ВНИЗ → ВНИЗ → ВНИЗ. Наш агент стартует на тайле S, поэтому идем прямо по замерзшей поверхности ✅, потом снова ✅, потом еще раз ✅, потом спускаемся и находим дыру ❌.

На самом деле очень легко найти несколько правильных решений: ВПРАВО → ВПРАВО → ВНИЗ → ВНИЗ → ВНИЗ → ВПРАВО очевиден. Но мы могли бы сделать последовательность действий, которая обходит дыру 10 раз, прежде чем достичь цели. Эта последовательность допустима, но она не соответствует нашему последнему требованию: агент должен достичь цели за минимальное количество действий. В этом примере минимальное количество действий для прохождения игры равно 6. Нам нужно запомнить этот факт, чтобы проверить, действительно ли наш агент владеет ❄️Замерзшим озером или нет.

Давайте инициализируем окружение благодаря библиотеке gym. Есть две версии игры: одна с скользким льдом, где выбранные действия имеют случайный шанс быть проигнорированным агентом; и нескользкий, где действия нельзя игнорировать. Начнем с нескользкого, потому что его легче понять.

🟥FFF
FHFH
FFFH
HFFG

Мы видим, что созданная игра имеет точно такую ​​же конфигурацию, как и в нашем примере: это та же головоломка. Положение нашего агента обозначено красным прямоугольником. Решить эту головоломку можно с помощью простого скрипта и условий if…else, которые на самом деле были бы полезны для сравнения нашего ИИ с более простым подходом. Однако мы хотим попробовать более интересное решение: обучение с подкреплением.

🏁 II. Q-таблица

В ❄️Frozen Lake 16 плиток, а это значит, что наш агент может находиться в 16 различных позициях, называемых состояниями. Для каждого состояния есть 4 возможных действия: ◀️ВЛЕВО, 🔽ВНИЗ, ▶️ВПРАВО и 🔼ВВЕРХ. Научиться играть в Frozen Lake — это то же самое, что узнать, какое действие следует выбирать в каждом штате. Чтобы узнать, какое действие является лучшим в данном состоянии, мы хотели бы присвоить нашим действиям значение качества. У нас есть 16 состояний и 4 действия, поэтому нужно вычислить 16 x 4 = 64 значения.

Хорошим способом представления этого является использование таблицы, известной как Q-таблица, где в строках перечислены все состояния s, а в столбцах перечислены все действия a. В этой Q-таблице каждая ячейка содержит значение Q(s, a), которое является значением (качеством) действия a в состоянии s (1, если это наилучшее возможное действие, 0 если совсем плохо) Когда наш агент находится в определенном состоянии s, ему просто нужно проверить эту таблицу, чтобы увидеть, какое действие имеет наибольшее значение. Выполнение действия с наибольшей ценностью имеет смысл, но позже мы увидим, что можем придумать что-то еще лучше…

Давайте создадим нашу Q-таблицу и заполним ее нулями, так как мы еще не знаем ценности каждого действия в каждом состоянии.

Q-table =
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

Большой! У нас есть Q-таблица с 16 строками (наши 16 состояний) и 4 столбцами (наши 4 действия), как и ожидалось. Давайте попробуем посмотреть, что мы можем сделать дальше: каждое значение установлено равным нулю, поэтому у нас нет никакой информации. Допустим, агент выполняет случайное действие: ◀️ВЛЕВО, 🔽ВНИЗ, ▶️ВПРАВО или 🔼ВВЕРХ.

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

'LEFT'

Подождите, на самом деле агент в настоящее время находится в начальном состоянии S, что означает, что возможны только два действия: ▶️ВПРАВО и 🔽ВНИЗ. Агент также может выполнять действия 🔼ВВЕРХ и ◀️ВЛЕВО, но он не будет двигаться: его состояние не меняется. Поэтому мы не накладываем никаких ограничений на возможные действия: агент естественно поймет, что некоторые из них ничего не делают.

Мы можем продолжать использовать random.choice(), но библиотека gym уже реализует метод случайного выбора действия. Это может избавить нас от хлопот позже, так что давайте попробуем.

0

Упс... на этот раз это число. Мы могли бы прочитать документацию gym, но, к сожалению, ее очень мало. Не беспокойтесь, мы можем проверить исходный код на GitHub, чтобы понять, что означают эти цифры. Это на самом деле очень просто:

◀️ LEFT = 0
🔽 DOWN = 1
▶️ RIGHT = 2
🔼 UP = 3

Хорошо, теперь, когда мы понимаем, как gym связывает числа с направлениями, давайте попробуем использовать его для перемещения нашего агента вправо ▶️. На этот раз это можно сделать с помощью метода step(action). Мы можем попытаться непосредственно предоставить ему число 2, соответствующее выбранному нами направлению (справа), и проверить, двигался ли агент.

(Right)
S🟥FF
FHFH
FFFH
HFFG

Ура! Красный квадрат переместился из исходного состояния S вправо: наш прогноз был верным. И это все, что нам нужно знать, чтобы взаимодействовать с окружающей средой:

  1. Как случайно выбрать действие с помощью action_space.sample();
  2. Как выполнить это действие и переместить нашего агента в нужном направлении с помощью step(action).

Чтобы быть полностью исчерпывающим, мы можем добавить:

  1. Как отобразить текущую карту, чтобы увидеть, что мы делаем с render();
  2. Как перезапустить игру, когда агент падает в яму или достигает цели G с помощью reset().

Теперь, когда мы поняли, как взаимодействовать с нашей средой gym, давайте вернемся к нашему алгоритму. При обучении с подкреплением агенты вознаграждаются средой, когда они достигают заранее определенной цели. В ❄️Frozen Lake агент получает вознаграждение только тогда, когда достигает состояния G (см. исходный код). Мы не можем контролировать это вознаграждение, оно устанавливается в среде: это 1, когда агент достигает G, и 0 в противном случае.

Давайте печатать его каждый раз, когда мы реализуем действие. Награда выдается методом step(action).

(Left)
🟥FFF
FHFH
FFFH
HFFG
Reward = 0.0

Награда действительно равна 0… 😱 вау, я думаю, мы в затруднительном положении, потому что только одно состояние может дать нам положительную награду во всей игре. Как мы должны брать правильное направление в самом начале, когда единственное подтверждение, которое у нас есть, находится в самом конце? Если мы когда-либо хотим увидеть награду 1, нам должно повезти. достаточно, чтобы случайно найти правильную последовательность действий. К сожалению, именно так это и работает… Q-таблица останется заполненной нулями, пока агент случайно не достигнет цели G.

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

🤖 III. Q-обучение

Вернемся к нашей проблеме. Хорошо, нам нужно быть достаточно удачливым, чтобы случайно найти цель G. Но как только это будет сделано, как вернуть информацию в исходное состояние? 🤖Алгоритм Q-обучения предлагает разумное решение этой проблемы. Нам нужно обновить значение наших пар состояние-действие (каждая ячейка в Q-таблице), учитывая 1/награду за достижение следующего состояния и 2/наивысшее возможное значение в следующее состояние.

Мы знаем, что получаем награду 1, когда переходим на G. Как мы только что сказали, значение состояния рядом с G (назовем его G-1) с соответствующим действием для достижения G равно увеличивается благодаря награде. Ладно, конец эпизода: агент победил, и мы перезапускаем игру. Теперь, когда в следующий раз агент окажется в состоянии рядом с G-1, он увеличит значение этого состояния (назовем его G-2) на >соответствующие действия для достижения G-1. В следующий раз, когда агент окажется в состоянии рядом с G-2, он сделает то же самое. Промойте и повторяйте, пока обновление не достигнет исходного состояния S.

Давайте попробуем найти формулу обновления для обратного распространения значений от G до S. Помните: значения обозначают качество действия в определенном состоянии (0, если оно ужасное, 1, если это наилучшее действие, возможное в этом состоянии). Мы пытаемся обновить значение действия aₜ (например, aₜ= 0, если действие осталось) в состоянии sₜ (например, sₜ = 0, когда агент находится в начальном состоянии S). Это значение — просто ячейка в нашей Q-таблице, соответствующая номеру строки sₜи номеру столбца aₜ: это значение формально называется Q (sₜ, aₜ).

Как мы уже говорили ранее, нам нужно обновить его, используя 1/ вознаграждение за следующее состояние (формально обозначенное rₜ) и 2/ максимально возможное значение в следующем состоянии. (максₐQ(sₜ₊₁, а)). Следовательно, формула обновления должна выглядеть так:

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

где Q(G-1, aₜ) = 0 и maxₐQ(G, a) = 0, поскольку Q-таблица пуста, и rₜ= 1, поскольку мы получаем единственная награда в этой среде. Получаем Q{new}(G-1, aₜ) = 1. В следующий раз, когда агент окажется в состоянии, следующем за этим (G-2), мы также обновим его по формуле и получаем тот же результат: Q{new}(G-2, aₜ) = 1. В конце мы распространяем единицы обратно в Q-таблице из G на S. Хорошо, это работает, но результат бинарный: либо это неправильная пара состояние-действие, либо лучшая. Хотелось бы больше нюансов…

На самом деле, мы почти нашли истинную формулу обновления Q-learning со здравым смыслом. Нюанс, который мы ищем, добавляет два параметра:

  • α — это 💡скорость обучения (от 0 до 1), то есть насколько мы должны изменить исходное значение Q(sₜ, aₜ). Если α = 0, значение никогда не меняется, но если α = 1, значение меняется очень быстро. В нашей попытке мы не ограничивали скорость обучения, поэтому α = 1. Но на самом деле это слишком быстро: вознаграждение и максимальное значение в следующем состоянии быстро превышают текущее значение. Нам нужно найти баланс между важностью прошлых и новых знаний.
  • γ — это 📉коэффициент дисконтирования (от 0 до 1), который определяет, насколько агент заботится о будущих вознаграждениях по сравнению с немедленными (как говорится, «птица в руке стоит два в кустах»). Если γ = 0, агент фокусируется только на немедленных вознаграждениях, но если γ = 1, любое потенциальное вознаграждение в будущем имеет ту же ценность, что и текущее. В ❄️Замерзшее озеро нам нужен высокий коэффициент скидки, поскольку в самом конце игры есть только одна возможная награда.

С реальным алгоритмом Q-обучения новое значение рассчитывается следующим образом:

Хорошо, давайте попробуем эту новую формулу, прежде чем применять ее. И снова мы можем сделать вид, что наш агент впервые оказался рядом с целью G. Мы можем обновить пару состояние-действие, чтобы выиграть игру, используя нашу формулу: Q{new}(G-1, aₜ) = 0 + α · (1 + γ · 0 − 0). Мы можем присвоить произвольные значения α и γ для вычисления результата. При α = 0,5 и γ = 0,9 получаем Q{new}(G-1, aₜ) = 0 + 0,5 · (1 + 0,9 · 0 − 0) = 0,5. Во второй раз, когда агент окажется в этом состоянии, мы получим: Q{new}(G-1, aₜ) = 0,5 + 0,5 · (1 + 0,9 · 0 − 0,5) = 0,75, затем 0,875, 0,9375, 0,96875 и т. д. .

Таким образом, обучение нашего агента коду означает:

  1. Выбор случайного действия (используя action_space.sample()), если значения в текущем состоянии просто нули. В противном случае мы выполняем действие с наибольшим значением в текущем состоянии с помощью функции np.argmax();
  2. Выполнение этого действия путем перемещения в нужном направлении с помощью step(action);
  3. Обновление значения исходного состояния в соответствии с предпринятым нами действием с использованием информации о новом состоянии и вознаграждении, предоставленном step(action);

Мы продолжаем повторять эти 3 шага, пока агент не застрянет в дыре или не достигнет цели G. Когда это происходит, мы просто перезапускаем среду с reset() и начинаем новую серию, пока не наберем 1000 серий. Кроме того, мы можем построить график результатов каждого запуска (сбой, если цель не была достигнута, успех в противном случае), чтобы наблюдать за прогрессом нашего агента.

Q-table before training:
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

===========================================
Q-table after training:
[[0.         0.         0.59049    0.        ]
 [0.         0.         0.6561     0.        ]
 [0.         0.729      0.         0.        ]
 [0.         0.         0.         0.        ]
 [0.         0.02050313 0.         0.        ]
 [0.         0.         0.         0.        ]
 [0.         0.81       0.         0.        ]
 [0.         0.         0.         0.        ]
 [0.         0.         0.17085938 0.        ]
 [0.         0.         0.49359375 0.        ]
 [0.         0.9        0.         0.        ]
 [0.         0.         0.         0.        ]
 [0.         0.         0.         0.        ]
 [0.         0.         0.         0.        ]
 [0.         0.         1.         0.        ]
 [0.         0.         0.         0.        ]]

Агент обучен! Каждая синяя полоса на рисунке соответствует выигрышу, поэтому мы видим, что агенту было трудно найти цель в начале обучения. Но найдя его несколько раз подряд, он стал стабильно выигрывать. 🥳 Обученная Q-таблица тоже очень интересна: эти значения указывают на уникальную последовательность действий, которым научился агент для достижения цели.

Теперь давайте посмотрим, как он работает, оценив его на 100 эпизодах. Мы считаем, что обучение закончено, поэтому нам больше не нужно обновлять Q-таблицу. Чтобы увидеть, как работает агент, мы можем рассчитать процент случаев, когда ему удалось достичь цели (коэффициент успеха).

Success rate = 100.0%

Наш агент не только прошел обучение, но и достигает 100% успеха. Всем отлично, нескользкое ❄️Замерзшее озеро решено!

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

(Right)
SFFF
FHFH
FFFH
HFF🟥
Sequence = [2, 2, 1, 1, 1, 2]

Агент может выучить несколько правильных последовательностей действий: [2, 2, 1, 1, 1, 2], [1, 1, 2, 2, 1, 2] и т. д. Хорошо, что всего 6 действий в нашей последовательности, что было минимально возможным количеством действий, которые мы подсчитали: это означает, что наш агент научился решать игру оптимальным способом. В случае [2, 2, 1, 1, 1, 2], что соответствует ВПРАВО → ВПРАВО → ВНИЗ → ВНИЗ → ВНИЗ → ВПРАВО, это именно та последовательность, которую мы предсказывали в самом начале статьи. 📣

📐 IV. Эпсилон-Жадный алгоритм

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

Другими словами, мы хотим разрешить нашему агенту:

  • Выполнить действие с наибольшей ценностью (эксплуатация);
  • Выберите случайное действие, чтобы попытаться найти еще лучшие (исследование).

Компромисс между этими двумя видами поведения важен: если агент сосредоточен только на эксплуатации, он не может пробовать новые решения и, таким образом, больше не учится. С другой стороны, если агент выполняет только случайные действия, обучение бессмысленно, так как он не использует Q-таблицу. Поэтому мы хотим изменить этот параметр с течением времени: в начале обучения мы хотим исследовать окружающую среду как можно больше. Но исследование становится все менее и менее интересным, так как агент уже знает все возможные пары состояние-действие. Этот параметр представляет собой степень случайности при выборе действия.

Этот метод обычно называют эпсилон-жадным алгоритмом, где эпсилон — наш параметр. Это простой, но чрезвычайно эффективный способ найти хороший компромисс. Каждый раз, когда агент должен совершить действие, он имеет вероятность ε выбора случайного действия и вероятность 1-ε выбора действия с наибольшим значением. Мы можем уменьшить значение эпсилон в конце каждого эпизода на фиксированную величину (линейное затухание) или на основе текущего значения эпсилон (экспоненциальное затухание ).

Давайте реализуем линейное затухание. Предварительно хотелось бы посмотреть, как выглядит кривая с произвольными параметрами. Мы начнем с ε = 1, чтобы быть в режиме полного исследования, и будем уменьшать это значение на 0,001 после каждого эпизода.

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

Q-table before training:
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

===========================================
Q-table after training:
[[0.531441   0.59049    0.59049    0.531441  ]
 [0.531441   0.         0.6561     0.56396466]
 [0.58333574 0.729      0.56935151 0.65055117]
 [0.65308668 0.         0.33420534 0.25491326]
 [0.59049    0.6561     0.         0.531441  ]
 [0.         0.         0.         0.        ]
 [0.         0.81       0.         0.65519631]
 [0.         0.         0.         0.        ]
 [0.6561     0.         0.729      0.59049   ]
 [0.6561     0.81       0.81       0.        ]
 [0.72899868 0.9        0.         0.72711067]
 [0.         0.         0.         0.        ]
 [0.         0.         0.         0.        ]
 [0.         0.81       0.9        0.729     ]
 [0.81       0.9        1.         0.81      ]
 [0.         0.         0.         0.        ]]

Эй, теперь агенту требуется больше времени, чтобы стабильно выигрывать игру! А Q-таблица имеет намного больше ненулевых значений, чем предыдущая, что означает, что агент выучил несколько последовательностей действий для достижения цели. Это понятно, так как этот новый агент вынужден исследовать пары состояние-действие вместо того, чтобы всегда использовать пары с ненулевыми значениями.

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

Success rate = 100.0%

Уф, это еще один 100% успех! Мы не портили модель. 😌 В этом примере преимущества такого подхода могут быть неочевидны, но наша модель стала менее статична и более гибка. Он изучил разные пути (последовательности действий) от S до G вместо одного, как в предыдущем подходе. Дополнительные исследования могут снизить производительность, но необходимо обучать агентов, которые могут адаптироваться к новым условиям.

❄️ IV. Испытание: скользкое замерзшее озеро

Мы не решали всю среду ❄️Frozen Lake: мы только обучили агента на нескользкой версии, используя is_slippery = False во время инициализации. В скользком варианте действие, которое предпринимает агент, имеет вероятность успеха 33%. В случае неудачи вместо этого случайным образом выполняется одно из трех других действий. Эта функция добавляет в обучение много случайности, что усложняет работу нашего агента. Давайте посмотрим, насколько хорошо наш код работает в этой новой среде...

Q-table before training:
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

===========================================
Q-table after training:
[[0.06208723 0.02559574 0.02022059 0.01985828]
 [0.01397208 0.01425862 0.01305446 0.03333396]
 [0.01318348 0.01294602 0.01356014 0.01461235]
 [0.01117016 0.00752795 0.00870601 0.01278227]
 [0.08696239 0.01894036 0.01542694 0.02307306]
 [0.         0.         0.         0.        ]
 [0.09027682 0.00490451 0.00793372 0.00448314]
 [0.         0.         0.         0.        ]
 [0.03488138 0.03987256 0.05172554 0.10780482]
 [0.12444437 0.12321815 0.06462294 0.07084008]
 [0.13216145 0.09460133 0.09949734 0.08022573]
 [0.         0.         0.         0.        ]
 [0.         0.         0.         0.        ]
 [0.1606242  0.18174032 0.16636549 0.11444442]
 [0.4216631  0.42345944 0.40825367 0.74082329]
 [0.         0.         0.         0.        ]]

Success rate = 17.0%

Уф не очень. Но можете ли вы улучшить производительность, настроив различные параметры, о которых мы говорили? Я призываю вас принять этот небольшой вызов и сделать это самостоятельно, чтобы получить удовольствие от обучения с подкреплением и проверить, поняли ли вы все, что мы сказали о Q-обучении. И почему бы не реализовать экспоненциальное затухание и для эпсилон-жадного алгоритма? Во время этого небольшого упражнения вы могли понять, что небольшое изменение гиперпараметров может полностью разрушить результаты. Это еще одна особенность обучения с подкреплением: гиперпараметры довольно переменчивы, и важно понимать их значение, если вы хотите их настроить. Всегда полезно тестировать и пробовать новые комбинации, чтобы развить свою интуицию и стать более эффективным. Удачи и получайте удовольствие!

🔚 В. Заключение

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

  • Мы научились взаимодействовать с gym средой, чтобы выбирать действия и перемещать нашего агента;
  • Мы представили идею Q-таблицы, где строки — это состояния, столбцы — это действия, а ячейки — это значение. strong> действия в данном состоянии;
  • Мы экспериментально воссоздали формулу обновления Q-learning, чтобы решить проблему редкого вознаграждения;
  • Мы внедрили весь процесс обучения и оценки, который помог справиться со средой ❄️Frozen Lake со 100% вероятностью успеха;
  • Мы внедрили знаменитый эпсилон-жадный алгоритм, чтобы найти компромисс между исследованием неизвестных пар состояние-действие и эксплуатацией наиболее успешных. сильный>.

❄️Frozen Lake — это очень простая среда, но другие могут иметь так много состояний и действий, что становится невозможным хранить Q-таблицу в памяти. Это особенно актуально в средах, где события не дискретны, а непрерывны (например, Super Mario Bros. или Minecraft). Когда возникает проблема, популярным методом является обучение глубокой нейронной сети аппроксимации Q-таблицы. Этот метод добавляет несколько уровней сложности, поскольку нейронные сети не очень стабильны. Но я расскажу об этом в другом уроке с различными методами их стабилизации.

А пока поделитесь этой статьей, если она вам помогла, и подпишитесь на меня в Твиттере и Средний для получения дополнительной практической информации о машинном обучении и глубоком обучении. 📣