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.

Aprendizado por reforço: agente, ambiente, ação e estado

O aprendizado por reforço é um tipo de machine learning. Ele ensina um agente a tomar decisões. O agente aprende por tentativa e erro. Ele recebe recompensas ou punições. Esse método inspira-se na psicologia comportamental. Portanto, as pessoas usam muito este método em robótica e jogos.

Os quatro elementos fundamentais

Primeiramente, o agente é quem aprende e age. Ele observa o ambiente ao redor. O ambiente compreende tudo com que o agente interage. Por exemplo, uma ação representa uma escolha possível do agente. Mover para esquerda ou direita seria um exemplo disso. O estado descreve a situação atual. Consequentemente, a cada ação, o estado muda. Além disso, o ambiente fornece uma recompensa numérica. Assim, o objetivo do agente é maximizar a soma das recompensas. Dessa forma, o agente melhora continuamente seu comportamento.

Os pesquisadores modelam esses quatro elementos matematicamente. A política π define a estratégia do agente. Ela mapeia estados para ações. A função valor V(s) estima a recompensa futura. Os especialistas denotam isso frequentemente por \( V(s) = \mathbb{E} \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s \right] \). O fator γ é um hiperparâmetro entre 0 e 1. Ele desconta recompensas distantes. Portanto, valores baixos de γ priorizam ganhos imediatos.

Hiperparâmetros e arquitetura comum

A taxa de aprendizado α controla a velocidade de atualização. O fator de desconto γ foi mencionado antes. A taxa de exploração ε usa a estratégia ε-greedy. Em cada passo, o agente escolhe ação aleatória com probabilidade ε. Caso contrário, ele escolhe a melhor ação conhecida. Essa abordagem equilibra exploração e explotação. Os engenheiros usam redes neurais profundas frequentemente. Essas redes aproximam a função valor ou política. Essa arquitetura chama-se DQN (Deep Q-Network). Consequentemente, os profissionais resolvem problemas complexos com essa técnica.

A equação de Bellman ocupa lugar central no aprendizado. Nós a escrevemos como \( Q(s,a) = r + \gamma \max_{a’} Q(s’, a’) \). Aqui Q(s,a) é o valor de agir em um estado. O erro temporal (TD error) é calculado assim: \( \delta = r + \gamma \max_{a’} Q(s’, a’) – Q(s,a) \). A atualização do Q-valor segue a fórmula \( Q(s,a) \leftarrow Q(s,a) + \alpha \delta \). Essas fórmulas constituem a base de muitos algoritmos. Além disso, elas permitem aprendizado online eficiente.

Exemplo clássico: o labirinto do rato faminto

Considere um rato em um labirinto 4×4. O rato (agente) quer encontrar o queijo. A recompensa do queijo é +10. Ele pode mover-se para cima, baixo, esquerda ou direita. Porém, paredes bloqueiam certos movimentos. Buracos dão recompensa -5. Eles também terminam o episódio. O estado representa a posição (linha, coluna). O ambiente compreende a grade com paredes e buracos. Portanto, o objetivo do agente é aprender a política ótima. O código abaixo resolve esse problema com Q-learning.

import numpy as np
import matplotlib.pyplot as plt

# Ambiente: grade 4x4
# 0 = caminho, 1 = parede, 2 = queijo, 3 = buraco
grid = np.array([
    [0, 0, 0, 0],
    [0, 1, 0, 3],
    [0, 1, 0, 0],
    [0, 0, 2, 0]
])

# Mapeamento ações: 0=cima, 1=baixo, 2=esquerda, 3=direita
acoes = [(-1,0), (1,0), (0,-1), (0,1)]
num_acoes = 4
num_estados = 16  # 4x4

# Hiperparâmetros
alpha = 0.1   # taxa aprendizado
gamma = 0.95  # fator desconto
epsilon = 0.2 # exploração
episodios = 500

# Inicializa tabela Q
Q = np.zeros((num_estados, num_acoes))

def estado_para_idx(linha, coluna):
    return linha * 4 + coluna

def idx_para_estado(idx):
    return (idx // 4, idx % 4)

def obter_recompensa(linha, coluna):
    if grid[linha, coluna] == 2:  # queijo
        return 10, True
    elif grid[linha, coluna] == 3: # buraco
        return -5, True
    return -0.1, False  # pequena penalidade por tempo

def escolher_acao(estado_idx, epsilon):
    if np.random.rand() < epsilon:
        return np.random.randint(num_acoes)
    return np.argmax(Q[estado_idx])

# Treinamento
recompensas_por_episodio = []
for ep in range(episodios):
    linha, coluna = 0, 0  # estado inicial
    estado_idx = estado_para_idx(linha, coluna)
    total_recompensa = 0
    feito = False
    
    while not feito:
        acao = escolher_acao(estado_idx, epsilon)
        dlinha, dcoluna = acoes[acao]
        nova_linha = linha + dlinha
        nova_coluna = coluna + dcoluna
        
        # Verifica limites e paredes
        if (nova_linha < 0 or nova_linha >= 4 or 
            nova_coluna < 0 or nova_coluna >= 4 or
            grid[nova_linha, nova_coluna] == 1):
            nova_linha, nova_coluna = linha, coluna  # não move
        
        recompensa, feito = obter_recompensa(nova_linha, nova_coluna)
        novo_estado_idx = estado_para_idx(nova_linha, nova_coluna)
        
        # Atualização Q-learning
        melhor_futuro = np.max(Q[novo_estado_idx])
        Q[estado_idx, acao] += alpha * (recompensa + gamma * melhor_futuro - Q[estado_idx, acao])
        
        linha, coluna = nova_linha, nova_coluna
        estado_idx = novo_estado_idx
        total_recompensa += recompensa
        
        if feito:
            break
    
    recompensas_por_episodio.append(total_recompensa)

# Gráfico 1: Evolução das recompensas
plt.figure(figsize=(12,4))
plt.subplot(1,2,1)
plt.plot(recompensas_por_episodio, alpha=0.7)
plt.xlabel('Episódio')
plt.ylabel('Recompensa total')
plt.title('Aprendizado do rato')
plt.grid(True)

# Gráfico 2: Política aprendida (setas)
plt.subplot(1,2,2)
política = np.argmax(Q, axis=1)
setas = ['↑', '↓', '←', '→']
grade_pol = np.empty((4,4), dtype=str)
for i in range(4):
    for j in range(4):
        if grid[i,j] == 2:
            grade_pol[i,j] = '🧀'
        elif grid[i,j] == 3:
            grade_pol[i,j] = '💀'
        elif grid[i,j] == 1:
            grade_pol[i,j] = '█'
        else:
            acao = política[estado_para_idx(i,j)]
            grade_pol[i,j] = setas[acao]
plt.text(0.1, 0.5, str(grade_pol), fontsize=14, family='monospace')
plt.axis('off')
plt.title('Política ótima aprendida')
plt.tight_layout()
plt.show()

print("Política final (setas):")
for linha in grade_pol:
    print(' '.join(linha))

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

import numpy as np

import matplotlib.pyplot as plt

# Ambiente: grade 4x4

# 0 = caminho, 1 = parede, 2 = queijo, 3 = buraco

grid = np.array([

[0, 0, 0, 0],

[0, 1, 0, 3],

[0, 1, 0, 0],

[0, 0, 2, 0]

])

# Mapeamento ações: 0=cima, 1=baixo, 2=esquerda, 3=direita

acoes = [(-1,0), (1,0), (0,-1), (0,1)]

num_acoes = 4

num_estados = 16 # 4x4

# Hiperparâmetros

alpha = 0.1 # taxa aprendizado

gamma = 0.95 # fator desconto

epsilon = 0.2 # exploração

episodios = 500

# Inicializa tabela Q

Q = np.zeros((num_estados, num_acoes))

def estado_para_idx(linha, coluna):

return linha * 4 + coluna

def idx_para_estado(idx):

return (idx // 4, idx % 4)

def obter_recompensa(linha, coluna):

if grid[linha, coluna] == 2: # queijo

return 10, True

elif grid[linha, coluna] == 3: # buraco

return -5, True

return -0.1, False # pequena penalidade por tempo

def escolher_acao(estado_idx, epsilon):

if np.random.rand() < epsilon:

return np.random.randint(num_acoes)

return np.argmax(Q[estado_idx])

# Treinamento

recompensas_por_episodio = []

for ep in range(episodios):

linha, coluna = 0, 0 # estado inicial

estado_idx = estado_para_idx(linha, coluna)

total_recompensa = 0

feito = False

while not feito:

acao = escolher_acao(estado_idx, epsilon)

dlinha, dcoluna = acoes[acao]

nova_linha = linha + dlinha

nova_coluna = coluna + dcoluna

# Verifica limites e paredes

if (nova_linha < 0 or nova_linha >= 4 or

nova_coluna < 0 or nova_coluna >= 4 or

grid[nova_linha, nova_coluna] == 1):

nova_linha, nova_coluna = linha, coluna # não move

recompensa, feito = obter_recompensa(nova_linha, nova_coluna)

novo_estado_idx = estado_para_idx(nova_linha, nova_coluna)

# Atualização Q-learning

melhor_futuro = np.max(Q[novo_estado_idx])

Q[estado_idx, acao] += alpha * (recompensa + gamma * melhor_futuro - Q[estado_idx, acao])

linha, coluna = nova_linha, nova_coluna

estado_idx = novo_estado_idx

total_recompensa += recompensa

if feito:

break

recompensas_por_episodio.append(total_recompensa)

# Gráfico 1: Evolução das recompensas

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

plt.subplot(1,2,1)

plt.plot(recompensas_por_episodio, alpha=0.7)

plt.xlabel('Episódio')

plt.ylabel('Recompensa total')

plt.title('Aprendizado do rato')

plt.grid(True)

# Gráfico 2: Política aprendida (setas)

plt.subplot(1,2,2)

política = np.argmax(Q, axis=1)

setas = ['↑', '↓', '←', '→']

grade_pol = np.empty((4,4), dtype=str)

for i in range(4):

for j in range(4):

if grid[i,j] == 2:

grade_pol[i,j] = '🧀'

elif grid[i,j] == 3:

grade_pol[i,j] = '💀'

elif grid[i,j] == 1:

grade_pol[i,j] = '█'

else:

acao = política[estado_para_idx(i,j)]

grade_pol[i,j] = setas[acao]

plt.text(0.1, 0.5, str(grade_pol), fontsize=14, family='monospace')

plt.axis('off')

plt.title('Política ótima aprendida')

plt.tight_layout()

plt.show()

print("Política final (setas):")

for linha in grade_pol:

print(' '.join(linha))

O código implementa Q-learning clássico. O rato explora o labirinto por 500 episódios. A recompensa total cresce gradualmente. A política final mostra o caminho para o queijo. Este exemplo oferece uma introdução poderosa. Assim, você entende os fundamentos do aprendizado por reforço.

Recompensa e Retorno

Aprendizado por reforço: recompensa e retorno

Definição formal de recompensa e retorno

Hiperparâmetros relacionados e arquitetura

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

Agente, Ambiente, Ação, Estado

Aprendizado por reforço: agente, ambiente, ação e estado

Os quatro elementos fundamentais

Hiperparâmetros e arquitetura comum

Exemplo clássico: o labirinto do rato faminto