Нихиль Будума - Основы глубокого обучения

Когда дело доходит до выборки из таблицы, можно обратиться к sample_batch(self, batch_size) для случайной компоновки пакета:

class ExperienceReplayTable(object):

def __init__(self, table_size=5000):

self.states = []

self.actions = []

self.rewards = []

self.state_primes = []

self.discounted_returns = []

self.table_size = table_size

def add_episode(self, episode):

self.states += episode.states

self.actions += episode.actions

self.rewards += episode.rewards

self.discounted_returns += episode.discounted_returns

self.state_primes += episode.state_primes

self.purge_old_experiences()

def purge_old_experiences(self):

if len(self.states) > self.table_size:

self.states = self.states[-self.table_size:]

self.actions = self.actions[-self.table_size:]

self.rewards = self.rewards[-self.table_size:]

self.discounted_returns = self.discounted_returns[

— self.table_size:]

self.state_primes = self.state_primes[

— self.table_size:]

def sample_batch(self, batch_size):

s_t, action, reward, s_t_plus_1, terminal = [], [], [], [], []

rands = np.arange(len(self.states))

np.random.shuffle(rands)

rands = rands[: batch_size]

for r_i in rands:

s_t.append(self.states[r_i])

action.append(self.actions[r_i])

reward.append(self.rewards[r_i])

s_t_plus_1.append(self.state_primes[r_i])

terminal.append(self.discounted_returns[r_i])

return np.array(s_t), np.array(action),

np.array(reward), np.array(s_t_plus_1),

np.array(terminal)

Сведем всё воедино в основной функции, которая создаст среду OpenAI Gym для Breakout, выведет образец DQNAgent и заставит его взаимодействовать со средой и успешно обучаться игре в Breakout:

def main(argv):

# Configure Settings (Конфигурируем настройки)

run_index = 0

learn_start = 100

scale = 10

total_episodes = 500*scale

epsilon_stop = 250*scale

train_frequency = 4

target_frequency = 16

batch_size = 32

max_episode_length = 1000

render_start = total_episodes — 10

should_render = True

env = gym.make(‘Breakout-v0')

num_actions = env.action_space.n

solved = False

with tf.Session() as session:

agent = DQNAgent(session=session,

um_actions=num_actions)

session.run(tf.global_variables_initializer())

episode_rewards = []

batch_losses = []

replay_table = ExperienceReplayTable()

global_step_counter = 0

for i in tqdm.tqdm(range(total_episodes)):

frame = env.reset()

past_frames = [frame] * (agent.history_length-1)

state = agent.process_state_into_stacked_frames(

frame, past_frames, past_state=None)

episode_reward = 0.0

episode_history = EpisodeHistory()

epsilon_percentage = float(min(i/float(

epsilon_stop), 1.0))

for j in range(max_episode_length):

action = agent.predict_action(state,

epsilon_percentage)

if global_step_counter < learn_start:

action = random_action(agent.num_actions)

# print(action)

frame_prime, reward, terminal, _ = env.step(

action)

state_prime =

agent.process_state_into_stacked_frames(

frame_prime, past_frames,

past_state=state)

past_frames.append(frame_prime)

past_frames = past_frames[-4:]

if (render_start > 0 and (i >

render_start)

and should_render) or (solved and

should_render):

env.render()

episode_history.add_to_history(

state, action, reward, state_prime)

state = state_prime

episode_reward += reward

global_step_counter += 1

if j == (max_episode_length — 1):

terminal = True

if terminal:

episode_history.discounted_returns =

discount_rewards(

episode_history.rewards)

replay_table.add_episode(episode_history)

if global_step_counter > learn_start:

if global_step_counter %

train_frequency == 0:

s_t, action, reward, s_t_plus_1,

terminal = \

replay_table.sample_batch(

batch_size)

q_t_plus_1 = agent.target_q.eval(

{agent.target_s_t:

s_t_plus_1})

terminal = np.array(terminal) + 0.

max_q_t_plus_1 = np.max(q_t_plus_1,

axis=1)

target_q_t = (1. — terminal) * \

agent.gamma * max_q_t_plus_1 +

reward

_, q_t, loss = agent.session.run(

[agent.train_step, agent.q_t,

agent.loss], {

agent.target_q_t: target_q_t,

agent.action: action,

agent.s_t: s_t

})

if global_step_counter %

target_frequency == 0:

agent.update_target_q_weights()

episode_rewards.append(episode_reward)

break

if i % 50 == 0:

ave_reward = np.mean(episode_rewards[-100:])

print(ave_reward)

if ave_reward > 50.0:

solved = False

else:

solved = False

Мы обучаем DQNAgent на 1000 эпизодах и рассматриваем кривую обучения. Чтобы достичь на Atari результатов выше, чем у человека, обычно время обучения растягивается на несколько дней. Но общая восходящая тенденция в вознаграждениях проявляется быстро, что показано на рис. 9.7.

Рис. 9.7. Агент DQN показывает все более успешные результаты в Breakout во время обучения, усвоив хорошую функцию-значение, и действует все менее случайно благодаря ϵ-жадной нормализации

В 2013 году DQN прекрасно поработала над решением задач Atari, но имела ряд серьезных недостатков. Среди основных слабостей — слишком большое время обучения, неудачные результаты в определенных типах игр и необходимость повторного обучения для каждой новой задачи. Большинство исследований в области глубокого обучения с подкреплением в последние несколько лет было сосредоточено на устранении этих недостатков.

Помните предположение Маркова — что следующее состояние зависит только от предыдущего и действия агента? Решение Маркова при помощи DQN, при котором четыре последовательных кадра помещаются в стек как отдельный канал, просто обходит проблему и во многом напоминает инженерную уловку. Почему кадров четыре, а не десять? Этот искусственный гиперпараметр ограничивает обобщающую способность модели. Как работать с произвольными последовательностями взаимосвязанных данных? Можно воспользоваться тем, что мы узнали в главе 6о рекуррентных нейронных сетях, для моделирования последовательностей при помощи глубоких рекуррентных Q-сетей (DRQN).

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

DRQN даже расширили, включив нейронный механизм внимания, о чем говорится в работе Ивана Сорокина и коллег «Глубокие рекуррентные Q-сети с вниманием; DAQRN» 2015 года [106]. Поскольку DRQN работает с последовательностью данных, она может уделять внимание конкретным ее фрагментам. Такая способность концентрироваться на деталях и повышает эффективность, и обеспечивает интерпретируемость модели, создавая логическое обоснование для предпринимаемых действий.

DRQN оказалась лучше, чем DQN, в играх-«стрелялках» от первого лица, например DOOM [107], а также продемонстрировала лучшие результаты в некоторых играх Atari с длинными временными зависимостями, например Seaquest [108].

Продвинутый асинхронный агент-критик (Asynchronous advantage actor-critic , A3C) — новый подход к глубокому обучению с подкреплением, представленный в DeepMind 2016 года «Асинхронные методы глубокого обучения с подкреплением» [109]. Поговорим о том, что это и в чем его преимущества перед DQN.

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

A3C использует метод агента-критика [110]. Он заключается в обучении как функции ценностей V(s t) — критик, так и стратегии π ( s t ) — агент. В этой главе мы выделили два разных подхода: обучение ценности и обучение стратегии. В A3C сочетаются сильные стороны обоих: функция ценностей критика улучшает стратегию агента.