Aprendizado Q profundo

O aprendizado Q profundo é uma extensão do aprendizado Q que usa uma rede neural para aproximar a tabela Q. Isso permite que o aprendizado por reforço seja escalável para ambientes com espaços de estados e ações grandes ou contínuos.

Por que usar o aprendizado Q profundo?

O aprendizado Q profundo resolve as limitações do aprendizado Q tradicional:

• Lida com espaços de estados de alta dimensionalidade, como imagens.
• Evita a necessidade de armazenar tabelas Q grandes na memória.
• Generaliza entre estados usando redes neurais.

O algoritmo DQN

O aprendizado Q profundo usa uma rede neural chamada rede Q para aproximar os valores Q. As principais etapas são:

1. Inicialize a rede Q com pesos aleatórios.
2. Interaja com o ambiente para coletar tuplas de experiência (state, action, reward, next_state).
3. Atualize a rede Q usando a equação de Bellman:

Q(s, a) ≈ r + γ max(Q(s', a'))

Construindo a rede Q

A rede Q é uma rede neural simples de propagação direta que recebe o estado atual como entrada e produz valores Q para todas as ações possíveis:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# Define the Q-Network
q_network = Sequential([
    Dense(24, activation='relu', input_shape=(state_space_size,)),
    Dense(24, activation='relu'),
    Dense(action_space_size, activation='linear')
])

q_network.compile(optimizer='adam', loss='mse')

Repetição de experiências

O aprendizado Q profundo usa uma técnica chamada repetição de experiências para melhorar o aprendizado:

• Armazene experiências (state, action, reward, next_state) em um buffer de memória.
• Amostre aleatoriamente lotes de experiências para treinar a rede Q.

from collections import deque

# Initialize replay memory
memory = deque(maxlen=2000)

# Add experience to memory
memory.append((state, action, reward, next_state, done))

Treinando a rede Q

Treinamos a rede Q usando as experiências do buffer de memória:

import numpy as np

# Sample a batch of experiences
batch_size = 32
batch = random.sample(memory, batch_size)

# Train the Q-Network
for state, action, reward, next_state, done in batch:
    target = reward
    if not done:
        target += gamma * np.max(q_network.predict(next_state[np.newaxis, ...]))
    q_values = q_network.predict(state[np.newaxis, ...])
    q_values[0][action] = target
    q_network.fit(state[np.newaxis, ...], q_values, epochs=1, verbose=0)

Redes-alvo

Para estabilizar o treinamento, DQN usa uma rede-alvo:

• Mantenha uma rede separada para calcular os valores Q-alvo.
• Copie periodicamente os pesos da rede Q para a rede-alvo.

Vantagens do aprendizado Q profundo

O aprendizado Q profundo oferece diversos benefícios:

• Lida com espaços de estados de alta dimensionalidade, como imagens.
• Generaliza entre estados usando redes neurais.
• Pode resolver tarefas complexas, como jogos de Atari e controle robótico.

Resumo e próximos passos

Nesta lição, nós:

• Exploramos os conceitos básicos do aprendizado Q profundo.
• Construímos uma rede Q para aproximar os valores Q.
• Discutimos a repetição de experiências e as redes-alvo para obter um treinamento estável.

Em seguida, exploraremos o OpenAI Gym e aplicaremos o aprendizado por reforço em ambientes simulados.