Aprendizado por Reforço

O que é Aprendizado por Reforço?

Aprendizado por Reforço (Reinforcement Learning, RL) é um paradigma de aprendizado de máquina (machine learning) em que um agente (agent) aprende a tomar decisões por meio da interação com um ambiente (environment). Em vez de aprender a partir de um conjunto de dados rotulado fixo (como no aprendizado supervisionado (supervised learning)), o agente descobre bons comportamentos por tentativa e erro (trial and error), guiado por recompensas (rewards).

A ideia central pode ser resumida assim:

• O agente observa a situação atual (estado).
• O agente escolhe uma ação.
• O ambiente transiciona para uma nova situação e emite uma recompensa.
• O agente atualiza seu comportamento para maximizar a recompensa de longo prazo.

Esse enquadramento de “aprender por interação” torna o RL central para agentes e planejamento (agents & planning): robótica, jogos, pesquisa operacional (operations research) e sistemas agênticos (agentic systems) modernos que precisam agir ao longo de horizontes longos, às vezes usando ferramentas e recursos externos.

Conceitos Centrais: Agente, Ambiente, Recompensa

Loop Agente–Ambiente

No passo de tempo (t), a interação é tipicamente modelada como:

• Estado: (s_t)
• Ação: (a_t)
• Recompensa: (r_{t+1})
• Próximo estado: (s_{t+1})

O objetivo do agente é aprender uma estratégia — chamada política (policy) — que seleciona ações para maximizar a recompensa cumulativa esperada (expected cumulative reward) ao longo do tempo.

Recompensas e Retorno

A recompensa imediata (r_{t+1}) é um único sinal de feedback escalar. O RL geralmente não se trata de maximizar a recompensa imediata, mas sim a recompensa de longo prazo.

Defina o retorno (return):

[ G_t = r_{t+1} + \gamma r_{t+2} + \gamma^2 r_{t+3} + \dots ]

onde ( \gamma \in [0,1) ) é o fator de desconto (discount factor):

• ( \gamma ) menor: favorece resultados de curto prazo
• ( \gamma ) maior: valoriza mais resultados de longo prazo

Em tarefas contínuas (sem estado terminal), o desconto também garante que o retorno seja finito.

Fundamento Formal: Processos de Decisão de Markov (MDPs)

A maior parte da teoria de RL é construída sobre o Processo de Decisão de Markov (Markov Decision Process, MDP), um modelo matemático padrão para tomada de decisão sequencial. Veja também: Processos de Decisão de Markov.

Um MDP consiste em:

• ( \mathcal{S} ): conjunto de estados
• ( \mathcal{A} ): conjunto de ações
• ( P(s' \mid s, a) ): dinâmica de transição
• ( R(s, a) ) ou ( R(s, a, s') ): função de recompensa
• ( \gamma ): fator de desconto

A propriedade de Markov (Markov property) significa que o futuro depende do estado e da ação presentes, e não do histórico completo:

[ P(s_{t+1} \mid s_t, a_t, s_{t-1}, a_{t-1}, \dots) = P(s_{t+1} \mid s_t, a_t) ]

Muitos problemas reais são apenas aproximadamente Markovianos (ou parcialmente observados), o que motiva extensões como processos de decisão de Markov parcialmente observáveis (POMDPs).

Políticas: Como o Agente Escolhe Ações

Uma política ( \pi ) é um mapeamento de estados para uma distribuição sobre ações:

[ \pi(a \mid s) = P(a_t = a \mid s_t = s) ]

Dois tipos comuns:

• Política determinística (deterministic policy): (a = \pi(s))
• Política estocástica (stochastic policy): (a \sim \pi(\cdot \mid s))

Políticas estocásticas são especialmente úteis para:

• exploração (tentar novas ações)
• ambientes com incerteza
• aprendizado em espaços de ação contínuos (comuns em robótica)

Estimação de Valor: Predizendo Recompensa de Longo Prazo

O RL frequentemente depende de estimar o quão bons estados ou ações são sob uma política.

Função Valor de Estado \(V^\pi(s)\)

Retorno esperado começando do estado (s) e seguindo a política (\pi):

[ V^\pi(s) = \mathbb{E}_\pi[G_t \mid s_t = s] ]

Função Valor-Ação \(Q^\pi(s,a)\)

Retorno esperado começando em (s), tomando a ação (a), e então seguindo (\pi):

[ Q^\pi(s,a) = \mathbb{E}_\pi[G_t \mid s_t = s, a_t = a] ]

Equações de Bellman (Recorrências-Chave)

A equação de expectativa de Bellman (Bellman expectation equation) expressa consistência dos valores:

[ V^\pi(s) = \sum_a \pi(a \mid s) \sum_{s'} P(s' \mid s,a)\left(R(s,a,s') + \gamma V^\pi(s')\right) ]

De forma análoga para (Q^\pi). Essas equações são fundamentais porque transformam raciocínio de horizonte longo em atualizações locais.

Valores Ótimos e Política Ótima

Defina:

[ V^(s) = \max_\pi V^\pi(s), \quad Q^(s,a) = \max_\pi Q^\pi(s,a) ]

A equação de otimalidade de Bellman para (Q^*):

[ Q^(s,a) = \sum_{s'} P(s' \mid s,a)\left(R(s,a,s') + \gamma \max_{a'} Q^(s',a')\right) ]

Se você conhece (Q^*), agir de forma ótima é “guloso (greedy)”:

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

Exploração vs. Aproveitamento

Agentes de RL precisam equilibrar:

• Aproveitamento (exploitation): escolher a melhor ação conhecida
• Exploração (exploration): tentar ações para aprender mais

Estratégias clássicas de exploração:

• (\epsilon)-gulosa ((\epsilon)-greedy): escolhe uma ação aleatória com probabilidade (\epsilon)
• Amostragem softmax/Boltzmann (Softmax / Boltzmann): amostra ações proporcionalmente ao valor estimado
• Limite Superior de Confiança (Upper Confidence Bound, UCB): estimativas otimistas para incentivar exploração (comum em bandidos)

Um exemplo simples e prático é o bandido de múltiplos braços (multi-armed bandit), em que cada ação produz uma recompensa a partir de uma distribuição desconhecida. Bandidos capturam exploração/aproveitamento sem transições de estado; o RL completo adiciona dinâmica sequencial.

Abordagens de Aprendizado: Baseadas em Modelo vs. Livres de Modelo

RL Baseado em Modelo

O agente aprende ou recebe um modelo do ambiente:

• modelo de transição (P(s' \mid s,a))
• modelo de recompensa (R(s,a))

Então ele pode planejar simulando resultados, de forma semelhante a Planejamento e Algoritmos de Busca clássicos.

Prós:

• pode ser mais eficiente em amostras
• dá suporte a planejamento com lookahead e raciocínio contrafactual

Contras:

• aprender modelos precisos pode ser difícil
• erros de modelo podem induzir planejamento ao erro (“viés de modelo”)

RL Livre de Modelo

O agente aprende valores e/ou uma política sem modelar explicitamente transições.

Prós:

• frequentemente mais simples de implementar
• evita armadilhas explícitas de aprendizado de modelo

Contras:

• pode exigir muitas interações (pouco eficiente em amostras), especialmente em tarefas do mundo real

Aprendizado por Diferença Temporal (TD): O Motor do RL

Aprendizado por diferença temporal (temporal-difference learning, TD) atualiza estimativas de valor usando bootstrap (bootstrapping) — usando estimativas de valores futuros para atualizar os atuais.

Uma atualização TD(0) básica para valor de estado:

[ V(s_t) \leftarrow V(s_t) + \alpha \left(r_{t+1} + \gamma V(s_{t+1}) - V(s_t)\right) ]

onde ( \alpha ) é a taxa de aprendizado (learning rate) e o termo entre parênteses é o erro de TD (TD error).

Métodos TD combinam benefícios de:

• métodos de Monte Carlo (Monte Carlo methods) (aprender com experiência)
• programação dinâmica (dynamic programming) (bootstrap)

Aprendizado Q e SARSA (Controle Clássico Livre de Modelo)

Aprendizado Q (Q-Learning) (Fora da Política)

O aprendizado Q aprende (Q^*(s,a)) enquanto se comporta de acordo com uma política de exploração (como (\epsilon)-gulosa). Atualização:

[ Q(s_t,a_t) \leftarrow Q(s_t,a_t) + \alpha\left(r_{t+1} + \gamma \max_{a'} Q(s_{t+1},a') - Q(s_t,a_t)\right) ]

Ele é fora da política (off-policy) porque aprende o alvo guloso (\max_{a'} Q(s_{t+1},a')) mesmo que o agente não tenha agido de forma gulosa.

SARSA (Na Política)

SARSA aprende o valor da política de comportamento (behavior policy):

[ Q(s_t,a_t) \leftarrow Q(s_t,a_t) + \alpha\left(r_{t+1} + \gamma Q(s_{t+1},a_{t+1}) - Q(s_t,a_t)\right) ]

Ele é na política (on-policy) porque a atualização usa a próxima ação real (a_{t+1}) escolhida pela mesma política.

Exemplo Mínimo de Aprendizado Q (Tabular)

Abaixo está um esboço compacto e prático para um pequeno ambiente discreto (tipo gridworld):

import random
from collections import defaultdict

Q = defaultdict(float)

def epsilon_greedy(state, actions, eps=0.1):
    if random.random() < eps:
        return random.choice(actions)
    return max(actions, key=lambda a: Q[(state, a)])

alpha = 0.1
gamma = 0.99
eps = 0.1

for episode in range(1000):
    s = env.reset()
    done = False
    while not done:
        actions = env.actions(s)
        a = epsilon_greedy(s, actions, eps)
        s2, r, done = env.step(a)

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

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

Isso funciona bem quando o espaço estado-ação é pequeno o suficiente para armazenar em uma tabela. Para problemas grandes, precisamos de aproximação de função.

Aproximação de Função e RL Profundo

Em aplicações reais, estados podem ser de alta dimensionalidade (imagens, texto, sensores contínuos). Em vez de uma tabela, aproximamos (V), (Q) ou (\pi) com uma função parametrizada como uma rede neural (neural network); veja Redes Neurais e Aprendizado Profundo.

Redes Q Profundas (Deep Q-Networks, DQN)

DQN aproxima (Q(s,a)) com uma rede neural (Q_\theta(s,a)). Duas técnicas de estabilização foram historicamente cruciais:

• Repetição de experiência (experience replay): armazenar transições ((s,a,r,s')) e treinar em minibatches embaralhados para reduzir correlação
• Rede-alvo (target network): uma cópia da rede Q atualizada lentamente, para alvos mais estáveis

DQN possibilitou resultados fortes em jogos Atari a partir de pixels e continua sendo uma abordagem fundamental de RL profundo para ações discretas.

Métodos de Gradiente de Política

Em vez de aprender valores e derivar uma política, métodos de gradiente de política (policy gradient) otimizam diretamente os parâmetros da política (\theta) para maximizar o retorno esperado:

[ J(\theta) = \mathbb{E}{\pi\theta}\left[\sum_t \gamma^t r_{t+1}\right] ]

Um estimador de gradiente básico (REINFORCE) é:

[ \nabla_\theta J(\theta) \approx \sum_t \nabla_\theta \log \pi_\theta(a_t \mid s_t), G_t ]

Esses métodos são flexíveis, especialmente para:

• ações contínuas (por exemplo, comandos de torque em robótica)
• políticas estocásticas
• variantes com restrições ou multiobjetivo

Em geral, eles dependem de Descida do Gradiente (e suas variantes) por baixo dos panos.

Métodos Ator–Crítico

Ator–crítico (actor–critic) combina:

• Ator: a política (\pi_\theta(a\mid s))
• Crítico: um estimador de valor (por exemplo, (V_\phi(s)) ou (Q_\phi(s,a)))

O crítico reduz a variância substituindo retornos brutos (G_t) por uma estimativa de vantagem (advantage estimate):

[ A(s_t,a_t) = Q(s_t,a_t) - V(s_t) ]

Algoritmos ator–crítico modernos e amplamente usados incluem:

• A2C/A3C (ator–crítico com vantagem síncrono/assíncrono)
• DDPG / TD3 (controle contínuo, políticas determinísticas)
• SAC (Ator–Crítico Suave (Soft Actor-Critic); regularizado por entropia, forte para controle contínuo)
• PPO (Otimização de Política Proximal (Proximal Policy Optimization); robusto e popular na prática)

PPO é notoriamente usado em RL para alinhamento de modelos de linguagem (ver RLHF abaixo).

Exemplos Práticos: Como o RL Aparece no Mundo Real

Exemplo 1: Navegação de Robôs em um Armazém

• Estado: posição do robô, leituras de lidar, características do mapa
• Ações: mover para frente, virar, ajustar velocidade
• Recompensa: positiva por atingir um objetivo rapidamente, negativa por colisões ou atrasos

Desafios:

• segurança (colisões são custosas)
• transferência sim-to-real (sim-to-real transfer) (treinar em simulação, implantar em hardware)
• recompensas esparsas (sparse rewards) (atingir o objetivo é raro no começo)

Soluções comuns:

• modelagem de recompensa (reward shaping) (com cuidado)
• aprendizado curricular (curriculum learning) (começar fácil, aumentar a dificuldade)
• RL baseado em modelo ou híbridos com planejamento para eficiência amostral

Exemplo 2: Recomendação e Ranqueamento (Sequencial)

Ao contrário de recomendações “one-shot”, muitos sistemas são sequenciais:

• Estado: contexto do usuário + histórico de interações
• Ação: o item (ou lista) a recomendar
• Recompensa: clique, tempo assistido, compra, retenção

RL é atraente porque pode otimizar o engajamento de longo prazo, mas precisa lidar com:

• observabilidade parcial e feedback atrasado
• avaliação fora da política (off-policy evaluation) (você não pode experimentar livremente com usuários)
• mudança de distribuição (distribution shift) e restrições de segurança (safety constraints)

Esse domínio frequentemente usa aprendizado por reforço offline (offline RL) e técnicas de avaliação contrafactual (counterfactual evaluation).

Exemplo 3: Jogos (Benchmark Clássico de RL)

Em jogos como Go ou StarCraft, RL se destaca porque:

• ambientes podem ser simulados de forma barata
• o sucesso exige planejamento e estratégia de longo horizonte
• autojogo (self-play) pode gerar dados de treinamento ilimitados

Sistemas marcantes combinaram RL com aprendizado profundo e busca (por exemplo, busca em árvore (tree search) + redes de valor/política), conectando RL e ideias de planejamento clássico.

RL Offline e RLHF: Desenvolvimentos Modernos

Aprendizado por Reforço Offline (em Lote)

RL offline aprende uma política a partir de um conjunto de dados fixo de interações passadas, sem novas consultas ao ambiente. Isso é importante quando explorar é caro ou inseguro (saúde, robótica, finanças).

Dificuldade principal:

• mudança distribucional (distributional shift): a política aprendida pode escolher ações que não estão bem cobertas pelo conjunto de dados, levando a erros de extrapolação.

Muitos métodos de RL offline restringem a política aprendida a permanecer próxima da política de comportamento no conjunto de dados ou usam estimativas de valor conservadoras.

RLHF (Aprendizado por Reforço a partir de Feedback Humano)

Em sistemas modernos de IA — especialmente modelos de linguagem grandes — RL é usado para alinhar o comportamento com preferências humanas.

Um pipeline comum de aprendizado por reforço a partir de feedback humano (Reinforcement Learning from Human Feedback, RLHF):

1. Coletar comparações de preferência humana entre saídas do modelo.
2. Treinar um modelo de recompensa (reward model) para prever preferência.
3. Fazer ajuste fino (fine-tune) da política (o modelo de linguagem) com um algoritmo de RL (frequentemente PPO) para maximizar a recompensa aprendida enquanto permanece próximo do modelo original.

Isso conecta RL a comportamento agêntico (agentic behavior), uso de ferramentas (tool use) e tarefas de longo horizonte — em que “recompensa” pode representar utilidade definida por humanos, em vez de pontuações nativas do ambiente.

Principais Desafios e Armadilhas na Prática

Design de Recompensas e Fraude de Recompensa

Agentes otimizam o que você mede. Recompensas mal especificadas podem produzir comportamentos não intencionais (às vezes chamado “jogo da especificação” (“specification gaming”)). Mitigações práticas incluem:

• adicionar restrições ou penalidades com cuidado
• usar feedback humano (RLHF / aprendizado de preferências (preference learning))
• avaliar com cenários de teste adversariais

Eficiência Amostral

Muitos algoritmos de RL exigem grandes quantidades de dados de interação. Técnicas para melhorar a eficiência:

• RL baseado em modelo
• melhores estratégias de exploração
• usar demonstrações / aprendizado por imitação (imitation learning)
• pré-treinamento offline e depois ajuste fino online

Estabilidade com Aproximação de Função

Combinar bootstrap + aproximação de função + aprendizado fora da política pode ser instável (a “tríade mortal” (“deadly triad”)). Estabilizadores incluem:

• redes-alvo, buffers de repetição (replay buffers) (estilo DQN)
• objetivos conservadores (RL offline)
• atualizações no estilo de região de confiança (trust-region) (PPO, TRPO)

Observabilidade Parcial

Ambientes reais frequentemente escondem variáveis importantes. Abordagens:

• políticas recorrentes (recurrent policies) (RNNs, transformers)
• estimação de estado de crença (belief-state estimation) (filtragem probabilística (probabilistic filtering))
• arquiteturas com memória (memory-based architectures)

Onde o RL se Encaixa no Panorama Mais Amplo de IA

RL é um pilar do aprendizado de máquina, complementar a:

• aprendizado supervisionado (aprender com exemplos rotulados)
• aprendizado não supervisionado/auto-supervisionado (unsupervised/self-supervised learning) (aprender representações a partir de dados brutos)
• planejamento/busca (lookahead explícito e raciocínio estruturado)

Em muitos sistemas modernos, RL é hibridizado (hybridized):

• redes profundas fornecem percepção e aprendizado de representações (representation learning)
• RL fornece tomada de decisão sob incerteza
• planejamento/busca fornece lookahead e restrições

Essa combinação é especialmente relevante para sistemas de “Agentes e Planejamento” que precisam agir ao longo de horizontes longos e se adaptar online.

Resumo

Aprendizado por reforço é aprender por interação, orientado por recompensas, moldado por políticas e impulsionado por estimação de valor. Fundamentos teóricos como MDPs e equações de Bellman esclarecem o que significa agir de forma ótima, enquanto algoritmos práticos — aprendizado por diferença temporal, aprendizado Q, ator–crítico e RL profundo — fazem isso funcionar em escala.

RL tem impacto onde decisões são sequenciais e os resultados são atrasados: robótica, jogos, operações, recomendação e, cada vez mais, o treinamento e o alinhamento de grandes agentes de IA. Ao mesmo tempo, ele traz desafios de engenharia únicos: exploração, estabilidade, design de recompensas e segurança — tornando a avaliação cuidadosa e a formulação criteriosa do problema tão importantes quanto o próprio algoritmo de aprendizado.

---