Понимание Q-Learning в действии и на примере

Добро пожаловать в мою серию статей об обучении с подкреплением! Теперь, когда мы рассмотрели строительные блоки, пришло время обсудить TD (λ) и Q-обучение.

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

  • Что такое TD (λ) и как он используется?
  • Как работает классический внеполитический метод Q-Learning?
  • Как выглядит реализация Q-обучения в Python?

Если вы новичок в этой серии, обязательно сначала ознакомьтесь со следующими публикациями:

Часть 1: Краткое введение в RL

Часть 2: Знакомство с марковским процессом

Часть 3: Марковский процесс принятия решений (MDP)

Часть 4: Поиск оптимальной политики с MDP

Часть 5: Монте-Карло и изучение временной разницы

Приступим к Q-обучению!

Обучение временной разнице: TD (λ)

В моем последнем посте мы упоминали, что если мы заменим Gt в формуле, обновленной MC, предполагаемой доходностью Rt + 1 + V (St + 1 ), мы можем получить TD (0):

Где:

  • Rt + 1 + V (St + 1) называется целевым значением TD.
  • Rt + 1 + V (St + 1) - V (St） называется ошибкой TD.

Теперь мы заменяем целевое значение TD на Gt (), мы можем получить TD (λ). Gt () создается следующим образом:

Итак, формула TD (λ):

В котором:

Как уже говорилось, Q-обучение представляет собой комбинацию обучения по методу Монте-Карло (MC) и временной разнице (TD). Теперь, когда у нас за плечами MC и TD (0), описанные в Части 5 и TD (λ), мы, наконец, готовы вытащить большие пушки!

Q-Learning

Формула Q-Value:

Из вышесказанного мы видим, что Q-обучение напрямую происходит от TD (0). Для каждого обновленного шага Q-Learning использует жадный метод: maxaQ (St + 1, a).

В этом основное отличие Q-обучения от другого метода, основанного на TD, под названием Sarsa, который я не буду объяснять в этой серии. Но как изучающий RL вы должны знать, что Q-обучение - не единственный метод, основанный на TD.

Пример того, как работает Q-Learning

Попробуем лучше понять это на примере:

Вы ужинаете с друзьями в итальянском ресторане, и, поскольку вы бывали здесь один или два раза раньше, они хотят, чтобы вы сделали заказ. По опыту вы знаете, что пицца Маргарита и паста Болоньезе восхитительны. Итак, если вам нужно заказать десять блюд, опыт может подсказать вам, что нужно заказывать по пять из каждого. Но как насчет всего остального в меню?

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

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

Здесь в игру вступает ε-жадность.

Политика ε-жадных исследований

В приведенном выше примере то, что произошло в ресторане, похоже на наш MDP (Марковский процесс принятия решений), и вы, как наш агент, сможете найти лучшую комбинацию блюд для своей вечеринки, только если вы изучите ее достаточно тщательно.

Так и с Q-Learning: он может работать, только если агент достаточно тщательно исследует MDP. Конечно, это займет очень много времени. Представляете, сколько раз вам придется возвращаться в ресторан, чтобы попробовать каждое блюдо из меню в каждой комбинации?

Вот почему Q-Learning использует ε-жадную политику, которая является «жадной» по ε степени для самых высоких значений Q и 1 - ε степенью «жадной» для случайного исследования. .

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

Таким образом, обычно начинают с большого значения ε, например 1,0. Это означает, что агент будет тратить 100% своего времени на изучение (например, с использованием случайной политики) вместо обращения к Q-таблице.

Отсюда значение ε можно постепенно уменьшать, делая агента более жадным для значений Q. Например, если мы снизим ε до 0,9, это означает, что агент будет тратить 90% своего времени на выбор лучшей стратегии на основе Q-таблицы и 10% своего времени на изучение неизвестного.

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

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

Реализация Q-Learning на Python

Вот как можно реализовать Q-обучение:

import numpy as np
# Q
q = np.matrix(np.zeros([6, 6]))
# Reward
r = np.matrix([[-1, -1, -1, -1,  0,  -1],
[-1, -1, -1,  0, -1, 100],
[-1, -1, -1,  0, -1,  -1],
[-1,  0,  0, -1,  0,  -1],
[ 0, -1, -1,  0, -1, 100],
[-1,  0, -1, -1,  0, 100]])
gamma = 0.8
epsilon = 0.4
# the main training loop
for episode in range(101):
# random initial state
state = np.random.randint(0, 6)
# if not final state
while (state != 5):
# choose a possible action
# Even in random case, we cannot choose actions whose r[state, action] = -1.
possible_actions = []
possible_q = []
for action in range(6):
if r[state, action] >= 0:
possible_actions.append(action)
possible_q.append(q[state, action])
# Step next state, here we use epsilon-greedy algorithm.
action = -1
if np.random.random() < epsilon:
# choose random action
action = possible_actions[np.random.randint(0, len(possible_actions))]
else:
# greedy
action = possible_actions[np.argmax(possible_q)]
# Update Q value
q[state, action] = r[state, action] + gamma * q[action].max()
# Go to the next state
state = action
# Display training progress
if episode % 10 == 0:
print("------------------------------------------------")
print("Training episode: %d" % episode)
print(q)

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

Примечание. Приведенный выше код взят из https://blog.csdn.net/zjm750617105/article/details/80295267

В итоге

Q-Learning - это алгоритм вне политики, основанный на методе TD. Со временем он создает Q-таблицу, которая используется для выработки оптимальной политики. Чтобы изучить эту политику, агент должен изучить. Обычный способ сделать это - заставить агента следовать другой случайной политике, которая изначально игнорирует Q-таблицу при выборе действий.

На сегодня все. Ты сделал это! Этой статьей мы завершили обсуждение TD, и я надеюсь, что вы получили базовые знания о:

  • Обучение временной разнице: целевое значение TD, ошибка TD и TD (y)
  • Реализация Q-обучения на Python
  • Политика исследования Q-Learning с помощью ε-greedy

TD и Q-обучение очень важны в RL, потому что на их основе происходит множество оптимизированных методов. Есть Double Q-Learning, Deep Q-Learning и так далее.

Кроме того, есть и другие методы, совершенно отличные от TD и Q-обучения, которые мы еще не затрагивали в этой серии, например Policy Gradient (PG).

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

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

Вопросы или мысли добавить? Буду рад услышать от вас в комментариях!

Подпишитесь на меня, чтобы увидеть мою следующую запись.