Métodos

Visão geral: três famílias de métodos de AR

A maioria dos algoritmos modernos de aprendizado por reforço (reinforcement learning, RL) pode ser agrupada em três famílias intimamente relacionadas:

Métodos baseados em valor (value-based methods) (ex.: aprendizado Q (Q-learning)): aprendem quão boas são as ações e então agem escolhendo a melhor ação.
Métodos baseados em política (policy-based methods) (ex.: gradientes de política (policy gradients)): aprendem diretamente uma política que mapeia estados para probabilidades de ação.
Métodos ator–crítico (actor–critic methods): combinam ambos — um ator (actor) (política) e um crítico (critic) (estimador de valor).

Todos os três se apoiam na mesma base formal descrita em Conceitos: o Processo de Decisão de Markov (Markov Decision Process, MDP), com estados (s), ações (a), recompensas (r), transições e um fator de desconto (\gamma \in [0,1)).

Na prática, a escolha entre essas famílias depende de:

Espaço de ações (action space): discreto vs contínuo
Estabilidade e facilidade de ajuste fino
Eficiência amostral (sample efficiency) (quanta interação com o ambiente é necessária)
Se é possível fazer aprendizado fora da política (off-policy) (reutilizando dados antigos) ou se é preciso permanecer na política (on-policy) (aprendendo apenas a partir da política atual)

Este artigo foca em: aprendizado Q, gradientes de política e abordagens ator–crítico — sua teoria, como são implementadas e onde funcionam melhor.

Aprendizado Q (AR Baseado em Valor)

Ideia central

O aprendizado Q aprende uma função valor-ação (action-value function):

[ Q^*(s,a) = \mathbb{E}\left[\sum_{t=0}^{\infty}\gamma^t r_{t} \mid s_0=s, a_0=a, \pi^* \right] ]

Se você conhece (Q^*(s,a)), pode agir de forma ótima sendo guloso (greedy):

[ \pi^*(s) = \arg\max_a Q^*(s,a) ]

O aprendizado Q é poderoso porque é fora da política: ele pode aprender a política gulosa ótima mesmo enquanto se comporta com uma política exploratória (ex.: (\epsilon)-gulosa ((\epsilon)-greedy)). Isso se conecta diretamente a Exploração vs Aproveitamento.

A regra de atualização (otimalidade de Bellman)

A atualização tabular clássica do aprendizado Q é:

[ Q(s,a) \leftarrow Q(s,a) + \alpha \left( r + \gamma \max_{a'} Q(s',a') - Q(s,a) \right) ]

Onde:

(\alpha) é a taxa de aprendizado
(r + \gamma \max_{a'} Q(s',a')) é um alvo por bootstrap (bootstrap target)
A quantidade entre parênteses é o erro de diferença temporal (temporal-difference, TD)

Essa atualização tenta impor a equação de otimalidade de Bellman (Bellman optimality equation).

Quando o aprendizado Q tabular funciona?

O aprendizado Q tabular pode convergir para (Q^*) sob condições padrão:

Cada par estado–ação é visitado infinitas vezes (exploração suficiente)
Taxas de aprendizado satisfazem as condições de Robbins–Monro (ex.: (\sum \alpha_t = \infty), (\sum \alpha_t^2 < \infty))
MDP finito

Em problemas realistas, os espaços de estado são enormes/contínuos, então usamos aproximação de função (function approximation) (aprendizagem profunda). É aí que as coisas ficam mais delicadas.

Exemplo prático: aprendizado Q tabular em um pequeno mundo em grade (gridworld)

Abaixo está um esboço mínimo para um ambiente discreto:

import random
from collections import defaultdict

Q = defaultdict(lambda: 0.0)

alpha = 0.1
gamma = 0.99
epsilon = 0.1

def eps_greedy_action(s, actions):
    if random.random() < epsilon:
        return random.choice(actions)
    return max(actions, key=lambda a: Q[(s, a)])

for episode in range(num_episodes):
    s = env.reset()
    done = False

    while not done:
        actions = env.actions(s)
        a = eps_greedy_action(s, actions)

        s2, r, done = env.step(a)

        # Q-learning target uses max over next actions (off-policy)
        next_actions = env.actions(s2)
        target = r + (0 if done else gamma * max(Q[(s2, a2)] for a2 in next_actions))

        Q[(s, a)] += alpha * (target - Q[(s, a)])
        s = s2

Rede Q Profunda (Deep Q-Network, DQN): escalando com redes neurais

Para lidar com grandes espaços de estado, substitua a tabela Q por uma rede neural (neural network) (Q_\theta(s,a)) (ver Redes Neurais). A abordagem ingênua — treinar diretamente em alvos de TD — frequentemente diverge porque tanto o alvo quanto a predição dependem da mesma rede em constante mudança.

A DQN estabiliza o aprendizado com duas ideias-chave:

Repetição de experiência (experience replay): armazenar transições ((s,a,r,s',done)) em um buffer e treinar em minilotes (mini-batches) aleatórios (reduz correlação).
Rede-alvo (target network): usar uma rede separada, atualizada lentamente, (Q_{\bar{\theta}}) para computar alvos.

Uma perda comum da DQN:

[ \mathcal{L}(\theta) = \mathbb{E}\left[\left(r + \gamma \max_{a'} Q_{\bar{\theta}}(s',a') - Q_{\theta}(s,a)\right)^2\right] ]

Limitações de métodos no estilo do aprendizado Q

Ações discretas: (\arg\max_a) é fácil apenas quando as ações são discretas/pequenas.
Viés de superestimação (overestimation bias): o (\max) sobre estimativas ruidosas tende a superestimar; a DQN Dupla (Double DQN) ajuda.
Desafios de exploração: (\epsilon)-gulosa pode ser fraca em cenários com recompensas esparsas.
Instabilidade com aproximação de função: bootstrap fora da política + aproximação de função é uma conhecida “zona de perigo”.

Gradientes de Política (Otimização Direta de Política)

Ideia central

Em vez de aprender valores e então derivar uma política, métodos de gradiente de política otimizam diretamente uma política parametrizada (parameterized policy) (\pi_\theta(a\mid s)) para maximizar o retorno esperado:

[ J(\theta) = \mathbb{E}{\tau \sim \pi\theta}\left[\sum_{t=0}^{T} \gamma^t r_t\right] ]

Aqui (\tau) é uma trajetória (trajectory) amostrada ao seguir (\pi_\theta).

Isso é especialmente natural para espaços de ações contínuas (continuous action spaces), em que “escolher a ação máxima” não é direto.

O teorema do gradiente de política (REINFORCE)

Um resultado fundamental é:

[ \nabla_\theta J(\theta) = \mathbb{E}\left[\sum_{t} \nabla_\theta \log \pi_\theta(a_t\mid s_t); G_t \right] ]

Onde (G_t) é o retorno a partir do tempo (t).

Isso leva ao REINFORCE (gradiente de política de Monte Carlo (Monte Carlo policy gradient)). Intuitivamente:

Se uma ação leva a alto retorno, aumente sua log-probabilidade.
Se leva a baixo retorno, diminua-a.

Gradientes de política são treinados com Descida do Gradiente usando retropropagação através da rede de política (ver Retropropagação).

Redução de variância: linhas de base e vantagens

O REINFORCE “cru” tem alta variância. Um truque-chave é subtrair uma linha de base (baseline) (b(s_t)) que não depende da ação:

[ \nabla_\theta J(\theta) = \mathbb{E}\left[\sum_t \nabla_\theta \log \pi_\theta(a_t\mid s_t); (G_t - b(s_t)) \right] ]

Uma escolha comum: (b(s_t)=V_\phi(s_t)), uma função de valor aprendida. Então (G_t - V(s_t)) é uma estimativa da vantagem (advantage) — o quanto a ação foi melhor do que o esperado.

Exemplo prático: atualização no estilo REINFORCE (pseudocódigo tipo PyTorch)

# Pseudocode: REINFORCE with baseline
for episode in range(num_episodes):
    states, actions, rewards = rollout(env, policy)

    returns = compute_discounted_returns(rewards, gamma)

    # Optional baseline: value network V(s)
    baselines = value_net(states).detach()
    advantages = returns - baselines

    logp = policy.log_prob(states, actions)  # sum over action dims if continuous
    policy_loss = -(logp * advantages).mean()

    policy_opt.zero_grad()
    policy_loss.backward()
    policy_opt.step()

    # Fit baseline with regression to returns
    value_loss = ((value_net(states) - returns) ** 2).mean()
    value_opt.zero_grad()
    value_loss.backward()
    value_opt.step()

Forças e limitações dos gradientes de política

Forças

Funciona naturalmente com ações contínuas (políticas Gaussianas, políticas Beta etc.)
Pode representar políticas estocásticas (stochastic policies), úteis para exploração e comportamentos multimodais
Otimiza a política diretamente, evitando (\arg\max) ou restrições de ações discretas

Limitações

Muitas vezes é na política: os dados devem vir da política atual, reduzindo a eficiência amostral
Pode ser instável sem restrições de região de confiança (trust-region) ou ajuste fino cuidadoso
Gradientes de alta variância, a menos que você use linhas de base/críticos

Algoritmos modernos de gradiente de política frequentemente usam restrições para melhorar a estabilidade (ex.: PPO/TRPO), muitos dos quais são melhor compreendidos como variantes ator–crítico.

Métodos Ator–Crítico (Combinando Aprendizado de Política e de Valor)

Ideia central

Métodos ator–crítico aprendem:

Ator: (\pi_\theta(a\mid s)), a política
Crítico: (V_\phi(s)) ou (Q_\phi(s,a)), um estimador de valor usado para guiar/melhorar o ator

Eles combinam o sinal de aprendizado de baixa variância de métodos de diferença temporal (bootstrapping) com a otimização direta de gradientes de política.

A atualização ator–crítico com vantagem

Uma forma comum usa um crítico (V_\phi(s)) e uma estimativa de vantagem baseada em TD:

[ \hat{A}t = r_t + \gamma V\phi(s_{t+1}) - V_\phi(s_t) ]

Atualização do ator:

[ \nabla_\theta J(\theta) \approx \mathbb{E}\left[\nabla_\theta \log \pi_\theta(a_t\mid s_t); \hat{A}_t \right] ]

Atualização do crítico: ajustar por regressão as predições de valor em direção a alvos TD, por exemplo:

[ \mathcal{L}(\phi)=\mathbb{E}\left[\left(r_t + \gamma V_\phi(s_{t+1}) - V_\phi(s_t)\right)^2\right] ]

Isso produz um algoritmo que tipicamente é:

De menor variância do que gradiente de política via Monte Carlo
Frequentemente mais eficiente em amostras
Ainda sensível a hiperparâmetros e questões de estabilidade (especialmente variantes fora da política)

Exemplo prático: esboço no estilo A2C (advantage actor–critic síncrono)

# Pseudocode: A2C-style update with TD(0) advantage
batch = collect_n_steps(env, policy, n_steps)

states, actions, rewards, next_states, dones = batch

V = value_net(states)
V_next = value_net(next_states).detach()

td_target = rewards + gamma * (1 - dones) * V_next
advantage = (td_target - V).detach()

logp = policy.log_prob(states, actions)
entropy = policy.entropy(states)  # encourages exploration

actor_loss = -(logp * advantage).mean() - ent_coef * entropy.mean()
critic_loss = ((V - td_target) ** 2).mean()

loss = actor_loss + vf_coef * critic_loss

opt.zero_grad()
loss.backward()
opt.step()

A regularização por entropia (entropy regularization) é um truque prático comum: ela desencoraja o colapso prematuro para comportamento determinístico e apoia a exploração.

Ator–crítico na política vs fora da política

Ator–crítico é um padrão, não um único algoritmo. A maior bifurcação na prática é se o aprendizado é na política ou fora da política.

Ator–crítico na política

Exemplos: A2C/A3C, PPO (frequentemente formulado como ator–crítico)
Prós: teoria mais simples; tende a ser estável
Contras: menor eficiência amostral

Ator–crítico fora da política

Exemplos: DDPG, TD3, SAC
Prós: pode reutilizar buffers de repetição → muito mais eficiente em amostras
Contras: mais partes móveis; pode ser instável sem projeto cuidadoso

O aprendizado fora da política se conecta conceitualmente ao Aprendizado por Reforço Offline, em que você pode apenas ter dados registrados e não consegue interagir mais.

Controle contínuo: por que ator–crítico domina

Em tarefas de robótica e controle (comandos contínuos de torque/velocidade), métodos ator–crítico são amplamente usados porque:

O ator pode produzir ações contínuas diretamente.
O crítico fornece um sinal de aprendizado estruturado.
Variantes fora da política com buffers de repetição podem ser muito mais eficientes em dados.

Uma escolha moderna comum é o Ator–Crítico Suave (Soft Actor–Critic, SAC), que maximiza tanto retorno quanto a entropia da política:

[ J(\pi) = \mathbb{E}\left[\sum_t \gamma^t \left(r_t + \alpha \mathcal{H}(\pi(\cdot\mid s_t))\right)\right] ]

Isso incentiva a exploração e frequentemente melhora a robustez.

Como Esses Métodos se Relacionam (Visão Unificadora)

Um modelo mental útil:

Aprendizado Q aprende uma política gulosa implicitamente ao tornar (Q(s,a)) preciso e escolher (\arg\max_a Q(s,a)).
Gradientes de política aprendem a política explicitamente ao diferenciar através de (\log \pi_\theta(a\mid s)).
Ator–crítico usa uma função de valor (crítico) para produzir um sinal de vantagem, e então aplica uma atualização de gradiente de política ao ator.

Você pode ver ator–crítico como uma ponte entre os dois:

Como aprendizado Q, ele usa bootstrap (bootstrapping) (alvos TD).
Como gradientes de política, ele atualiza diretamente uma política parametrizada.

Escolhendo um Método na Prática

Se as ações são discretas e pequenas

Comece com métodos no estilo aprendizado Q / DQN.
Aplicações típicas: jogos tipo Atari, roteamento com pequenos conjuntos de ações, escalonamento com escolhas discretas.

Se as ações são contínuas ou de alta dimensionalidade

Prefira gradientes de política ou (mais frequentemente) ator–crítico.
Aplicações típicas: controle robótico, locomoção, alocação contínua de recursos.

Se interações com o ambiente são caras

Prefira métodos fora da política (variantes de DQN, SAC/TD3) que podem reutilizar experiência via repetição.
Considere AR Baseado em Modelo quando for possível aprender a dinâmica e planejar para reduzir interações reais.

Se estabilidade e simplicidade importam mais

Ator–crítico no estilo PPO é um padrão comum em muitos domínios devido à estabilidade razoável e forte desempenho empírico.

Considerações Práticas Comuns (Entre Métodos)

Estratégias de exploração

Baseados em valor: (\epsilon)-gulosa, exploração de Boltzmann, redes ruidosas
Baseados em política/ator–crítico: bônus de entropia, ruído de parâmetros Exploração é tão central que vale a pena ler Exploração vs Aproveitamento junto com qualquer método.

Escalonamento e modelagem de recompensas

Recompensas mal escalonadas podem desestabilizar o treinamento.
Modelagem de recompensa (reward shaping) pode acelerar o aprendizado, mas pode alterar a política ótima se não for baseada em potencial (potential-based).

Aproximação de função e estabilidade

Combinar estes três ingredientes pode causar instabilidade:

Bootstrap (alvos TD)
Aprendizado fora da política
Aproximação de função (redes neurais)

Esta é uma fonte clássica de divergência em aprendizado por reforço profundo (deep RL). Muitas melhorias “modernas” (redes-alvo, repetição, objetivos com recorte, críticos gêmeos) são estabilizadores para esse problema.

Armadilhas de avaliação

Curvas de aprendizado em RL têm alta variância; rode múltiplas sementes (seeds).
Meça tanto o retorno de treinamento quanto o retorno de avaliação (sem ruído de exploração).
Cuidado com “manipulação de recompensa (reward hacking)” e problemas de especificação — especialmente em implantações no mundo real e contextos de alinhamento (alignment) (veja AR para Modelos de Linguagem Grandes para uma perspectiva aplicada e orientada a alinhamento).

Resumo

Aprendizado Q aprende (Q(s,a)) via a atualização de otimalidade de Bellman e age de forma gulosa; ele é naturalmente fora da política e se ajusta bem a problemas com ações discretas (especialmente com estabilizadores da DQN em aprendizado por reforço profundo).
Gradientes de política otimizam diretamente uma política parametrizada (\pi_\theta) usando o truque da derivada do log; eles suportam naturalmente ações contínuas, mas podem ter alta variância e frequentemente são na política.
Métodos ator–crítico combinam um ator (política) com um crítico (estimador de valor), produzindo atualizações de menor variância e forte desempenho prático; eles dominam o RL moderno de controle contínuo e sustentam muitos algoritmos amplamente usados (PPO, SAC, TD3).

Juntos, esses métodos formam a espinha dorsal da prática contemporânea de RL, e entender suas suposições — na política vs fora da política, ações discretas vs contínuas e como a estimação de valor interage com a aproximação de função — é essencial para aplicar RL de forma eficaz.

Tópico pai

←Aprendizado por Reforço

Subtópicos

Aprendizado por Diferença Temporal (Temporal-Difference, TD)Explica o aprendizado por diferença temporal (temporal-difference, TD) como uma família de métodos de aprendizado por reforço (reinforcement learning, RL) que aprende funções de valor por meio de bootstrap a partir de outras estimativas aprendidas (o erro TD) em vez de esperar pelos retornos completos. Aborda atualizações centrais como TD(0) e TD(λ) com traços de elegibilidade, e como as ideias de TD fundamentam algoritmos como SARSA e Q-learning.
Gradientes de PolíticaExplica métodos de gradiente de política para aprendizado por reforço: otimização direta de uma política parametrizada por meio do teorema do gradiente de política (policy gradient theorem) (por exemplo, REINFORCE) e considerações práticas comuns, como redução de variância com baselines e estimativas de vantagem (advantage estimates).
Aprendizado por Reforço HierárquicoAborda o aprendizado por reforço hierárquico (hierarchical reinforcement learning, HRL): o aprendizado de políticas em múltiplos níveis de abstração (por exemplo, seleção de objetivos/opções em alto nível e controle em baixo nível) para resolver tarefas de longo horizonte com mais eficiência. Discute estruturas comuns como opções, habilidades, subobjetivos e arquiteturas no estilo feudal, além de principais benefícios e armadilhas (atribuição de crédito, exploração e estabilidade).
Iteração de PolíticasExplica a iteração de políticas (policy iteration), um método de controle por programação dinâmica para resolver MDPs (processos de decisão de Markov), alternando entre avaliação de políticas (policy evaluation; cálculo de V^π) e melhoria de políticas (policy improvement; tornar a política gulosa em relação à função de valor) até a convergência. Aborda as etapas do algoritmo, a intuição e as garantias de convergência no cenário tabular, e sua relação com iteração de valores (value iteration) e iteração generalizada de políticas (generalized policy iteration).
Iteração de ValorExplica a iteração de valor (value iteration) como um algoritmo de programação dinâmica para calcular a função de valor ótima e a política em um MDP conhecido, usando atualizações de otimalidade de Bellman (Bellman optimality backups). Aborda a regra de atualização, as condições de convergência, os critérios de parada e a relação com a iteração de política e a iteração de valores Q.
Iteração Generalizada de PolíticasExplica a iteração generalizada de políticas (generalized policy iteration, GPI), a visão unificadora em RL (reinforcement learning), na qual a avaliação de políticas e a melhoria de políticas são intercaladas (frequentemente de forma aproximada e assíncrona) em vez de serem alternadas até a convergência. Aborda como a GPI se relaciona com a iteração de políticas e a iteração de valores, por que ela fundamenta o controle TD (temporal-difference) e os métodos ator–crítico (actor–critic), e a intuição básica de convergência em cenários tabulares.
Métodos Ator-CríticoExplica algoritmos de aprendizado por reforço (reinforcement learning) do tipo ator-crítico, que combinam uma política (ator) com uma função de valor (crítico) para reduzir a variância e melhorar a estabilidade do aprendizado. Aborda variantes-chave (por exemplo, A2C/A3C, DDPG, TD3, SAC), diferenças entre on-policy e off-policy, e considerações práticas como estimação de vantagem (advantage estimation) e exploração.
Q-learningApresenta o Q-learning como um algoritmo de controle por diferença temporal (temporal-difference) sem modelo (model-free) e off-policy para aprender funções de valor-ação em MDPs. Aborda a atualização de otimalidade de Bellman, pressupostos de convergência, estratégias de exploração (por exemplo, epsilon-greedy) e variantes práticas em alto nível, como abordagem tabular vs. aproximação por função (function approximation) e redes Q profundas (Deep Q-Networks, DQN).
Otimização de Política Proximal (Proximal Policy Optimization, PPO)Explica a Otimização de Política Proximal (Proximal Policy Optimization, PPO), um algoritmo prático on-policy de gradiente de política com arquitetura ator-crítico que estabiliza as atualizações por meio de um objetivo com recorte (clipped) (ou penalizado por KL). Aborda a intuição, a função objetivo central, os principais hiperparâmetros e onde o PPO é usado em pipelines modernos de aprendizado por reforço (reinforcement learning, RL) e RLHF (Reinforcement Learning from Human Feedback).