В 2016 году APLHAGO, программа, разработанная для игры в игру Идти , сделали заголовки, когда он побил чемпион мира Go игрок в пяти игровом матче. Это был замечательный подвиг, потому что количество возможных юридических ходов в Go является порядка 2,1 × 10 170 Отказ Чтобы поставить это в контекст, это число далеко, гораздо больше, чем количество атомов в наблюдаемой вселенной, которые имеют порядка 10 80 Отказ Такое большое количество возможностей делает практически невозможным создание программы, которая может эффективно играть использование грубой силы или несколько оптимизированных алгоритмов поиска.
Часть секретного соуса Альфагома было использование укрепления обучения, чтобы улучшить свое понимание игры, играя против себя. С тех пор область обучения подкреплениями видно повысило интерес, и было разработано гораздо более эффективные программы для поиска различных игр при эффективной эффективности. Хотя вы обнаружите, что обучение подкрепления обсуждалось в контексте игр и головоломок в большинстве мест (включая этот пост), приложения обучения подкрепления гораздо более распространены. Цель этого учебника – дать вам нежное введение в мир укрепления обучения.
ℹ️ Первые вещи первыми! Этот пост был написан в сотрудничестве с Алексей Винел (Профессор, Хальмстадский университет). Некоторые идеи и визуальные эффекты заимствованы из моего предыдущего поста о Q-обучении, написанные для УзнатьДаташи . В отличие от большинства постов, вы найдете в обучении подкрепления, мы пытаемся изучить обучение подкрепления здесь под углом нескольких агентов. Так что это делает его немного сложнее и захватывающим одновременно. Хотя это будет хороший ресурс для разработки интуитивного понимания укрепления укрепления (укрепление Q-обучения, чтобы быть конкретным), настоятельно рекомендуется посетить теоретические детали (некоторые ссылки, которые обделяются в Приложении), если вы готовы исследовать Укрепление укрепления за пределами этого поста.
Я должен был вспомогать библиотеку спортзала Openai для реализации пользовательской среды. Код можно найти на Этот репозиторий Github Отказ Если вы хотите исследовать интерактивную версию, вы можете проверить Из этой ноутбуки Google Colab Отказ Мы используем Python для реализации алгоритмов; Если вы не знакомы с Python, вы можете притворяться, что эти фрагменты не будут существовать и прочитать текстовую часть (включая комментарии кода). Хорошо, время начать 🚀
Что такое укрепление обучения?
Обучение подкрепления – это парадигма машинного обучения, где обучение происходит через обратную связь, полученную взаимодействием агента с его средой. Это также один из критических дифференциаторов укрепления укрепления с другими двумя парадигмами машинного обучения ( Контролируемое обучение и Ожидаемое обучение ). Алгоритмы над руководителями обучения требуют полностью маркированных учебных данных, а нерешенные алгоритмы обучения не нуждаются в этикеток. С другой стороны, алгоритмы обучения подкреплениями используют обратную связь от окружающей среды, в которой они работают, чтобы улучшить задачи, которые они обучены выполнять. Таким образом, мы можем сказать, что обучение подкрепления лежит где-то в середине спектра.
Неизбежно говорить о укреплении укрепления в изучении ясности без использования некоторых технических терминов, таких как «Агент», «Действие», «Государство», «Награда» и «Окружающая среда». Итак, давайте попробуем получить понимание высокого уровня обучения подкреплению и настоящих Условий по аналогии,
Понимание укрепления обучения через птичку
Давайте сначала посмотрим первые несколько секунд этого видео,
Довольно круто, не так ли?
А теперь подумайте о том, как кто-то удалось научить этот попугай ответить с определенными звуками по конкретным подсказкам. И если вы внимательно соблюдаете, часть ответа лежит в еде попугая после каждого прохлада. Человек задает вопрос, и попугай пытается реагировать во многих отношениях, и если ответ Parrot является желаемым, он вознаграждается едой. Теперь угадай что? В следующий раз попугай подвергается тому же кишему, он, вероятно, ответит аналогично, ожидая большего количества продуктов питания. Вот как мы «укрепляем» определенное поведение посредством положительного опыта. Если бы мне пришлось объяснить вышеуказанный процесс с точки зрения концепций обучения подкреплениями, это было бы что-то вроде,
” Агент учится принять желаемое для данного состояния в окружающей среде »,
где,
- «Агент» – попугай
- «Государство» – это вопросы или киес, которые попугая подвергается
- «Действия» являются звуками Это произнесено
- «Награда» – это еда, которую он получает, когда он принимает желаемое действие
- И «окружающая среда» – это место, где живет попугай (или, другими словами, все остальное, чем попугай)
Усиление может произойти через негативный опыт. Например, если ребенок касается горящей свечи из любопытства, (ы), он вряд ли повторит одно и то же действие. Итак, в этом случае вместо вознаграждения агент получил штраф, который не согласил бы агент, чтобы снова повторить те же действие в будущем.
Если вы попытаетесь подумать об этом, существуют бесчисленные подобные реальные аналогии. Это говорит о том, почему обучение подкрепления может быть полезно для широкого спектра реальных применений и почему это может быть путь для создания генеральных агентов AI (подумайте о программе, которая не может просто победить человека в игре, но несколько игр как шахматы, гта и др.). Это может потребоваться много времени для развития агентов с общей интеллектом, но читая о программах, таких как Музеро (Одним из многих преемников Alpha Go) намекает на то, что обучение подкреплениями может иметь достойную роль в достижении этого.
Прочитав аналогии, несколько вопросов, как ниже, могут прийти в ваш разум,
- Пример реального мира в порядке, но как мне сделать это «подкрепление» в мире программ?
- Каковы эти алгоритмы, и как они работают?
Давайте начнем ответить на такие вопросы, как переключатели передач и погрузитесь в определенные технические науки о подготовке армирования.
Пример Заявление о проблеме: самостоятельно вождение такси
Разве это не было бы фантастическим для обучения агента (то есть создать компьютерную программу), чтобы забрать с местоположения и бросить их в нужное место? В остальной части урока мы решим упрощенную версию этой проблемы с помощью укрепления обучения.
Давайте начнем с указания типичных шагов в процессе обучения подкреплением,
- Агент отмечает окружающую среду. Наблюдение представлено в цифровой форме, а также называемое «государством».
- Агент использует наблюдение, чтобы решить, как действовать. Агент стратегии использует для выявления действий для выполнения, также называется «политикой».
- Агент выполняет действие в окружающей среде.
- Окружающая среда, в результате действия может перемещаться в новое состояние (то есть создание разных наблюдений) и может вернуть обратную связь с агентом в виде наград/штрафов.
- Агент использует награды и наказания для уточнения своей политики.
- Процесс можно повторить, пока агент не найдет оптимальную политику.
Теперь, когда мы прояснимся о процессе, нам нужно настроить окружающую среду. В большинстве случаев это означает, что нам нужно выяснить следующие детали,
1. Состояние пространства
Как правило, «состояние» будет кодировать наблюдаемую информацию о том, что агент может использовать, чтобы научиться эффективно действовать. Например, в случае самоуправления-такси государственная информация может содержать следующую информацию,
- Текущее местонахождение такси
- Текущее местоположение пассажира
- Назначение
Может быть несколько способов представить такую информацию, и как можно сделать, это зависит от уровня сложности, предназначенного.
Государственное пространство – это набор всех возможных состояний. Окружающая среда может быть в. Например, если мы рассмотрим нашу среду для самостоятельного вождения такси, чтобы быть двумерным 4×4 сеткой, Есть
- 16 возможных местоположений для такси
- 16 возможных местоположений для пассажира
- и 16 возможных путей пункта назначения
Это означает, что наш размер пространства состояния становится 16 x 16 x, то есть в любой момент времени, окружающая среда должна быть в любом из этих 4096 состояний.
2. Пространство действия
Пространство действия – это набор всех возможных действий, которые агент может принимать в окружающую среду. Примерение той же 2D-мирового примера 2D, агент такси может быть разрешено принимать следующие действия,
- Двигаться на север
- Двигаться на юг
- Переместить восток
- Двигаться на запад
- Поднимать
- Высадка
Опять же, могут быть несколько способов определить пространство действий, и это только один из них. Выбор также зависит от уровня сложности и алгоритмов, которые вы хотите использовать позже.
3. Награды
Награды и штрафы имеют решающее значение для обучения агента. Решая структуру вознаграждения, мы должны тщательно продумать величину, направление (положительное или отрицательное), а частота вознаграждения (каждый шаг/на основе определенного этапа/и т. Д.). Примерение той же среды сетки, некоторые идеи для структуры вознаграждения могут быть,
- Агент должен получить положительное вознаграждение, когда он выполняет успешный пассажирский отброс. Награда должна быть высокой величиной, потому что это поведение очень желательно.
- Агент должен быть наказан, если он пытается выбросить пассажир в неправильных местах.
- Агент должен получить небольшую негативную награду, чтобы не добраться до места назначения после каждого шага. Это стимулировало бы агента, чтобы взять более быстрые маршруты.
Для вознаграждений могут быть больше идей, как награда за успешный пикап и так далее.
4. Правила перехода
Правила перехода являются своего рода мозг окружающей среды. Они указывают динамику вышеупомянутых компонентов (состояние, действие и вознаграждение). Они часто представлены с точки зрения таблиц (а.к.А государственных переходных таблиц), которые указывают, что,
Для данного состояния S, если вы принять меры A, новое состояние окружающей среды становится S ‘, а полученная награда R.
| Поспешный | AQ. | Rpq. | Сп | 1.0 |
| … | … | … | … | … |
Пример строки может быть, когда местоположение такси находится в середине сетки, местоположение пассажира в правом нижнем углу. Агент принимает действие «Move North», он получает негативную награду, а следующее государство становится государством, представляющим такси в новой позиции.
Примечание: В реальном мире государственные переходы могут не быть детерминированными, то есть они могут быть либо.
- Стохастик; Это означает, что правила работают по вероятности, то есть, если вы принимаете меры, есть X 1 % вероятность, что вы получите в штате S 1 и XN% вероятность, что вы закончите в состоянии Sn.
- Неизвестно, что означает, что он не известен заранее, что все возможные состояния, который может войти в действие, если он принимает действие A в данном состоянии S. Это может быть случай, когда агент работает в реальном мире.
Реализация окружающей среды
Реализация компьютерной программы, которая представляет среду, может быть немного усилий программирования. Помимо решения специфики, таких как состояние пространства государства, таблица переходной трансзарения, структура вознаграждения и т. Д., Нам нужно реализовать другие функции, такие как создание способа ввода действий в окружающую среду и получить обратную связь взамен. Чаще всего, чем нет, есть также требование визуализировать то, что происходит под капотом. Поскольку целью этого учебника «Введение в обучение подкрепления», мы пропустим «Как программировать среду обучения подкреплениями» и прыгать прямо на его использование. Однако, если вы заинтересованы, вы можете проверить Исходный код и следуйте за комментариями.
Особенности окружающей среды
Мы будем использовать пользовательскую среду, вдохновленную в тренажерном зале Openai Taxi-V3 Окружающая среда Отказ Мы добавили поворот в окружающую среду. Вместо того, чтобы иметь один такси и один пассажир, у нас будет два такси и пассажира! Намерение за модом состоит в том, чтобы наблюдать интересную динамику, которая может возникнуть из-за наличия другого такси. Это также означает, что государственное пространство состоится дополнительное местоположение такси, а пространство действий состоит в том, что сейчас имеются действия как на такси.
Наша среда построена на библиотеке спортзала Openai, что позволяет удобно реализовать среды для оценки алгоритмов обучения подкреплениями. Они также включают в себя некоторые предварительно упакованные среды (Taxi-V3 – это один из них), и их среда являются популярным способом практикования укрепления обучения и оценки алгоритмов обучения подкреплениями. Не стесняйтесь проверить свои документы, чтобы узнать больше о них!
Исследуя окружающую среду
Пришло время мы начать погружение в какой-код и исследовать специфики окружающей среды, мы будем использовать для укрепления обучения в этом руководстве.
# Let's first install the custom gym module, which contains the environment pip uninstall gym -y pip install git+git://github.com/satwikkansal/gym-dual-taxi.git#"egg=gym&subdirectory=gym/"
import gym
env = gym.make('DualTaxi-v1')
env.render()
# PS: If you're using jupyter notebook and get env not registered error, you have to restart your kernel after installing the custom gym package in the last step.
На фрагменте выше мы инициализировали наш пользовательский Dualtaxi-v1 окружающая среда и оказывает свое текущее состояние. В представленном выходе,
- Желтые и красные прямоугольники представляют как такси на сетке 4×4
- R, g, b, и y – четыре возможных места для забрать или высадки для пассажира
- Персонаж “|” представляет стену, что такси не могут пересекать
- Письмо голубого цвета представляет собой местоположение пассажира
- Фиолетовая буква представляет собой местонахождение.
- Любое такси, которое получает пассажирский борт, станет зеленым цветом
>>> env.observation_space, env.action_space
(Discrete(6144), Discrete(36))
Возможно, вы заметили, что единственная напечатанная информация – их дискретная природа и размер пространства. Остальные детали абстрагированы. Это важный момент, и, поскольку вы будете реализовать к концу поста, наш ALGoritm RL не понадобится больше информации.
Однако, если вам все еще интересно, как функции окружающей среды, пожалуйста, проверьте Код окружающей среды и следуйте за комментариями. Еще одна вещь, которую вы можете сделать, это заглянуть в таблицу с переходной экономикой (проверьте код в приложении, если вы любопытно, как это сделать)
Цель
Целью окружающей среды состоит в том, чтобы забрать пассажир из синего местоположения и упасть на фиолетовое место как можно быстрее. Интеллектуальный агент должен быть в состоянии сделать это с согласованностью. Теперь давайте посмотрим, какую информацию у нас есть для пространства состояния окружающей среды (пространство наблюдения A.k.a) и пространство действий. Но перед тем, как мы погрузимся в реализацию этого интеллектуального агента, давайте посмотрим, как будет выполнять случайное агент в этой среде,
def play_random(env, num_episodes):
"""
Function to play the episodes.
"""
for i in range(num_episodes):
state = env.reset()
done = False
while not done:
next_action = env.action_space.sample()
state, reward, done, _ = env.step(next_action)
# Trying the dumb agent print_frames(play_random(env, num_episodes=2)) # check github for the code for print_frames
Вы можете увидеть номер эпизода в верхней части. В нашем случае эпизод является таймфреймом между шагами, где такси делают первый шаг и шаг, в котором они падают пассажиру при желаемом после подбора. Когда это произойдет, эпизод окончен, и мы должны сбросить среду, чтобы начать все снова.
Вы можете увидеть разные действия внизу и как состояние продолжает меняться и вознаграждение агента после каждого действия.
Как вы могли бы реализовать, эти такси занимают некоторое время, чтобы закончить даже один эпизод. Таким образом, наш случайный подход очень тупой наверняка. Наш интеллектуальный агент определенно должен будет выполнить эту задачу лучше.
Представляем Q-обучение
Q-обучение является одним из нескольких алгоритмов обучения подкреплениями. Причина, по которой мы выбираем Q-обучение, заключается в том, что она просто понять. Мы будем использовать Q-обучение, чтобы наш агент несколько разумным.
Интуиция за Q-обучение
Путь Q-обучающих работ является хранение того, что мы называем q-значениями для каждой комбинации состояния. Q-значение представляет «качество» действия, взятого из этого состояния. Конечно, начальные значения Q – это просто случайные числа, но цель – обновить их в правильном направлении итеративно. После достаточных итераций эти значения Q могут начинаться сходятся (то есть размер обновления в предстоящих итерациях становится настолько крошечно, что оно имеет незначительное воздействие). Как только это дело, мы можем смело сказать это,
Для данного государства, тем выше количество Q-стоимости для пары государства-действия, тем выше будет ожидаемая долгосрочная награда на принятие этих конкретных действий.
Таким образом, длинная история, часть «развивающейся интеллектуальной» части Q-обучения заключается в том, как q-значения после взаимодействия агента с окружающей средой, которые требуют обсуждения двух ключевых концепций,
1. Уравнение Белламана
Прилагается ниже – уравнение Белламана в контексте обновления ценностей Q. Это уравнение, которое мы используем для обновления ценностей Q после взаимодействия агента с окружающей средой.
Q-значение пары государства-действия – это сумма мгновенного вознаграждения и скидка будущая награда (из полученного государства). Где,
- S T представляет состояние во времени
т - А T представляет действия, предпринятые во время
т(Агент был в штате S T на данный момент времени) - R T вознаграждается ли вознаграждение, выполнив действие A T в состоянии S T Отказ
- S Т + 1 Является ли следующее государство, которое наш агент будет переходить к выполнению действия A T в состоянии S T Отказ
Коэффициент дисконтирования γ (Gamma) определяет, насколько важнее мы хотим дать на будущие награды. Высокое значение для фактора дисконтирования (близко к 1 ) отражает эффективную долгосрочную награду, тогда как коэффициент дисконтирования 0 Заставляет наш агент рассматривать только немедленную награду, поэтому делает его жадным.
$ \ Alpha $ (alpha) – это наше курс обучения. Как и в контролируемых настройках обучения, альфа здесь представляет собой степень, в которой наши q-значения обновляются в каждой итерации.
2. Эпсилон жадный метод
Хотя мы поддерживаем обновление Q-значений каждой итерации, есть важный выбор, который должен принять агент при принятии действий. Выбор его лица – это «исследовать» или «эксплуатировать»?
Таким образом, со временем Q-значения Q поправляются при предложении качества пары состояния. Но чтобы достичь этой цели, агент должен попробовать разные действия (как он может знать, является ли паре государства-действия хороша, если она не пробовала?). Таким образом, это становится критическим для агента «исследовать», то есть. Возьми случайные действия, чтобы собрать больше знаний об окружающей среде.
Но есть проблема, если агент исследует только. Разведка может только получить агент до сих пор. Представьте, что среда окружающая среда находится как лабиринт. Разведка может поставить агента на неизвестный путь и дать обратную связь, чтобы сделать Q-значения более ценными. Но если агент предпринимает только случайные действия на каждом шаге, он будет трудно достичь конечного состояния лабиринта. Вот почему это также важно «эксплуатировать». Агент также должен рассмотреть вопрос о том, что он уже изучил (то есть q-значения), чтобы определить, какие действия следует взять дальше.
Это все сказать, агент должен сбалансировать эксплуатацию и разведку. Есть много способов сделать это. Один из общего способа сделать это с помощью Q-обучения, состоит в том, чтобы иметь значение, называемое «EPSILON», что обозначает вероятность, с помощью которой агент исследует. Высшее значение EPSILON приводит к взаимодействиям с большим количеством наказаний (в среднем), что очевидно, потому что мы исследуем и делаем произвольные решения. Мы можем добавить более сложность к этому методу, и это обычная практика, которую люди начинают с высокого значения EPSILON и продолжают уменьшать его с течением времени. Это называется эпсилон распад. Интуиция заключается в том, что, поскольку мы продолжаем добавлять больше знаний до ценностей Q с помощью разведки, эксплуатация становится более заслуживающей доверия, что означает, что мы можем исследовать более низкую ставку.
Примечание. Обычно существует некоторая путаница, если Eppisilon представляет вероятность «разведки» или «эксплуатацию». Вы обнаружите, что он использовал оба пути в Интернете и другие ресурсы. Я нахожу первым способом более комфортно, поскольку он подходит к терминологии «Эпсилон распад». Если вы видите это наоборот, не запутайтесь, концепция все еще такая же.
Использование Q-обучения для нашей среды
Хорошо, достаточно фона о Q-обучении. Теперь, как мы применим его к нашему Dualtaxi-v1 окружающая обстановка? Потому что у нас есть два такси в нашей среде, мы можем сделать это в паре способы,
1. Кооперативный подход
В этом подходе можно предположить, что один агент с одним Q-таблицей контролирует как такси как такси (подумайте об этом как агентство такси). Общая цель этого агента будет максимизировать награду, эти такси получают комбинированные.
2. Конкурентный подход
В этом подходе мы можем тренировать двух агентов (один для каждого такси). У каждого агента есть собственный Q-стол и получает свою награду. Конечно, следующее состояние окружающей среды по-прежнему зависит от действий как агентов. Это создает интересную динамику, где каждый такси будет обучен максимизировать свои индивидуальные награды.
Кооперативный подход в действии
Прежде чем мы увидим код, давайте укажем шаги, которые мы должны были взять,
- Инициализировать Q-Table (размер Q-Table – это state_space_size x action_space_size) всеми нулями.
- Определите между разведкой и эксплуатацией на основе ценности EPSILON.
- Разведка: Для каждого состояния выберите любой из всех возможных действий для текущих состояний (ы).
- Эксплуатация: Для всех возможных действий из состояния (S ‘) выберите тот, который с наибольшим значением Q.
- Путешествовать в следующее государство (S ‘) в результате этого действия (а).
- Обновите значения Q-таблицы с использованием уравнения обновления.
- Если эпизод закончился (то есть состояния цели достигается), сбросьте среду для следующей итерации.
- Продолжайте повторять шаги от 2 до 7, пока не увидим приличных результатов в производительности агента.
from collections import Counter, deque
import random
def bellman_update(q_table, state, action, next_state, reward):
"""
Function to perform the q-value update as per bellman equation.
"""
# Get the old q_value
old_q_value = q_table[state, action]
# Find the maximum q_value for the actions in next state
next_max = np.max(q_table[next_state])
# Calculate the new q_value as per the equation
new_q_value = (1 - alpha) * old_q_value + alpha * (reward + gamma * next_max)
# Finally, update the q_value
q_table[state, action] = new_q_value
def update(q_table, env, state):
"""
Selects an action according to epsilon greedy method, performs it, and the calls bellman update
to update the Q-values.
"""
if random.uniform(0, 1) > epsilon:
action = env.action_space.sample()
else:
action = np.argmax(q_table[state])
next_state, reward, done, info = env.step(action)
bellman_update(q_table, state, action, next_state, reward)
return next_state, reward, done, info
def train_agent(
q_table, env, num_episodes, log_every=50000, running_metrics_len=50000,
evaluate_every=1000, evaluate_trials=200):
"""
This is the training logic. It takes input as a q-table, the environment.
The training is done for num_episodes episodes. The results are logged periodically.
We also record some useful metrics like average reward in the last 50k timesteps, the average length of the last 50 episodes and so on. These are helpful to gauge how the algorithm is performing
over time.
After every few episodes of training. We run an evaluation routine, where we just "exploit", i.e. rely on the q-table so far and see how well the agent has learned so far. Over time, the results should get
better until the q-table starts converging, after which there's negligible change in the results.
"""
rewards = deque(maxlen=running_metrics_len)
episode_lengths = deque(maxlen=50)
total_timesteps = 0
metrics = {}
for i in range(num_episodes):
epochs = 0
state = env.reset()
num_penalties, reward= 0, 0
done = False
while not done:
state, reward, done, info = update(q_table, env, state)
rewards.append(reward)
epochs += 1
total_timesteps += 1
if total_timesteps % log_every == 0:
rd = Counter(rewards)
avg_ep_len = np.mean(episode_lengths)
zeroes, fill_percent = calculate_q_table_metrics(q_table)
print(f'Current Episode: {i}')
print(f'Reward distribution: {rd}')
print(f'Last 10 episode lengths (avg: {avg_ep_len})')
print(f'{zeroes} Q table zeroes, {fill_percent} percent filled')
episode_lengths.append(epochs)
if i % evaluate_every == 0:
print('===' * 10)
print(f"Running evaluation after {i} episodes")
finish_percent, avg_time, penalties = evaluate_agent(q_table, env, evaluate_trials)
print('===' * 10)
rd = Counter(rewards)
avg_ep_len = float(np.mean(episode_lengths))
zeroes, fill_percent = calculate_q_table_metrics(q_table)
metrics[i] = {
'train_reward_distribution': rd,
'train_ep_len': avg_ep_len,
'fill_percent': fill_percent,
'test_finish_percent': finish_percent,
'test_ep_len': avg_time,
'test_penalties': penalties
}
print("Training finished.")
return q_table, metrics
def calculate_q_table_metrics(grid):
"""
This function counts what percentage of cells in the q-table is non-zero.
Note: Certain state-action combinations are illegal, so the table might never be full.
"""
r, c = grid.shape
total = r * c
count = 0
for row in grid:
for cell in row:
if cell == 0:
count += 1
fill_percent = (total - count) / total * 100.0
return count, fill_percent
def evaluate_agent(q_table, env, num_trials):
"""
The routine to evaluate an agent. It simply exploits the q-table and records the performance metrics.
"""
total_epochs, total_penalties, total_wins = 0, 0, 0
for _ in range(num_trials):
state = env.reset()
epochs, num_penalties, wins = 0, 0, 0
done = False
while not done:
next_action = np.argmax(q_table[state])
state, reward, done, _ = env.step(next_action)
if reward < -2:
num_penalties += 1
elif reward > 10:
wins += 1
epochs += 1
total_epochs += epochs
total_penalties += num_penalties
total_wins += wins
average_penalties, average_time, complete_percent = compute_evaluation_metrics(num_trials,total_epochs,total_penalties,total_wins)
print_evaluation_metrics(average_penalties,average_time,num_trials,total_wins)
return complete_percent, average_time, average_penalties
def print_evaluation_metrics(average_penalties, average_time, num_trials, total_wins):
print("Evaluation results after {} trials".format(num_trials))
print("Average time steps taken: {}".format(average_time))
print("Average number of penalties incurred: {}".format(average_penalties))
print(f"Had {total_wins} wins in {num_trials} episodes")
def compute_evaluation_metrics(num_trials, total_epochs, total_penalties, total_wins):
average_time = total_epochs / float(num_trials)
average_penalties = total_penalties / float(num_trials)
complete_percent = total_wins / num_trials * 100.0
return average_penalties, average_time, complete_percent
import numpy as np
# The hyper-parameters of Q-learning
alpha = 0.1 # learning rate
gamma = 0.7 # discout factor
epsilon = 0.2
env = gym.make('DualTaxi-v1')
num_episodes = 50000
# Initialize a q-table full of zeroes
q_table = np.zeros([env.observation_space.n, env.action_space.n])
q_table, metrics = train_agent(q_table, env, num_episodes) # Get back trained q-table and metrics
Total encoded states are 6144
==============================
Running evaluation after 0 episodes
Evaluation results after 200 trials
Average time steps taken: 1500.0
Average number of penalties incurred: 1500.0
Had 0 wins in 200 episodes
==============================
----------------------------
Skipping intermediate output
----------------------------
==============================
Running evaluation after 49000 episodes
Evaluation results after 200 trials
Average time steps taken: 210.315
Average number of penalties incurred: 208.585
Had 173 wins in 200 episodes
==============================
Current Episode: 49404
Reward distribution: Counter({-3: 15343, -12: 12055, -4: 11018, -11: 4143, -20: 3906, -30: 1266, -2: 1260, 99: 699, -10: 185, 90: 125})
Last 10 episode lengths (avg: 63.0)
48388 Q table zeroes, 78.12319155092592 percent filled
Training finished.
Я пропустил промежуточный вывод нарочно; Вы можете проверить это пастебин Если вы заинтересованы во всем выходе.
Конкурентный подход
Шаги для этого похожи на совместный подход, с разницей, которые теперь у нас есть несколько Q-таблиц для обновления.
- Инициализируйте Q-Table 1 и 2 как для агентов всеми нулями. Размер каждой Q-таблицы
STATE_SPACE_SIZE X SQRT (ACTE_SPACE_SIZE)Отказ - Определите между разведкой и эксплуатацией на основе ценности EPSILON.
- Разведка: Для каждого состояния выберите любой из всех возможных действий для текущих состояний (ы).
- Эксплуатация: Для всех возможных действий из состояния (S ‘) выберите тот, который с наибольшим значением Q в Q-таблицах соответствующих агентов.
- Переход к следующему состоянию (S ‘) в результате этого комбинированного действия (A1, A2).
- Обновите значения Q-таблицы для обоих агентов, используя уравнение обновления и соответствующие награды и действия.
- Если эпизод закончился (то есть состояния цели достигается), сбросьте среду для следующей итерации.
- Продолжайте повторять шаги от 2 до 7, пока не начнем увидеть приличные результаты в производительности.
def update_multi_agent(q_table1, q_table2, env, state):
"""
Same as the update method discussed in the last section, just modified for two independent q-tables.
"""
if random.uniform(0, 1) > epsilon:
action = env.action_space.sample()
action1, action2 = env.decode_action(action)
else:
action1 = np.argmax(q_table1[state])
action2 = np.argmax(q_table2[state])
action = env.encode_action(action1, action2)
next_state, reward, done, info = env.step(action)
reward1, reward2 = reward
bellman_update(q_table1, state, action1, next_state, reward1)
bellman_update(q_table2, state, action1, next_state, reward2)
return next_state, reward, done, info
def train_multi_agent(
q_table1, q_table2, env, num_episodes, log_every=50000, running_metrics_len=50000,
evaluate_every=1000, evaluate_trials=200):
"""
Same as the train method discussed in the last section, just modified for two independent q-tables.
"""
rewards = deque(maxlen=running_metrics_len)
episode_lengths = deque(maxlen=50)
total_timesteps = 0
metrics = {}
for i in range(num_episodes):
epochs = 0
state = env.reset()
done = False
while not done:
# Modification here
state, reward, done, info = update_multi_agent(q_table1, q_table2, env, state)
rewards.append(sum(reward))
epochs += 1
total_timesteps += 1
if total_timesteps % log_every == 0:
rd = Counter(rewards)
avg_ep_len = np.mean(episode_lengths)
zeroes1, fill_percent1 = calculate_q_table_metrics(q_table1)
zeroes2, fill_percent2 = calculate_q_table_metrics(q_table2)
print(f'Current Episode: {i}')
print(f'Reward distribution: {rd}')
print(f'Last 10 episode lengths (avg: {avg_ep_len})')
print(f'{zeroes1} Q table 1 zeroes, {fill_percent1} percent filled')
print(f'{zeroes2} Q table 2 zeroes, {fill_percent2} percent filled')
episode_lengths.append(epochs)
if i % evaluate_every == 0:
print('===' * 10)
print(f"Running evaluation after {i} episodes")
finish_percent, avg_time, penalties = evaluate_multi_agent(q_table1, q_table2, env, evaluate_trials)
print('===' * 10)
rd = Counter(rewards)
avg_ep_len = float(np.mean(episode_lengths))
zeroes1, fill_percent1 = calculate_q_table_metrics(q_table1)
zeroes2, fill_percent2 = calculate_q_table_metrics(q_table2)
metrics[i] = {
'train_reward_distribution': rd,
'train_ep_len': avg_ep_len,
'fill_percent1': fill_percent1,
'fill_percent2': fill_percent2,
'test_finish_percent': finish_percent,
'test_ep_len': avg_time,
'test_penalties': penalties
}
print("Training finished.\n")
return q_table1, q_table2, metrics
def evaluate_multi_agent(q_table1, q_table2, env, num_trials):
"""
Same as evaluate method discussed in the last section, just modified for two independent q-tables.
"""
total_epochs, total_penalties, total_wins = 0, 0, 0
for _ in range(num_trials):
state = env.reset()
epochs, num_penalties, wins = 0, 0, 0
done = False
while not done:
# Modification here
next_action = env.encode_action(
np.argmax(q_table1[state]),
np.argmax(q_table2[state]))
state, reward, done, _ = env.step(next_action)
reward = sum(reward)
if reward < -2:
num_penalties += 1
elif reward > 10:
wins += 1
epochs += 1
total_epochs += epochs
total_penalties += num_penalties
total_wins += wins
average_penalties, average_time, complete_percent = compute_evaluation_metrics(num_trials,total_epochs,total_penalties,total_wins)
print_evaluation_metrics(average_penalties,average_time,num_trials,total_wins)
return complete_percent, average_time, average_penalties
# The hyperparameter of Q-learning
alpha = 0.1
gamma = 0.8
epsilon = 0.2
env_c = gym.make('DualTaxi-v1', competitive=True)
num_episodes = 50000
q_table1 = np.zeros([env_c.observation_space.n, int(np.sqrt(env_c.action_space.n))])
q_table2 = np.zeros([env_c.observation_space.n, int(np.sqrt(env_c.action_space.n))])
q_table1, q_table2, metrics_c = train_multi_agent(q_table1, q_table2, env_c, num_episodes)
Total encoded states are 6144
==============================
Running evaluation after 0 episodes
Evaluation results after 200 trials
Average time steps taken: 1500.0
Average number of penalties incurred: 1500.0
Had 0 wins in 200 episodes
==============================
----------------------------
Skipping intermediate output
----------------------------
==============================
Running evaluation after 48000 episodes
Evaluation results after 200 trials
Average time steps taken: 323.39
Average number of penalties incurred: 322.44
Had 158 wins in 200 episodes
==============================
Current Episode: 48445
Reward distribution: Counter({-12: 13993, -3: 12754, -4: 11561, -20: 3995, -11: 3972, -30: 1907, -10: 649, -2: 524, 90: 476, 99: 169})
Last 10 episode lengths (avg: 78.08)
8064 Q table 1 zeroes, 78.125 percent filled
8064 Q table 2 zeroes, 78.125 percent filled
==============================
Running evaluation after 49000 episodes
Evaluation results after 200 trials
Average time steps taken: 434.975
Average number of penalties incurred: 434.115
Had 143 wins in 200 episodes
==============================
Current Episode: 49063
Reward distribution: Counter({-3: 13928, -12: 13605, -4: 10286, -11: 4542, -20: 3917, -30: 1874, -10: 665, -2: 575, 90: 433, 99: 175})
Last 10 episode lengths (avg: 75.1)
8064 Q table 1 zeroes, 78.125 percent filled
8064 Q table 2 zeroes, 78.125 percent filled
Current Episode: 49706
Reward distribution: Counter({-12: 13870, -3: 13169, -4: 11054, -11: 4251, -20: 3985, -30: 1810, -10: 704, -2: 529, 90: 436, 99: 192})
Last 10 episode lengths (avg: 76.12)
8064 Q table 1 zeroes, 78.125 percent filled
8064 Q table 2 zeroes, 78.125 percent filled
Training finished.
Я пропустил промежуточный вывод нарочно; Вы можете проверить это пастебин Если вы заинтересованы во всем выходе.
Оценка производительности
Если вы заметили код, функции поезда вернулись Q-таблицы, а также некоторые метрики. Теперь мы можем использовать Q-Table Now для принятия действий агента и посмотреть, насколько он стал умным. Кроме того, мы попытаемся построить эти метрики, чтобы визуализировать, как продвинулся тренировка.
from collections import defaultdict
import matplotlib.pyplot as plt
# import seaborn as plt
def plot_metrics(m):
"""
Plotting various metrics over the number of episodes.
"""
ep_nums = list(m.keys())
series = defaultdict(list)
for ep_num, metrics in m.items():
for metric_name, metric_val in metrics.items():
t = type(metric_val)
if t in [float, int, np.float64]:
series[metric_name].append(metric_val)
for m_name, values in series.items():
plt.plot(ep_nums, values)
plt.title(m_name)
plt.xlabel('Number of episodes')
plt.show()
def play(q_table, env, num_episodes):
for i in range(num_episodes):
state = env.reset()
done = False
while not done:
next_action = np.argmax(q_table[state])
state, reward, done, _ = env.step(next_action)
def play_multi(q_table1, q_table2, env, num_episodes):
"""
Capture frames by playing using the two q-tables.
"""
for i in range(num_episodes):
state = env.reset()
done = False
while not done:
next_action = env.encode_action(
np.argmax(q_table1[state]),
np.argmax(q_table2[state]))
state, reward, done, _ = env.step(next_action)
plot_metrics(metrics)
frames = play(q_table, env, 10) print_frames(frames)
plot_metrics(metrics_c)
print_frames(play_multi(q_table1, q_table2, env_c, 10))
Некоторые наблюдения
- В то время как агент по изучению Q, первоначально совершает ошибки во время разведки, но после того, как он узнал достаточно (видел большинство государств), он начинает действовать мудро.
- Оба подхода были достаточно хорошо. Однако в относительном сравнении кооперативный подход кажется лучше. Участки конкурентного подхода более летучие.
- Это потребовалось около 2000 эпизодов для агентов, чтобы исследовать большую часть возможных пар действий. Обратите внимание, что не являются парами на государственные действия, поскольку некоторые государства не являются юридическими (например, государствами, где оба такси имеют точное местоположение, не возможно).
- По мере продвижения обучения количество штрафов сократилось. Они не были полностью сокращены из-за Эпсилона (мы все еще исследуем на основе ценности EPSILON во время тренировок).
- Длина эпизода продолжалась уменьшаться, что означает, что такси могут подобрать и бросить пассажир быстрее из-за недавно изученных знаний в Q-таблицах.
Таким образом, чтобы обобщить, агент может охватить стены, выбирать пассажиров, взять меньше штрафов и своевременно добраться до пункта назначения. И тот факт, что код, в котором происходит обновление Q-обучения, это просто около 20-30 строк кода Python, делает его еще более впечатляющим.
От того, что мы обсуждали до сих пор в посте, вы, вероятно, получите справедливый бит интуиции о том, как работает укрепление обучения. Сейчас в последних нескольких разделах мы будем опускать наши пальцы на более широкие идеи и концепции уровня, которые могут иметь отношение к вам при изучении укрепления обучения дальше. Начнем с общих проблем обучения подкреплениями,
Общие вызовы при применении укрепления обучения
Нахождение правильных гиперпараметров
Вам может быть интересно, как я решил по ценностям Альфа, Гамма и Эпсилон. В приведенной выше программе он был в основном основан на интуиции от моего опыта и некоторого «хита и суда». Это проходит долгий путь, но есть и некоторые методы, чтобы придумать хорошие ценности. Процесс сам по себе иногда называют гиперпараметрической настройкой или оптимизацией гиперпараметра.
Тюнинг гиперпараметров
Простой способ программно придумать наилучший набор значений гиперпарамтера, состоит в том, чтобы создать всеобъемлющую функцию поиска, которая выбирает параметры, которые приведут к выполнению наилучшего агента. Более сложный способ получить правильное сочетание значений гиперпараметра было бы использовать генетические алгоритмы. Кроме того, это обычная практика, чтобы сделать эти параметры динамическими вместо фиксированных значений. Например, в нашем случае все три гиперпараметра могут быть сконфигурированы для уменьшения со временем, потому что когда агент продолжает изучать, он создает более устойчивые приоры.
Выбор правильных алгоритмов
Q-обучение – это всего лишь одно из множества алгоритмов обучения подкреплениями. Существуют несколько способов классификации алгоритмов обучения подкреплениями. Выбор зависит от различных факторов, включая природу окружающей среды. Например, если состояние пространства действия действия непрерывное вместо дискретизации (представьте, что среда теперь ожидает, что среда теперь ожидает, что некоторые значения степени вместо дискретных севера/Востока/и т. Д. Направления в качестве действий, а пространство государства состоит из более точного lat/long Такси вместо координат сетки), табличное Q-обучение невозможно работать. Существуют хаки, чтобы обойти непрерывные пространства (например, ведро их диапазона и делая его дискретизированным в результате), но эти хаки не удаются, если состояние пространства и пространства и действия состояния становится слишком большим. В этих случаях предпочтительно использовать более общие алгоритмы, как правило, те, которые включают приближения, такие как нейронные сети.
Чаще всего не на практике агент обучается с несколькими алгоритмами изначально, чтобы решить, какой алгоритм будет соответствовать лучшему.
Структура награды
Крайне важно, чтобы стратегически думать о наградах, которые будут переданы агенту. Если награды слишком редкие, агент может иметь трудности в обучении. Плохо структурированные награды также могут привести к случаям неконверженности и ситуаций, в которых агент застрял в местных минимах. Например, скажем, окружающая среда дала +1 награду за успешное забрание пассажира, а не наказание за пассажиру. Таким образом, агент может в конечном итоге неоднократно собирать и бросить пассажир, чтобы максимизировать свои награды. Точно так же, если бы была очень высокая негативная награда за подбор пассажиров, агент в конечном итоге научится вообще не выбирать пассажира, и, следовательно, никогда не закончится успешно.
Проблемы реальных сред
Обучение агенту в среде спортзала Openai, относительно легко, потому что вы получаете много вещей из коробки. Однако реальный мир немного более неорганизован. Мы используем датчики для приема экологической информации и переводят ее во что-то, что можно подавать в алгоритм машинного обучения. Таким образом, такие системы включают много техник в целом, кроме алгоритма обучения. В качестве простого примера рассмотрим генеральный агент для обучения подкреплением, чтобы играть в игры Atari. Информация, которую этот агент должен быть передан, – это пиксели на экране. Таким образом, нам, возможно, придется использовать методы глубокого обучения (например, сверточные нейронные сети) для интерпретации пикселей на экране и извлечь информацию из игры (например, оценки), чтобы включить агент для интерпретации игры.
Также есть проблема эффективности образца. Поскольку государственные пространства и пространства действия могут быть непрерывными и имеют большие диапазоны, становится важнейшим для достижения достойной эффективности образца, которая осуществляет обучение подкреплениями. Если алгоритм нуждается в большом количестве эпизодов (достаточно высоко, что мы не можем сделать его для того, чтобы произвести результаты в разумное количество времени), то обучение подкрепления становится непрактично.
Уважение теоретических границ
Легко иногда увлечься и увидеть усиление, чтобы быть решением большинства проблем. Это помогает иметь теоретическое понимание того, как эти алгоритмы работают и фундаментальные концепции, такие как Марковские решения процессов И осведомленность о состоянии арт-алгоритмов, чтобы иметь лучшую интуицию о том, что может и что нельзя решить, используя современные алгоритмы укрепления укрепления.
Упаковка
В этом руководстве мы начали с понимания укрепления обучения с помощью реальных мировых аналогов. Затем мы узнали о некоторых фундаментальных концепциях, таких как государство, действие и награды. Далее мы перешли по процессу оформления проблемы, так что мы можем тренировать агента с помощью алгоритмов обучения подкреплениями для ее решения.
Мы взяли на себя самостоятельные такси как нашу справочную проблему для остальной части учебника. Затем мы использовали модуль спортзала Openal в Python, чтобы предоставить нам связанную среду для развития нашего агента и оценить его. Затем мы заметили, насколько ужасна наш агент не использовал ни одного алгоритма, чтобы играть в игру, поэтому мы пошли дальше реализовать алгоритм Q-обучения с нуля.
Затем мы представили Q-обучение и пошли на шаги, чтобы использовать его для нашей среды. Мы придумали два подхода (кооперативные и конкурентоспособные). Затем мы оценили результаты Q-обучения и увидели, как производительность агента значительно улучшилась после изучения Q-обучения.
Как упоминалось в начале, обучение подкреплениями не просто ограничено средами и игрм и играми Openai. Он также используется для управления портфелем и финансами, для изготовления роботов гуманоида, для производства и управления инвентаризацией, для разработки генеральных агентов AI (агенты, которые могут выполнять несколько вещей с одним алгоритмом, как тот же агент, играющий несколько игр ATARI).
Приложение
дальнейшее чтение
- «Укрепление обучения: введение» Книга Андрея Барто и Ричарда С. Суттона. Самая популярная книга о укреплении обучения там. Настоятельно рекомендуется, если вы планируете погружаться в поле в поле.
- Лекции Дэвидом Серебро (также доступно на YouTube ). Еще один отличный ресурс, если вы больше учатся в изучении видео, чем книги.
- Учебное пособие по среднему По укреплению обучения с использованием Tensorflow от Arthur Juliani.
- Некоторые интересные темы, связанные с мультигагентными средами,
- Друг и вражда Q-обучение в играх общего суммы
- Концепции теории игры, как
- Строго доминирующие стратегии
- равновесие по Нэшу
- Образные значения для распределения вознаграждения
Визуализация переходной таблицы нашей двойной среды такси
Ниже приведена попытка визуализации внутреннего переходной таблицы нашей среды в читаемом человеке. Источник этой информации является env. P объект, который содержит отображение формы
teake_state: action_taken: [(transing_prob, next_state, вознаграждение, сделано)] Это все, что нам нужно имитировать среду, и это то, что мы можем использовать для создания таблицы перехода.
env.P # First, let's take a peek at this object
{0: {
0: [(1.0, 0, -30, False)],
1: [(1.0, 1536, -0.5, True)],
2: [(1.0, 1560, -0.5, True)],
3: [(1.0, 1536, -0.5, True)],
4: [(1.0, 1536, -0.5, True)],
5: [(1.0, 1536, -0.5, True)],
6: [(1.0, 96, -0.5, True)],
7: [(1.0, 0, -30, False)],
8: [(1.0, 24, -0.5, True)],
9: [(1.0, 0, -30, False)],
10: [(1.0, 0, -30, False)],
11: [(1.0, 0, -30, False)],
12: [(1.0, 480, -0.5, True)],
13: [(1.0, 384, -0.5, True)],
14: [(1.0, 0, -30, False)],
15: [(1.0, 384, -0.5, True)],
16: [(1.0, 384, -0.5, True)],
17: [(1.0, 384, -0.5, True)],
18: [(1.0, 96, -0.5, True)],
19: [(1.0, 0, -30, False)],
20: [(1.0, 24, -0.5, True)],
21: [(1.0, 0, -30, False)],
22: [(1.0, 0, -30, False)],
23: [(1.0, 0, -30, False)],
24: [(1.0, 96, -0.5, True)],
25: [(1.0, 0, -30, False)],
26: [(1.0, 24, -0.5, True)],
27: [(1.0, 0, -30, False)],
28: [(1.0, 0, -30, False)],
29: [(1.0, 0, -30, False)],
30: [(1.0, 96, -0.5, True)],
31: [(1.0, 0, -30, False)],
32: [(1.0, 24, -0.5, True)],
33: [(1.0, 0, -30, False)],
34: [(1.0, 0, -30, False)],
35: [(1.0, 0, -30, False)]},
1: {0: [(1.0, 1, -30, False)],
1: [(1.0, 1537, -0.5, True)],
2: [(1.0, 1561, -0.5, True)],
3: [(1.0, 1537, -0.5, True)],
4: [(1.0, 1537, -0.5, True)],
5: [(1.0, 1537, -0.5, True)],
6: [(1.0, 97, -0.5, True)],
7: [(1.0, 1, -30, False)],
8: [(1.0, 25, -0.5, True)],
9: [(1.0, 1, -30, False)],
10: [(1.0, 1, -30, False)],
11: [(1.0, 1, -30, False)],
12: [(1.0, 481, -0.5, True)],
13: [(1.0, 385, -0.5, True)],
14: [(1.0, 1, -30, False)],
15: [(1.0, 385, -0.5, True)],
16: [(1.0, 385, -0.5, True)],
17: [(1.0, 385, -0.5, True)],
18: [(1.0, 97, -0.5, True)],
19: [(1.0, 1, -30, False)],
20: [(1.0, 25, -0.5, True)],
21: [(1.0, 1, -30, False)],
22: [(1.0, 1, -30, False)],
23: [(1.0, 1, -30, False)],
24: [(1.0, 97, -0.5, True)],
25: [(1.0, 1, -30, False)],
26: [(1.0, 25, -0.5, True)],
27: [(1.0, 1, -30, False)],
28: [(1.0, 1, -30, False)],
29: [(1.0, 1, -30, False)],
30: [(1.0, 97, -0.5, True)],
31: [(1.0, 1, -30, False)],
32: [(1.0, 25, -0.5, True)],
33: [(1.0, 1, -30, False)],
34: [(1.0, 1, -30, False)],
35: [(1.0, 1, -30, False)]},
# omitting the whole output because it's very long!
Теперь давайте поставьте некоторый код вместе, чтобы преобразовать эту информацию в более читаемую табличную форму.
! pip install pandas
import pandas as pd
table = []
env_c = gym.make('DualTaxi-v1', competitive=True)
def state_to_human_readable(s):
passenger_loc = ['R', 'G', 'B', 'Y', 'T1', 'T2'][s[2]]
destination = ['R', 'G', 'B', 'Y'][s[3]]
return f'Taxi 1: {s[0]}, Taxi 2: {s[1]}, Pass: {passenger_loc}, Dest: {destination}'
def action_to_human_readable(a):
actions = 'NSEWPD'
return actions[a[0]], actions[a[1]]
for state_num, transition_info in env_c.P.items():
for action, possible_transitions in transition_info.items():
transition_prob, next_state, reward, done = possible_transitions[0]
table.append({
'State': state_to_human_readable(list(env.decode(state_num))),
'Action': action_to_human_readable(env.decode_action(action)),
'Probablity': transition_prob,
'Next State': state_to_human_readable(list(env.decode(next_state))),
'Reward': reward,
'Is over': done,
})
pd.DataFrame(table)
| Такси 1: (0, 0), Такси 2: (0, 0), Pass: R, DEST: R | (N, n) | (-15, -15) | Ложь | Такси 1: (0, 0), Такси 2: (0, 0), Pass: R, DEST: R | 1.0 | 0 |
| Такси 1: (0, 0), Такси 2: (0, 0), Pass: R, DEST: R | (N, s) | (-0.5, 0) | Истинный | Такси 1: (1, 0), такси 2: (0, 0), Pass: R, DEST: R | 1.0 | 1 |
| Такси 1: (0, 0), Такси 2: (0, 0), Pass: R, DEST: R | (N, e) | (-0.5, 0) | Истинный | Такси 1: (1, 0), такси 2: (0, 1), Pass: R, DEST: R | 1.0 | 2 |
| Такси 1: (0, 0), Такси 2: (0, 0), Pass: R, DEST: R | (N, w) | (-0.5, 0) | Истинный | Такси 1: (1, 0), такси 2: (0, 0), Pass: R, DEST: R | 1.0 | 3 |
| Такси 1: (0, 0), Такси 2: (0, 0), Pass: R, DEST: R | (N, p) | (-0.5, 0) | Истинный | Такси 1: (1, 0), такси 2: (0, 0), Pass: R, DEST: R | 1.0 | 4 |
| … | … | … | … | … | … | … |
| Такси 1: (3, 3), такси 2: (3, 3), Pass: T2, DEST: Y | (D, S) | (-0.5, 0) | Истинный | Такси 1: (3, 3), такси 2: (2, 3), Pass: T2, DEST: Y | 1.0 | 221179 |
| Такси 1: (3, 3), такси 2: (3, 3), Pass: T2, DEST: Y | (D, E) | (-15, -15) | Ложь | Такси 1: (3, 3), такси 2: (3, 3), Pass: T2, DEST: Y | 1.0 | 221180 |
| Такси 1: (3, 3), такси 2: (3, 3), Pass: T2, DEST: Y | (D, W) | (-0.5, 0) | Истинный | Такси 1: (3, 3), такси 2: (3, 2), Pass: T2, DEST: Y | 1.0 | 221181 |
| Такси 1: (3, 3), такси 2: (3, 3), Pass: T2, DEST: Y | (D, P) | (-15, -15) | Ложь | Такси 1: (3, 3), такси 2: (3, 3), Pass: T2, DEST: Y | 1.0 | 221182 |
| Такси 1: (3, 3), такси 2: (3, 3), Pass: T2, DEST: Y | (D, D) | (-15, -15) | Ложь | Такси 1: (3, 3), такси 2: (3, 3), Pass: T2, DEST: Y | 1.0 | 221183 |
221184 строки × 6 столбцов
Придурок
При ретроспективе самая трудная часть написания этого поста должна была получить работу с двойной такси. Там было так много моментов, как внизу,
Это потребовалось много испытаний и ошибок (настраивание награды, обновление правил для ситуаций, таких как столкновение, сокращение пространства состояния), чтобы добраться до стадии, где были сходятся решения для конкурентных настроек. Чувство, когда решение сходится в первый раз, очень круто. Так что, если у вас есть какое-то свободное время, я бы порекомендовал вам взломать среду самостоятельно (в первый раз, когда я попробовал Q-обучение, был с игрой Snake-Apple, я разработал, используя PyGame) и попытаться решить ее с учетом армирования. Поверь мне, вы будете смирены и узнать много интересных вещей по пути!
Оригинал: “https://dev.to/satwikkansal/a-gentle-introduction-to-reinforcement-learning-75h”