4 – Por Reforco
4.1 – Fundamentos Por Reforco
4.1.3 – Politica – Policy

LEGENDA

Principal

Ramo

Metodo

Problemas

Modelo

Arquitetura

Aprendizado por reforço: política (policy)

A política é o cérebro do agente. Ela define qual ação tomar em cada estado. Podemos pensar nela como uma estratégia ou um mapa. Sem uma política, o agente age aleatoriamente. Portanto, aprender uma boa política é o objetivo principal. A política pode ser determinística ou estocástica.

Tipos de política e sua representação

Uma política determinística mapeia cada estado a uma única ação. Escrevemos isso como \( a = \pi(s) \). Por exemplo, em um labirinto, sempre vá para a direita. Uma política estocástica, por outro lado, dá probabilidades para cada ação. Representamos isso como \( \pi(a|s) = P(A_t = a | S_t = s) \). Essa abordagem é útil para explorar. Consequentemente, políticas estocásticas evitam ficar presas em mínimos locais.

A política pode ser armazenada como uma tabela. Em estados discretos, isso é simples. Porém, em espaços contínuos, usamos redes neurais. A rede recebe o estado e retorna ações. Essa arquitetura chama-se Policy Network. Os hiperparâmetros incluem o tamanho das camadas escondidas. Por exemplo, 64 ou 128 neurônios. A taxa de aprendizado α também é crucial. Além disso, usamos um parâmetro de entropia para incentivar exploração.

Como as políticas são aprendidas e avaliadas

O teorema do gradiente da política é fundamental. Ele permite atualizar a política diretamente. A cada passo, ajustamos π para aumentar o retorno esperado. A fórmula do gradiente é \( \nabla_\theta J(\theta) = \mathbb{E}_\pi \left[ \nabla_\theta \log \pi_\theta(a|s) \cdot G_t \right] \). Aqui θ são os parâmetros da política. Esse método é chamado de REINFORCE. Uma variante comum usa um baseline para reduzir variância. O baseline geralmente é a função valor V(s).

Outra abordagem é a comparação entre políticas. Dizemos que π é melhor que π’ se seu retorno esperado for maior. A equação de Bellman para políticas é \( V^\pi(s) = \sum_a \pi(a|s) \sum_{s’,r} p(s’,r|s,a) [r + \gamma V^\pi(s’)] \). Essa equação é resolvida por iteração de política. Primeiro, avaliamos a política atual. Depois, a melhoramos guloso. Esse processo se repete até a convergência.

Exemplo clássico: subindo a montanha (Mountain Car)

Um carro fraco tenta subir uma montanha íngreme. Ele não consegue ir direto ao topo. Primeiro, precisa ir para trás ganhar inércia. A cada passo, o agente acelera para esquerda, direita ou neutro. A recompensa é -1 por cada passo até o topo. O estado é a posição e velocidade. O objetivo é aprender uma política que minimize os passos. O código abaixo implementa esse problema com gradiente de política.

import numpy as np
import matplotlib.pyplot as plt
import gym
from collections import deque

# Cria ambiente MountainCar
env = gym.make('MountainCar-v0')
print(f"Espaço de estados: {env.observation_space}")
print(f"Espaço de ações: {env.action_space}")

# Hiperparâmetros
num_episodios = 500
taxa_aprendizado = 0.001
gamma = 0.99
entropia_beta = 0.01

# Inicializa pesos da política (estado tem 2 dimensões, 3 ações)
W = np.random.randn(2, 3) * 0.01

def politica(estado, W):
    """Política linear softmax"""
    logits = np.dot(estado, W)
    exp_logits = np.exp(logits - np.max(logits))
    return exp_logits / np.sum(exp_logits)

def escolher_acao(estado, W):
    probs = politica(estado, W)
    return np.random.choice(3, p=probs)

def gradiente_log_politica(estado, acao, W):
    probs = politica(estado, W)
    grad = np.zeros_like(W)
    for a in range(3):
        grad[:, a] = estado * (1 if a == acao else 0) - estado * probs[a]
    return grad

recompensas_por_episodio = []
passos_por_episodio = []

for ep in range(num_episodios):
    estado = env.reset()[0]
    trajetoria_estados = []
    trajetoria_acoes = []
    trajetoria_recompensas = []
    feito = False
    passos = 0
    
    while not feito and passos < 1000:
        acao = escolher_acao(estado, W)
        prox_estado, recompensa, feito, _, _ = env.step(acao)
        
        trajetoria_estados.append(estado)
        trajetoria_acoes.append(acao)
        trajetoria_recompensas.append(recompensa)
        
        estado = prox_estado
        passos += 1
    
    passos_por_episodio.append(passos)
    recompensas_por_episodio.append(sum(trajetoria_recompensas))
    
    # Calcula retornos G_t
    retornos = []
    G = 0
    for r in reversed(trajetoria_recompensas):
        G = r + gamma * G
        retornos.insert(0, G)
    retornos = np.array(retornos)
    
    # Normaliza retornos para estabilidade
    if len(retornos) > 1:
        retornos = (retornos - np.mean(retornos)) / (np.std(retornos) + 1e-8)
    
    # Atualiza política com REINFORCE
    grad_total = np.zeros_like(W)
    for t in range(len(trajetoria_estados)):
        grad = gradiente_log_politica(trajetoria_estados[t], trajetoria_acoes[t], W)
        grad_total += grad * retornos[t]
    
    W += taxa_aprendizado * grad_total

# Gráfico 1: Evolução dos passos por episódio
plt.figure(figsize=(12,4))
plt.subplot(1,2,1)
plt.plot(passos_por_episodio, alpha=0.7)
media_movel = np.convolve(passos_por_episodio, np.ones(20)/20, mode='valid')
plt.plot(range(19, num_episodios), media_movel, 'r', linewidth=2, label='Média móvel 20')
plt.xlabel('Episódio')
plt.ylabel('Passos até o topo')
plt.title('Aprendizado da política (MountainCar)')
plt.legend()
plt.grid(True)

# Gráfico 2: Probabilidades da política final para cada estado
estados_teste = np.linspace(-1.2, 0.6, 50)
velocidades_teste = np.linspace(-0.07, 0.07, 50)
X, Y = np.meshgrid(estados_teste, velocidades_teste)
Z_esquerda = np.zeros_like(X)
Z_direita = np.zeros_like(X)

for i in range(len(estados_teste)):
    for j in range(len(velocidades_teste)):
        estado = np.array([estados_teste[i], velocidades_teste[j]])
        probs = politica(estado, W)
        Z_esquerda[j,i] = probs[0]  # ação esquerda
        Z_direita[j,i] = probs[2]   # ação direita

plt.subplot(1,2,2)
plt.contourf(X, Y, Z_direita - Z_esquerda, levels=20, cmap='RdBu')
plt.colorbar(label='Preferência por direita - esquerda')
plt.xlabel('Posição')
plt.ylabel('Velocidade')
plt.title('Política final aprendida')
plt.tight_layout()
plt.show()

print(f"Melhor episódio: {min(passos_por_episodio)} passos")
print(f"Média dos últimos 100 episódios: {np.mean(passos_por_episodio[-100:]):.1f} passos")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

import numpy as np

import matplotlib.pyplot as plt

import gym

from collections import deque

# Cria ambiente MountainCar

env = gym.make('MountainCar-v0')

print(f"Espaço de estados: {env.observation_space}")

print(f"Espaço de ações: {env.action_space}")

# Hiperparâmetros

num_episodios = 500

taxa_aprendizado = 0.001

gamma = 0.99

entropia_beta = 0.01

# Inicializa pesos da política (estado tem 2 dimensões, 3 ações)

W = np.random.randn(2, 3) * 0.01

def politica(estado, W):

"""Política linear softmax"""

logits = np.dot(estado, W)

exp_logits = np.exp(logits - np.max(logits))

return exp_logits / np.sum(exp_logits)

def escolher_acao(estado, W):

probs = politica(estado, W)

return np.random.choice(3, p=probs)

def gradiente_log_politica(estado, acao, W):

probs = politica(estado, W)

grad = np.zeros_like(W)

for a in range(3):

grad[:, a] = estado * (1 if a == acao else 0) - estado * probs[a]

return grad

recompensas_por_episodio = []

passos_por_episodio = []

for ep in range(num_episodios):

estado = env.reset()[0]

trajetoria_estados = []

trajetoria_acoes = []

trajetoria_recompensas = []

feito = False

passos = 0

while not feito and passos < 1000:

acao = escolher_acao(estado, W)

prox_estado, recompensa, feito, _, _ = env.step(acao)

trajetoria_estados.append(estado)

trajetoria_acoes.append(acao)

trajetoria_recompensas.append(recompensa)

estado = prox_estado

passos += 1

passos_por_episodio.append(passos)

recompensas_por_episodio.append(sum(trajetoria_recompensas))

# Calcula retornos G_t

retornos = []

G = 0

for r in reversed(trajetoria_recompensas):

G = r + gamma * G

retornos.insert(0, G)

retornos = np.array(retornos)

# Normaliza retornos para estabilidade

if len(retornos) > 1:

retornos = (retornos - np.mean(retornos)) / (np.std(retornos) + 1e-8)

# Atualiza política com REINFORCE

grad_total = np.zeros_like(W)

for t in range(len(trajetoria_estados)):

grad = gradiente_log_politica(trajetoria_estados[t], trajetoria_acoes[t], W)

grad_total += grad * retornos[t]

W += taxa_aprendizado * grad_total

# Gráfico 1: Evolução dos passos por episódio

plt.figure(figsize=(12,4))

plt.subplot(1,2,1)

plt.plot(passos_por_episodio, alpha=0.7)

media_movel = np.convolve(passos_por_episodio, np.ones(20)/20, mode='valid')

plt.plot(range(19, num_episodios), media_movel, 'r', linewidth=2, label='Média móvel 20')

plt.xlabel('Episódio')

plt.ylabel('Passos até o topo')

plt.title('Aprendizado da política (MountainCar)')

plt.legend()

plt.grid(True)

# Gráfico 2: Probabilidades da política final para cada estado

estados_teste = np.linspace(-1.2, 0.6, 50)

velocidades_teste = np.linspace(-0.07, 0.07, 50)

X, Y = np.meshgrid(estados_teste, velocidades_teste)

Z_esquerda = np.zeros_like(X)

Z_direita = np.zeros_like(X)

for i in range(len(estados_teste)):

for j in range(len(velocidades_teste)):

estado = np.array([estados_teste[i], velocidades_teste[j]])

probs = politica(estado, W)

Z_esquerda[j,i] = probs[0] # ação esquerda

Z_direita[j,i] = probs[2] # ação direita

plt.subplot(1,2,2)

plt.contourf(X, Y, Z_direita - Z_esquerda, levels=20, cmap='RdBu')

plt.colorbar(label='Preferência por direita - esquerda')

plt.xlabel('Posição')

plt.ylabel('Velocidade')

plt.title('Política final aprendida')

plt.tight_layout()

plt.show()

print(f"Melhor episódio: {min(passos_por_episodio)} passos")

print(f"Média dos últimos 100 episódios: {np.mean(passos_por_episodio[-100:]):.1f} passos")

O código implementa REINFORCE para o Mountain Car. O agente aprende uma política estocástica linear. Inicialmente, ele age aleatoriamente e demora muitos passos. Com o tempo, a política melhora e o carro sobe mais rápido. O segundo gráfico mostra a preferência da política final. Regiões em azul indicam tendência a acelerar para a direita. Este exemplo demonstra como políticas são aprendidas na prática.

4 – Por Reforco
4.1 – Fundamentos Por Reforco
4.1.2 – Recompensa e Retorno

LEGENDA

Principal

Ramo

Metodo

Problemas

Modelo

Arquitetura

Aprendizado por reforço: recompensa e retorno

No aprendizado por reforço, a recompensa é um sinal imediato. Ela indica se uma ação foi boa ou ruim. Por exemplo, ganhar um ponto em um jogo. O retorno, por outro lado, é a soma total das recompensas futuras. Ele considera não apenas o agora, mas também o amanhã. Portanto, o agente busca maximizar o retorno ao longo do tempo.

Definição formal de recompensa e retorno

A cada passo t, o agente recebe uma recompensa r_t. Essa recompensa é um número real. Ela pode ser positiva, negativa ou zero. O retorno G_t é definido como a soma das recompensas futuras. Frequentemente, usamos um fator de desconto γ. Assim, o retorno é escrito como \( G_t = r_{t+1} + \gamma r_{t+2} + \gamma^2 r_{t+3} + \dots = \sum_{k=0}^{\infty} \gamma^k r_{t+k+1} \). Esse fator γ está entre 0 e 1. Ele dá menos peso a recompensas distantes. Consequentemente, o agente prefere recompensas imediatas.

Uma escolha comum é γ = 0.9 ou 0.99. Valores altos incentivam planejamento de longo prazo. Valores baixos tornam o agente míope. O retorno também pode ser definido sem desconto. Nesse caso, γ = 1, mas isso exige episódios finitos. A recompensa é projetada pelo desenvolvedor. Ela guia o comportamento desejado. Por exemplo, em um jogo de xadrez, dar +1 por vitória e 0 por derrota.

Hiperparâmetros relacionados e arquitetura

Além de γ, a taxa de aprendizado α é crucial. Ela controla quão rápido o agente atualiza suas estimativas. A taxa de exploração ε também impacta o retorno. Explorar pode levar a descobrir recompensas maiores no futuro. Portanto, há um trade-off entre exploração e explotação. Redes neurais profundas aproximam a função de valor. Elas estimam o retorno esperado para cada estado ou ação. Essa arquitetura chama-se DQN (Deep Q-Network). Nela, a perda é calculada com base no erro do retorno previsto.

A equação de Bellman conecta retorno e recompensa. Para a função valor V(s), temos \( V(s) = \mathbb{E}[r + \gamma V(s’)] \). Para a função ação-valor Q(s,a), escrevemos \( Q(s,a) = \mathbb{E}[r + \gamma \max_{a’} Q(s’, a’)] \). O erro temporal (TD error) é a diferença entre o retorno estimado e o atual: \( \delta = r + \gamma \max_{a’} Q(s’, a’) – Q(s,a) \). Esse erro é usado para atualizar os parâmetros do modelo.

Exemplo clássico: o problema do bandido (k-armed bandit)

Suponha uma máquina caça-níqueis com 5 braços. Cada braço dá uma recompensa média diferente. O agente não conhece essas médias. Ele deve descobrir qual braço maximiza o retorno. Cada tentativa (ação) produz uma recompensa imediata. O objetivo é maximizar o retorno total após 1000 jogadas. O código abaixo resolve isso com uma estratégia ε-greedy. Ele também mostra gráficos da evolução do retorno médio.

import numpy as np
import matplotlib.pyplot as plt

# Configuração do problema: 5 braços
num_braços = 5
recompensas_reais = np.random.normal(0, 1, num_braços)
print(f"Recompensas reais de cada braço: {recompensas_reais}")

# Hiperparâmetros
epsilon = 0.1  # taxa de exploração
alpha = 0.1    # taxa de aprendizado (para média incremental)
episodios = 1000

# Inicialização
Q = np.zeros(num_braços)  # estimativa do retorno para cada braço
N = np.zeros(num_braços)  # número de vezes que cada braço foi puxado
recompensas_por_passos = []
acao_escolhida = []

def escolher_acao(epsilon, Q):
    if np.random.rand() < epsilon:
        return np.random.randint(len(Q))  # explora
    return np.argmax(Q)  # explota

# Loop principal
for passo in range(episodios):
    acao = escolher_acao(epsilon, Q)
    # Gera recompensa com distribuição normal + ruído
    recompensa = np.random.normal(recompensas_reais[acao], 1.0)
    
    N[acao] += 1
    # Atualização incremental da média (retorno estimado)
    Q[acao] = Q[acao] + alpha * (recompensa - Q[acao])
    
    recompensas_por_passos.append(recompensa)
    acao_escolhida.append(acao)

# Cálculo do retorno acumulado ao longo do tempo
retorno_acumulado = np.cumsum(recompensas_por_passos)
retorno_medio_por_passo = retorno_acumulado / (np.arange(episodios) + 1)

# Gráfico 1: Evolução do retorno médio por passo
plt.figure(figsize=(12,4))
plt.subplot(1,2,1)
plt.plot(retorno_medio_por_passo)
plt.xlabel('Passo')
plt.ylabel('Retorno médio acumulado')
plt.title('Aprendizado do retorno esperado')
plt.grid(True)
plt.axhline(y=max(recompensas_reais), color='r', linestyle='--', 
            label=f'Ótimo teórico = {max(recompensas_reais):.2f}')
plt.legend()

# Gráfico 2: Porcentagem de vezes que o melhor braço foi escolhido
melhor_braco = np.argmax(recompensas_reais)
escolheu_melhor = [1 if acao == melhor_braco else 0 for acao in acao_escolhida]
media_movel = np.convolve(escolheu_melhor, np.ones(50)/50, mode='valid')

plt.subplot(1,2,2)
plt.plot(media_movel)
plt.xlabel('Passo')
plt.ylabel('Frequência do melhor braço')
plt.title('Exploração vs. Explotação (janela 50)')
plt.ylim(0, 1)
plt.grid(True)
plt.tight_layout()
plt.show()

print(f"Após {episodios} passos, as estimativas Q são: {Q}")
print(f"O melhor braço real é o {melhor_braco} com recompensa {recompensas_reais[melhor_braco]:.2f}")
print(f"O agente escolheu o melhor braço em {np.mean(escolheu_melhor)*100:.1f}% das vezes")

import numpy as np

import matplotlib.pyplot as plt

# Configuração do problema: 5 braços

num_braços = 5

recompensas_reais = np.random.normal(0, 1, num_braços)

print(f"Recompensas reais de cada braço: {recompensas_reais}")

# Hiperparâmetros

epsilon = 0.1 # taxa de exploração

alpha = 0.1 # taxa de aprendizado (para média incremental)

episodios = 1000

# Inicialização

Q = np.zeros(num_braços) # estimativa do retorno para cada braço

N = np.zeros(num_braços) # número de vezes que cada braço foi puxado

recompensas_por_passos = []

acao_escolhida = []

def escolher_acao(epsilon, Q):

if np.random.rand() < epsilon:

return np.random.randint(len(Q)) # explora

return np.argmax(Q) # explota

# Loop principal

for passo in range(episodios):

acao = escolher_acao(epsilon, Q)

# Gera recompensa com distribuição normal + ruído

recompensa = np.random.normal(recompensas_reais[acao], 1.0)

N[acao] += 1

# Atualização incremental da média (retorno estimado)

Q[acao] = Q[acao] + alpha * (recompensa - Q[acao])

recompensas_por_passos.append(recompensa)

acao_escolhida.append(acao)

# Cálculo do retorno acumulado ao longo do tempo

retorno_acumulado = np.cumsum(recompensas_por_passos)

retorno_medio_por_passo = retorno_acumulado / (np.arange(episodios) + 1)

# Gráfico 1: Evolução do retorno médio por passo

plt.figure(figsize=(12,4))

plt.subplot(1,2,1)

plt.plot(retorno_medio_por_passo)

plt.xlabel('Passo')

plt.ylabel('Retorno médio acumulado')

plt.title('Aprendizado do retorno esperado')

plt.grid(True)

plt.axhline(y=max(recompensas_reais), color='r', linestyle='--',

label=f'Ótimo teórico = {max(recompensas_reais):.2f}')

plt.legend()

# Gráfico 2: Porcentagem de vezes que o melhor braço foi escolhido

melhor_braco = np.argmax(recompensas_reais)

escolheu_melhor = [1 if acao == melhor_braco else 0 for acao in acao_escolhida]

media_movel = np.convolve(escolheu_melhor, np.ones(50)/50, mode='valid')

plt.subplot(1,2,2)

plt.plot(media_movel)

plt.xlabel('Passo')

plt.ylabel('Frequência do melhor braço')

plt.title('Exploração vs. Explotação (janela 50)')

plt.ylim(0, 1)

plt.grid(True)

plt.tight_layout()

plt.show()

print(f"Após {episodios} passos, as estimativas Q são: {Q}")

print(f"O melhor braço real é o {melhor_braco} com recompensa {recompensas_reais[melhor_braco]:.2f}")

print(f"O agente escolheu o melhor braço em {np.mean(escolheu_melhor)*100:.1f}% das vezes")

O código simula um problema clássico de bandido. O agente aprende a estimar o retorno de cada ação. Com ε-greedy, ele explora braços desconhecidos. Gradualmente, o retorno médio se aproxima do ótimo. O segundo gráfico mostra a taxa de escolha do melhor braço. Esse exemplo ilustra perfeitamente os conceitos de recompensa e retorno.