Путешествие к обучению с подкреплением продолжается… Пришло время проанализировать печально известное Q-обучение и посмотреть, как оно стало новым стандартом в области ИИ (с небольшой помощью нейронных сетей).

Перво-наперво. В последнем посте мы увидели основную концепцию обучения с подкреплением и сформулировали проблему, используя агента, среду, состояние (S), действие (A) и вознаграждение (R). Мы говорили о том, как весь процесс можно описать как марковский процесс принятия решений, и ввели термины «политика» и «ценность». Наконец, у нас был краткий общий обзор основных методов.

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

И вот мы добрались до нового материала. На самом деле сегодня используются две функции стоимости. Функция значения состояния V(s) и функция значения действия Q(s, a) .

• Функция значения состояния: достигается ли ожидаемая отдача при действиях из состояния в соответствии с политикой.

• Функция значения действия: ожидаемый доход с учетом состояния и действия.

В чем разница, спросите вы? Первое значение — это значение конкретного состояния. Второй — это значение этого состояния плюс значения всех возможных действий из этого состояния.

Когда у нас есть функция значения действия, значение Q, мы можем просто выбрать выполнение действия с наивысшим значением из состояния. Но как нам найти значение Q?

Что такое Q обучение?

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

Спасибо, Ричард Э. Беллманн. Приведенное выше уравнение известно как уравнение Беллмана и играет огромную роль в современных исследованиях RL. Но что в нем говорится?

Значение Q, также известное как максимальная будущая награда за состояние и действие, представляет собой немедленную награду плюс максимальную будущую награду за следующее состояние. И если подумать, то в этом есть смысл. Гамма (γ) — это число между (0,1) и он используется для дисконтирования вознаграждения по прошествии времени, учитывая предположение, что действия в начале важнее, чем в конце (предположение, которое подтверждается многими примерами использования в реальной жизни). В результате мы можем обновить значение Q итеративно.

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

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

env = gym.make('MountainCar-v0')
Q = np.zeros((env.observation_space.n,env.action_space.n))
for i in range(episodes):
    s = env.reset()
    reward = 0
    goal_flag = False
    for j in range(200):
        a = np.argmax(Q(s,:) + np.random.randn(1,env.action_space.n)*(1./(i+1)))
        s_new,r,goal_flag,_ = env.step(a)
        maxQ=np.max(Q(s_new,:))
        Q(s,a) += lr*(r + g*maxQ - Q(s,a))
        reward += r
        s = s_new
        if goal_flag == True:
            break

Разведка против эксплуатации

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

Зачем углубляться?

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

Что, если мы аппроксимируем значения Q, используя некоторую модель машинного обучения. Что, если мы аппроксимируем их с помощью нейронных сетей? Эта простая идея (и, конечно, исполнение) была причиной Приобретение DeepMind от Google за 500 миллионов долларов. DeepMind предложила алгоритм под названием Deep Q Learner и использовала его для играть в Атари игры с безупречным мастерством.

Глубокое Q-обучение

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

freecodecamp.org

Думаю, пора применить все это на практике и научить агента играть
Горный автомобиль. Цель состоит в том, чтобы заставить машину ехать в гору. Двигатель автомобиля недостаточно силен, чтобы подняться в гору за один проход. Таким образом, единственный способ добиться успеха — это ездить туда-сюда, чтобы набрать обороты.

Я объясню больше о Deep Q Networks вместе с кодом. Сначала мы должны построить нашего агента как нейронную сеть с 3 плотными слоями, и мы собираемся обучить его с помощью оптимизации Адама.

class DQNAgent:
    def __init__(self, state_size, action_size):
        self.state_size = state_size
        self.action_size = action_size
        self.memory = deque(maxlen=2000)
        self.gamma = 0.95    
        self.epsilon = 1.0  
        self.epsilon_min = 0.01
        self.epsilon_decay = 0.995
        self.learning_rate = 0.001
        self.model = self._build_model()
    def _build_model(self):
        model = Sequential()
        model.add(Dense(24, input_dim=self.state_size, activation='relu'))
        model.add(Dense(24, activation='relu'))
        model.add(Dense(self.action_size, activation='linear'))
        model.compile(loss='mse',
                      optimizer=Adam(lr=self.learning_rate))
        return model
    def remember(self, state, action, reward, next_state, done):
        self.memory.append((state, action, reward, next_state, done))
    def act(self, state):
        if np.random.rand() <= self.epsilon:
            return random.randrange(self.action_size)
        act_values = self.model.predict(state)
        return np.argmax(act_values(0))

Ключевые моменты:

• Агент хранит буфер памяти со всем прошлым опытом.

• Его следующее действие определяется максимальным выходом (значением добротности) сети.

• Функция потерь представляет собой среднеквадратичную ошибку предсказанного значения Q и целевого значения Q.

• Из уравнения Беллмана получаем, что целью является R + g*макс(Q).

• Разница между целевым значением и прогнозируемым значением называется ошибкой временной разницы (ошибкой TD).

Прежде чем мы обучим наш DQN, нам нужно решить проблему, которая играет жизненно важную роль в том, как агент учится оценивать значения Q, а именно:

Повтор опыта

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

def replay(self, batch_size):
        minibatch = random.sample(self.memory, batch_size)
        for state, action, reward, next_state, done in minibatch:
            target = reward
            if not done:
                Q_next=self.model.predict(next_state)(0)
                target = (reward + self.gamma *np.amax(Q_next))
            target_f = self.model.predict(state)
            target_f(0)(action) = target
            self.model.fit(state, target_f, epochs=1, verbose=0)

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

env = gym.make('MountainCar-v0')
state_size = env.observation_space.shape(0)
action_size = env.action_space.n
agent = DQNAgent(state_size, action_size)
done = False
batch_size = 32
for e in range(EPISODES):
    state = env.reset()
    state = np.reshape(state, (1, state_size))
    for time in range(500):
        action = agent.act(state)
        next_state, reward, done, _ = env.step(action)
        reward = reward if not done else -10
        next_state = np.reshape(next_state, (1, state_size))
        agent.remember(state, action, reward, next_state, done)
        state = next_state
        if done:
            print("episode: {}/{}, score: {}, e: {:.2}"
                  .format(e, EPISODES, time, agent.epsilon))
            break
    if len(agent.memory) > batch_size:
        agent.replay(batch_size)

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

Вы только что создали агента, который учится водить машину в гору. Потрясающий. И что еще более удивительно, тот же самый код (я имею в виду копирование и вставку) можно использовать во многих других играх, от Atari и Super Mario до Doom (!!!)

Потрясающий!

Просто на больше времени, я обещаю.

Потрясающий!

Если вам нужен дополнительный материал, я не могу порекомендовать достаточно Продвинутый ИИ: курс глубокого обучения на Python на Удеми. Он охватывает все, что вам нужно для Deep Q Learning, и многое другое.

В следующем эпизоде ​​мы останемся в области Deep Q Learning и обсудим некоторые более продвинутые методы, такие как двойные сети DQN, дуэльные DQN и воспроизведение приоритетного опыта.

До скорой встречи…

Книга «Глубокое обучение в производстве» 📖

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

Узнать больше

* Раскрытие информации: Обратите внимание, что некоторые из приведенных выше ссылок могут быть партнерскими ссылками, и без дополнительной оплаты для вас мы будем получать комиссию, если вы решите совершить покупку после перехода по ссылке.