RL Baseado em Modelos (Model-Based RL)

O que é Aprendizado por Reforço Baseado em Modelo?

Aprendizado por Reforço Baseado em Modelo (Model-Based Reinforcement Learning, Model-Based RL ou MB-RL) é a família de métodos de aprendizado por reforço (reinforcement learning, RL) que aprendem um modelo da dinâmica do ambiente (e, frequentemente, das recompensas) e então usam esse modelo para planejar—isto é, para escolher ações simulando o futuro no espaço de modelo aprendido.

Nos Conceitos de Aprendizado por Reforço padrão, um agente interage com um ambiente modelado como um processo de decisão de Markov (Markov decision process, MDP) com:

• estado (s_t)
• ação (a_t)
• dinâmica de transição (p(s_{t+1}\mid s_t, a_t))
• função de recompensa (r(s_t,a_t))

O aprendizado por reforço baseado em modelo tenta explicitamente aprender aproximações de:

• (\hat{p}\theta(s{t+1}\mid s_t, a_t)) (modelo de dinâmica)
• às vezes (\hat{r}_\theta(s_t,a_t)) (modelo de recompensa)
• às vezes (\hat{p}\theta(o{t+1}\mid s_{t+1})) se estiver aprendendo um estado latente a partir de observações (modelos de mundo (world models))

Em seguida, ele planeja (planning) simulando trajetórias sob sequências candidatas de ações e selecionando aquela com o maior retorno previsto.

Isso contrasta com métodos sem modelo (model-free) (ver Métodos de Aprendizado por Reforço), que aprendem diretamente uma política (policy)/função de valor (value function) e não aprendem explicitamente a dinâmica.

Por que aprender um modelo?

Motivações principais

• Eficiência de dados (data efficiency): se dados de interação forem caros (robótica, saúde), usar um modelo aprendido para “imaginar” resultados pode reduzir rollouts no mundo real.
• Generalização e reutilização: um modelo pode dar suporte a muitas tarefas downstream: planejamento para novas metas, mudança de funções de recompensa ou controle baseado em restrições.
• Interpretabilidade e depuração: modelos expõem o que o agente acredita que sejam as dinâmicas, tornando falhas mais fáceis de diagnosticar.
• Planejamento sob restrições: o planejamento baseado em modelo dá suporte natural a restrições (evitar colisões, limites de torque) e margens de segurança.

Trade-off típico

O aprendizado por reforço baseado em modelo frequentemente tem maior complexidade algorítmica e pode sofrer de viés de modelo (model bias) (erros no modelo aprendido levando a planos ruins). Sistemas MB-RL bem-sucedidos investem fortemente em estimativa de incerteza, planejamento de curto horizonte e treinamento robusto.

Componentes Centrais do Aprendizado por Reforço Baseado em Modelo

A maioria dos sistemas MB-RL combina três componentes:

1. Coleta de dados: coletar transições ((s_t,a_t,r_t,s_{t+1})) do ambiente real (ou de um simulador).
2. Aprendizado do modelo: treinar um modelo preditivo (\hat{p}\theta) (e possivelmente (\hat{r}\theta)) via aprendizado supervisionado (supervised learning).
3. Planejamento/controle: usar o modelo aprendido para escolher ações (frequentemente com replanejamento a cada passo).

Um loop genérico de MB-RL se parece com:

Initialize dataset D with random rollouts
Initialize model parameters θ

repeat:
  Train dynamics model p̂θ on D (supervised learning)
  for each environment step:
    Plan using p̂θ from current state s
    Execute first action a (receding-horizon / MPC)
    Observe transition (s, a, r, s')
    Add to D
    s ← s'

O padrão “planejar e então agir” é frequentemente implementado como Controle Preditivo por Modelo (Model Predictive Control, MPC): planejar um horizonte curto, executar apenas a primeira ação e então replanejar usando a observação real mais recente.

Aprendendo o Modelo de Dinâmica

O que está sendo modelado?

Dependendo do problema e da observabilidade, MB-RL pode aprender:

• Dinâmica no espaço de estados: (\hat{s}{t+1} = f\theta(s_t,a_t)) (determinística) ou uma distribuição (p_\theta(s_{t+1}\mid s_t,a_t)) (estocástica).
• Modelo de recompensa: (\hat{r}t = g\theta(s_t,a_t))
• Modelo de término (termination model): probabilidade de um episódio terminar.
• Modelo de mundo latente (latent world model): aprender um estado latente (z_t) a partir de pixels/observações e prever (z_{t+1}).

Se você observa apenas pixels, o “estado” não é Markoviano. Muitos sistemas modernos aprendem um estado latente (latent state) que é aproximadamente Markoviano via modelos recorrentes (recurrent models) (ver “Modelos de Mundo” abaixo).

Modelos determinísticos vs estocásticos

• Modelos determinísticos (por exemplo, previsão de (s_{t+1}) via MSE) podem funcionar bem quando as dinâmicas são quase determinísticas e os sensores têm baixo ruído.
• Modelos estocásticos são cruciais quando o ambiente é inerentemente incerto (contatos, outros agentes, observabilidade parcial). Eles preveem uma distribuição (por exemplo, Gaussiana com média/variância) ou usam variáveis latentes.

Na prática, mesmo ambientes determinísticos se beneficiam de modelagem estocástica porque efeitos não modelados e capacidade limitada criam incerteza efetiva.

Estimativa de incerteza (crítica na prática)

Planejar dentro de um modelo aprendido é perigoso se o modelo estiver errado. Dois tipos comuns de incerteza:

• Incerteza aleatória (aleatoric uncertainty): aleatoriedade inerente (por exemplo, sensores ruidosos).
• Incerteza epistêmica (epistemic uncertainty): incerteza devido a dados limitados (o modelo “não sabe”).

Técnicas comuns:

• Ensembles (ensembles): treinar múltiplos modelos ({\hat{p}_{\theta_i}}) e usar a divergência entre eles como incerteza epistêmica (amplamente usado em métodos no estilo PETS).
• Redes neurais bayesianas (Bayesian neural nets) / inferência aproximada (approximate inference): mais complexas, menos comuns na prática em larga escala.
• Dropout como inferência bayesiana aproximada (dropout as approximate Bayesian inference): às vezes usado como heurística de incerteza.

A incerteza é então usada para:

• penalizar trajetórias arriscadas,
• escolher ações conservadoras,
• impulsionar exploração (buscar estados informativos), relacionando-se a Exploração vs Aproveitamento (Exploration vs Exploitation).

Planejamento no Espaço de Modelo Aprendido

Uma vez que você tenha (\hat{p}_\theta), o planejamento escolhe ações para maximizar o retorno previsto:

[ \max_{a_{t:t+H-1}} \mathbb{E}{\hat{p}\theta}\left[\sum_{k=0}^{H-1} \gamma^k \hat{r}(s_{t+k}, a_{t+k}) \right] ]

onde (H) é o horizonte de planejamento (frequentemente curto na prática para reduzir o erro cumulativo).

Métodos de planejamento (escolhas comuns)

1) Métodos de disparo (shooting methods) + amostragem (CEM / disparo aleatório)

Para ações contínuas, uma abordagem popular é amostrar sequências candidatas de ações, “rolá-las” (rollout) através do modelo e escolher a melhor.

• Disparo aleatório (random shooting): amostrar muitas sequências de ações uniformemente (ou de uma Gaussiana).
• Método da Entropia Cruzada (Cross-Entropy Method, CEM): refina iterativamente uma distribuição de amostragem em direção a sequências de alto retorno.

Isso é simples, paralelizável e robusto quando gradientes não são confiáveis.

2) Otimização de trajetória baseada em gradiente (gradient-based trajectory optimization) (iLQR / MPC diferenciável)

Se o modelo aprendido for diferenciável, você pode retropropagar (backpropagate) através dos rollouts e otimizar ações via descida do gradiente (gradient descent). Isso pode ser eficiente, mas é sensível a mínimos locais (local minima) e a imprecisões do modelo.

3) Busca em árvore (tree search) (planejamento no estilo MCTS)

Para ações discretas, o planejamento pode usar busca lookahead. Sistemas modernos às vezes aprendem dinâmica e valor em espaço latente e usam busca:

• Abordagens no estilo MuZero aprendem um modelo de dinâmica latente e usam MCTS para planejar sem prever explicitamente observações.

Isso conecta o planejamento baseado em modelo a priors fortes aprendidos.

4) Programação dinâmica (dynamic programming, DP) (quando o modelo é conhecido e pequeno)

DP clássica (iteração de valor, iteração de política) é mais comum em cenários tabulares ou quando um bom simulador está disponível, mas é menos comum para modelos neurais aprendidos em controle contínuo.

Controle Preditivo por Modelo (MPC) como estabilizador

Um truque prático essencial é replanejar a cada passo:

• Planejar (H) passos à frente no modelo aprendido.
• Executar apenas a primeira ação.
• Observar o verdadeiro próximo estado.
• Replanejar a partir do estado corrigido.

Isso reduz o dano causado por erros do modelo e perturbações.

Erro Cumulativo e Viés de Modelo

Um desafio central: pequenos erros de previsão de um passo podem explodir ao longo de rollouts longos. Se o erro do modelo de um passo é (\epsilon), então, para horizontes longos, a distribuição de estados prevista pode se afastar muito da realidade, e o planejador pode explorar fraquezas do modelo (uma forma de “hackeamento do modelo (model hacking)”).

Mitigações comuns:

• Horizontes curtos + MPC: reduzir o comprimento do rollout.
• Ensembles + pessimismo (pessimism): otimizar um objetivo conservador, por exemplo, maximizar o retorno de pior caso (worst-case) entre membros do ensemble.
• Treinar com dados on-policy (on-policy): coletar repetidamente dados do controlador atual para que o modelo seja preciso onde importa.
• Regularizar o planejamento: adicionar custos de suavidade de ação, restrições de estado ou penalidades de incerteza.

Um objetivo heurístico prático com um ensemble pode ser:

[ \max_{a_{t:t+H-1}} \left( \mathbb{E}[R] - \lambda \cdot \text{Uncertainty} \right) ]

onde a incerteza pode ser a variância do ensemble dos próximos estados previstos ou dos retornos.

Principais Famílias de Algoritmos de Aprendizado por Reforço Baseado em Modelo

O aprendizado por reforço baseado em modelo não é um único algoritmo, mas um espaço de projeto. Uma taxonomia útil:

1) Controle “puramente” baseado em modelo (aprender modelo, planejar diretamente)

Ideias representativas: métodos no estilo PETS, MPC com ensembles aprendidos.

• Aprender (\hat{p}_\theta) a partir de dados.
• Planejar no modelo a cada passo (frequentemente com CEM).
• Muitas vezes muito eficiente em dados em controle contínuo.

Bom encaixe: controle em robótica, locomoção, manipulação, onde coletar dados é caro.

2) Estilo Dyna (Dyna-style): o modelo gera dados sintéticos para um aprendiz sem modelo

A ideia clássica (Dyna) é:

• Aprender um modelo.
• Usá-lo para gerar transições adicionais (“rollouts imaginados”).
• Treinar uma política/função de valor com dados reais e sintéticos.

Variantes modernas limitam cuidadosamente o comprimento do rollout para evitar erro cumulativo. Um exemplo bem conhecido são estratégias no estilo MBPO: rollouts imaginados curtos anexados a buffers de replay reais.

Isso faz a ponte entre métodos baseados em modelo e sem modelo de Métodos de Aprendizado por Reforço.

3) “Modelos de mundo” latentes (aprender representação + dinâmica)

Quando as observações são de alta dimensionalidade (imagens), o aprendizado do modelo é feito em um espaço latente (latent space):

• Aprender um codificador (encoder) (e(o_t) \to z_t)
• Prever (z_{t+1}) a partir de ((z_t,a_t))
• Decodificar ou usar o latente diretamente para recompensa/valor/política

Sistemas no estilo Dreamer aprendem:

• dinâmica latente,
• previsão de recompensa,
• uma função de valor,
• uma política treinada “dentro” do modelo de mundo.

Essa é uma das abordagens mais escaláveis para controle a partir de pixels.

4) Dinâmica latente + planejamento/busca (MuZero-like)

Esses métodos aprendem:

• uma função de representação,
• uma função de dinâmica latente,
• um preditor de recompensa,
• um prior de valor/política (value/policy prior),

e usam busca (search) (MCTS) para refinar a escolha de ações. Eles não necessariamente buscam reconstruir observações; aprendem as partes do modelo necessárias para planejar.

Bom encaixe: jogos de tabuleiro, tarefas de ação discreta com horizontes longos.

Um Exemplo Prático: Dinâmica Aprendida + MPC com CEM

Abaixo está um esboço simplificado de controle baseado em modelo para uma tarefa de controle contínuo (por exemplo, uma variante de cart-pole ou um pequeno robô). A ideia:

1. Treinar um ensemble de redes neurais para prever (\Delta s = s_{t+1}-s_t).
2. Em tempo de execução, usar CEM para encontrar uma sequência de ações que maximize a recompensa prevista.
3. Executar a primeira ação e replanejar.

import torch
import torch.nn as nn

class DynamicsModel(nn.Module):
    def __init__(self, state_dim, act_dim, hidden=256):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(state_dim + act_dim, hidden),
            nn.ReLU(),
            nn.Linear(hidden, hidden),
            nn.ReLU(),
            nn.Linear(hidden, state_dim),  # predict delta state
        )

    def forward(self, s, a):
        x = torch.cat([s, a], dim=-1)
        delta = self.net(x)
        return s + delta

@torch.no_grad()
def rollout_return(models, s0, action_seq, reward_fn, gamma=0.99):
    # models: list of ensemble models
    # Use ensemble mean prediction (simple variant)
    s = s0
    G = 0.0
    disc = 1.0
    for a in action_seq:
        preds = torch.stack([m(s, a) for m in models], dim=0)
        s = preds.mean(dim=0)
        r = reward_fn(s, a)
        G += disc * r
        disc *= gamma
    return G

@torch.no_grad()
def cem_plan(models, s0, reward_fn, horizon=20, pop=512, iters=5, elite_frac=0.1, act_dim=2):
    mean = torch.zeros(horizon, act_dim)
    std  = torch.ones(horizon, act_dim)

    elite_n = int(pop * elite_frac)
    for _ in range(iters):
        actions = mean + std * torch.randn(pop, horizon, act_dim)
        returns = torch.tensor([
            rollout_return(models, s0, actions[i], reward_fn).item()
            for i in range(pop)
        ])
        elite_idx = torch.topk(returns, elite_n).indices
        elite = actions[elite_idx]
        mean = elite.mean(dim=0)
        std  = elite.std(dim=0).clamp(min=1e-3)

    return mean[0]  # MPC: execute first action only

Sistemas reais adicionam:

• restrições/clipping nas ações,
• penalidades de incerteza (por exemplo, penalizar variância do ensemble),
• rollouts estocásticos melhores (amostrar um modelo por trajetória, ou propagar distribuições),
• computação rápida e vetorizada de rollouts.

Fundamentos Teóricos (O que você está aproximando)

Planejar é “resolver o MDP” dado um modelo

Se você tivesse a verdadeira função de transição (p) e a recompensa (r), poderia computar uma política ótima por planejamento/DP. O aprendizado por reforço baseado em modelo aproxima isso aprendendo (\hat{p}, \hat{r}) a partir de dados.

Erro do modelo induz erro de valor

Intuitivamente, se seu modelo aprendido estiver ligeiramente errado a cada passo, então previsões de múltiplos passos derivam. Muitas análises produzem limites do tipo:

• o erro de valor cresce com o horizonte,
• e com o quanto a política visita estados onde o modelo é impreciso.

É por isso que MB-RL na prática frequentemente:

• usa horizontes curtos + MPC,
• foca a capacidade do modelo em precisão local,
• ou treina políticas que permanecem dentro de regiões bem modeladas.

Observabilidade parcial e estados de crença

Quando você observa apenas (o_t) (não o estado completo), o processo pode ser um processo de decisão de Markov parcialmente observável (Partially Observable Markov Decision Process, POMDP). Métodos baseados em modelo lidam com isso ao:

• aprender um estado latente recorrente (z_t = f(z_{t-1}, a_{t-1}, o_t)),
• planejar no espaço latente,
• tratar (z_t) como um “estado de crença (belief state)” aprendido.

Essa é uma das principais razões pelas quais abordagens de modelo de mundo usam redes neurais recorrentes (recurrent neural networks, RNNs) ou modelos de sequência.

Exploração em Aprendizado por Reforço Baseado em Modelo

Um modelo aprendido pode ajudar na exploração ao quantificar incerteza e guiar o agente em direção a estados informativos:

• Otimismo diante da incerteza: escolher ações que poderiam gerar alta recompensa dadas dinâmicas incertas.
• Objetivos de ganho de informação (information gain objectives): buscar transições que reduzam a incerteza do modelo (aprendizado ativo (active learning)).
• Bônus por discordância (disagreement bonuses): recompensar visitar estados em que os modelos do ensemble discordam.

Isso se conecta diretamente a Exploração vs Aproveitamento, mas MB-RL tem uma vantagem: pode explorar por planejamento em vez de apenas via políticas estocásticas.

Aplicações Práticas

Robótica e controle (um caso de uso emblemático)

• Locomoção de pernas: aprender modelos locais para adaptação rápida.
• Manipulação: MPC em modelos aprendidos pode reduzir testes no mundo real.
• Controle industrial: planejar sob restrições e funções de custo.

Por que MB-RL ajuda: testes físicos são caros e inseguros; modelos viabilizam eficiência amostral e planejamento atento a restrições.

Direção autônoma e navegação

• Modelos preditivos de outros agentes (frequentemente multimodais).
• Planejamento com incerteza e restrições de segurança.
• Integração de dinâmicas aprendidas com planejamento clássico de movimento.

Pesquisa operacional / otimização de sistemas

• Resfriamento de datacenters, gestão de energia, logística.
• Simuladores aprendidos aceleram avaliação e controle de cenários “e se” (what-if).

Jogos (dinâmica latente + busca)

• Sistemas que combinam modelos aprendidos com MCTS podem alcançar forte desempenho onde a profundidade de planejamento importa.

Quando o Aprendizado por Reforço Baseado em Modelo Funciona Bem (e Quando Não)

Funciona bem quando:

• Coletar dados é caro.
• As dinâmicas são aprendíveis e relativamente suaves.
• O planejamento de curto horizonte é suficiente (ou MPC consegue manter você no caminho).
• Você pode explorar estrutura (física conhecida, restrições, modelos parciais).

Enfrenta dificuldades quando:

• As dinâmicas são caóticas ou extremamente de alta dimensionalidade sem bom aprendizado de representações.
• A atribuição de crédito em horizonte longo exige previsões precisas muito no futuro.
• O modelo é explorado pelo planejador (hackeamento de recompensa (reward hacking) dentro do modelo).
• Dados apenas offline são estreitos; o planejamento pode sair da distribuição (fora de distribuição), relacionado a Aprendizado por Reforço Offline (Offline RL).

Relação com Outros Tópicos de Aprendizado por Reforço

• Aprendizado por reforço sem modelo: frequentemente mais simples e muito eficaz com grandes volumes de dados, mas menos eficiente em amostras e menos naturalmente adequado a planejamento com restrições (ver Métodos de Aprendizado por Reforço).
• Problemas de bandit (bandits): nenhum modelo de dinâmica é necessário porque não há evolução de estado no mesmo sentido (ver Problemas de Bandit (Bandits)).
• Cenários multiagente: modelar se torna mais difícil porque a “dinâmica” inclui outros agentes que também aprendem; incerteza e não estacionariedade dominam (ver AR Multiagente (Multi-Agent RL)).
• AR para modelos de linguagem de grande porte (large language models, LLMs): normalmente não é baseado em modelo no sentido de dinâmica do ambiente; embora ideias de “planejamento em espaço latente” apareçam em raciocínio e busca, a maioria dos pipelines de aprendizado por reforço com feedback humano (Reinforcement Learning from Human Feedback, RLHF) está mais próxima de otimização de política do que de aprendizado de dinâmica (ver AR para LLMs (RL for LLMs)).

Dicas de Implementação e Armadilhas Comuns

Dicas

• Comece com MPC + horizonte curto; frequentemente é a baseline mais robusta.
• Use ensembles para incerteza; é prático e eficaz.
• Preveja deltas de estado em vez do próximo estado absoluto em muitos domínios físicos.
• Normalize entradas/saídas e acompanhe métricas de calibração do modelo.
• Atualize regularmente os dados de treinamento com o controlador atual para reduzir mudança de distribuição (distribution shift).

Armadilhas

• Sobreajustar (overfitting) o modelo em um conjunto de dados estreito → o planejador sai da distribuição e falha.
• Planejar por tempo demais → o erro cumulativo domina.
• Ignorar incerteza → políticas frágeis que colapsam em sistemas reais.
• Incompatibilidade do modelo de recompensa → o agente otimiza o objetivo errado (especialmente se a recompensa for aprendida a partir de dados).

Resumo

MB-RL trata de aprender a dinâmica do ambiente e usar esse modelo aprendido para planejar. Pode ser dramaticamente mais eficiente em dados do que abordagens sem modelo e dá suporte natural a restrições e raciocínio de “e se”, mas exige cuidado com erro de modelo, incerteza e mudança de distribuição. A prática moderna frequentemente combina:

• dinâmica aprendida (frequentemente probabilística/por ensemble),
• planejamento de curto horizonte com MPC,
• modelos de mundo latentes para observações de alta dimensionalidade,
• abordagens híbridas que usam rollouts do modelo para treinar políticas sem modelo.

Quando o ambiente é caro para amostrar e as dinâmicas são aprendíveis, MB-RL é um dos paradigmas mais valiosos na prática em aprendizado por reforço.

---