Aprendizado por Reforço — RL, Deep RL e PPO

Aprendizado por Reforço (Reinforcement Learning — RL) é o paradigma de aprendizado de máquina onde um agente aprende a tomar decisões interagindo com um ambiente, recebendo recompensas (positivas ou negativas) como sinal de feedback. Diferente de aprendizado supervisionado, não há pares (input, resposta correta) — o agente descobre por tentativa e erro quais ações levam a maiores recompensas acumuladas.

Papers de referência: arXiv cs.LG | Paper original PPO: arxiv.org/abs/1707.06347

O framework do RL — MDPs

O Processo de Decisão de Markov (MDP) é a formalização matemática do RL:

MDP = (S, A, P, R, γ)

- S: espaço de estados (o que o agente observa)
- A: espaço de ações (o que o agente pode fazer)
- P(s'|s,a): função de transição (probabilidade de ir para s' dado s e a)
- R(s,a): função de recompensa
- γ ∈ [0,1]: fator de desconto (quanto recompensas futuras valem vs imediatas)

Propriedade de Markov: o próximo estado depende apenas do estado atual e da ação — não do histórico completo.

O objetivo do agente

Maximizar a recompensa acumulada descontada:

G_t = R_{t+1} + γR_{t+2} + γ²R_{t+3} + ... = Σ γᵏ R_{t+k+1}

γ próximo de 0: agente míope (prioriza recompensas imediatas). γ próximo de 1: agente com visão de longo prazo.

Value Functions e Q-function

Value Function V(s)

Estima a recompensa acumulada esperada a partir do estado s seguindo uma política π:

V^π(s) = E_π[G_t | S_t = s]

Q-function Q(s,a)

Estima a recompensa acumulada esperada ao tomar ação a no estado s:

Q^π(s,a) = E_π[G_t | S_t = s, A_t = a]

A política ótima é simplesmente escolher a ação com maior Q-value em cada estado.

Equação de Bellman

Base recursiva das funções de valor — define a relação entre o valor de um estado e o valor dos estados seguintes:

V(s) = Σ_a π(a|s) Σ_s' P(s'|s,a) [R(s,a) + γV(s')]

Algoritmos clássicos

Q-Learning (tabular)

Aprende Q(s,a) iterativamente via experiência. Funciona para espaços discretos e pequenos.

# Atualização Q-learning
Q[s][a] = Q[s][a] + α * (reward + γ * max(Q[s_next]) - Q[s][a])

# α: learning rate
# A diferença (reward + γ*max_Q_next - Q_current) é o TD error

SARSA (on-policy): variante onde a atualização usa a ação realmente tomada, não a melhor possível. Mais conservador.

Limitação: curse of dimensionality

Q-learning tabular quebra quando os espaços de estado são contínuos ou de alta dimensão. Para um robô com 10 articulações, o espaço de estados é contínuo e imenso — inviável manter uma tabela.

Solução: aproximar a Q-function com redes neurais → Deep Q-Network (DQN).

Deep RL

DQN — Deep Q-Network

Publicado pela DeepMind em 2013/2015, o DQN foi o primeiro algoritmo a aprender a jogar jogos Atari diretamente dos pixels de forma super-humana.

Inovações:

• Usa CNN para aproximar Q(s,a)
• Experience Replay: armazena transições (s,a,r,s') em buffer, amostra aleatoriamente — quebra correlação temporal
• Target Network: cópia congelada da rede principal para calcular targets estáveis

Policy Gradient — aprender a política diretamente

Em vez de aprender uma função de valor, Policy Gradient aprende diretamente a política π(a|s) parametrizada por uma rede neural.

REINFORCE (Williams, 1992): atualiza os parâmetros na direção que aumenta a probabilidade de ações com alta recompensa:

∇θ J(θ) = E[∇θ log π_θ(a|s) × G_t]

Problema: alta variância — os gradientes são ruidosos, requer muita amostragem.

Actor-Critic

Combina Policy Gradient (ator) com estimação de valor (crítico):

• Ator: aprende a política π(a|s) — "o que fazer"
• Crítico: aprende V(s) — "quão bom é esse estado"

O crítico reduz a variância dos gradientes do ator usando a vantagem (Advantage):

A(s,a) = Q(s,a) - V(s)
       = "quanto essa ação foi melhor que o esperado"

A2C/A3C (DeepMind, 2016): arquitetura Actor-Critic com workers paralelos coletando experiência assincronamente.

PPO — Proximal Policy Optimization

O PPO (Schulman et al., OpenAI 2017) é hoje o algoritmo de RL mais amplamente usado em produção. Resolveu o principal problema dos Policy Gradient: como atualizar a política de forma significativa sem destruir o que já foi aprendido?

O problema que o PPO resolve

Atualizações muito grandes de política podem colapsar o desempenho catastroficamente — o agente "esquece" o que havia aprendido. Atualizações muito pequenas são ineficientes.

TRPO (predecessora) resolvia isso com uma restrição de otimização de segunda ordem — matematicamente correto mas complexo de implementar e computacionalmente caro.

A solução do PPO: Clipped Surrogate Objective

O PPO usa uma função objetivo recortada que limita quanto a nova política pode divergir da antiga:

L_CLIP(θ) = E[min(rₜ(θ)Aₜ, clip(rₜ(θ), 1-ε, 1+ε)Aₜ)]

Onde:
- rₜ(θ) = π_θ(a|s) / π_θ_old(a|s)  (ratio entre nova e antiga política)
- Aₜ: vantagem estimada
- ε ≈ 0.2: clipping range

Como o clipping funciona:

• Se a ação foi boa (Aₜ > 0): aumenta sua probabilidade, mas só até (1+ε)x a política antiga
• Se a ação foi ruim (Aₜ < 0): diminui sua probabilidade, mas só até (1-ε)x a política antiga

O resultado: updates conservadores que extraem aprendizado máximo de cada batch sem colapso.

Vantagens do PPO

• Simples de implementar (sem segunda derivada como TRPO)
• Funciona em espaços contínuos e discretos
• Sample-efficient: reutiliza o mesmo batch para múltiplos updates
• Padrão para RLHF — treinamento de preferência humana em LLMs (ChatGPT, Gemini, Claude)

# Pseudocódigo PPO simplificado
for iteration in range(num_iterations):
    # Coleta trajetórias com política atual
    trajectories = collect_rollouts(policy, env, steps=2048)
    advantages = compute_gae(trajectories)  # Generalized Advantage Estimation

    # Múltiplos epochs de otimização no mesmo batch
    for epoch in range(10):
        for minibatch in get_minibatches(trajectories):
            ratio = new_policy(a|s) / old_policy(a|s)
            clipped = clip(ratio, 1-ε, 1+ε)
            loss = -mean(min(ratio * A, clipped * A))
            loss += value_loss + entropy_bonus
            optimizer.step(loss)

RLHF — RL com Feedback Humano

O Reinforcement Learning from Human Feedback é como modelos como ChatGPT e Claude são alinhados com preferências humanas:

1. Supervised Fine-tuning (SFT): fine-tune o LLM base em demonstrações humanas
2. Reward Model: treina um modelo de recompensa a partir de comparações humanas ("qual resposta é melhor?")
3. PPO: otimiza o LLM usando PPO com o reward model como função de recompensa

Humano avalia: Resposta A vs Resposta B
    ↓
Reward Model aprende preferências humanas
    ↓
PPO ajusta LLM para maximizar reward model
    ↓
LLM alinhado com preferências humanas

RLHF → DPO: Direct Preference Optimization (2023) é uma alternativa que elimina a necessidade do reward model explícito, simplificando o pipeline.

Aplicações

Conexões com outras seções

• Redes Neurais Profundas — Deep RL usa DNNs como aproximadores de função
• LLMs — RLHF é componente central no treinamento de modelos de linguagem
• Teoria dos Jogos — multi-agent RL e equilíbrios em ambientes competitivos
• Arbitragem Estatística — RL aplicado a estratégias de trading

Referências:

• PPO — Proximal Policy Optimization Algorithms (arXiv)
• PPO explicado — Hugging Face
• Spinning Up in Deep RL — OpenAI

Aviso Legal: Conteúdo educativo. Não constitui recomendação de investimento.