Aprendizado por Imitação

Visão geral

Aprendizado por Imitação (Imitation Learning, IL) é uma família de métodos para aprender uma política — um mapeamento de observações/estados para ações — usando demonstrações de um especialista (um operador humano, um controlador clássico ou outro algoritmo). Em vez de especificar uma função de recompensa e descobrir o comportamento por tentativa e erro (como em Aprendizado por Reforço), o IL aproveita diretamente exemplos de “o que fazer”.

Em robótica, o IL é especialmente atraente porque:

Projetar funções de recompensa densas e confiáveis costuma ser difícil.
A exploração no mundo real é cara e arriscada (veja Segurança em Robótica).
Demonstrações podem codificar habilidades sutis (manipulação rica em contato, comportamentos de recuperação) que são difíceis de projetar manualmente.

Este artigo foca na ideia central e no baseline mais comum: Clonagem Comportamental (Behavioral Cloning, BC).

Configuração do problema e notação

A maior parte do IL é formulada em um Processo de Decisão de Markov (Markov Decision Process, MDP):

Estado (s \in \mathcal{S}) (às vezes não observado diretamente)
Observação (o \in \mathcal{O}) (imagens de câmera, propriocepção etc.)
Ação (a \in \mathcal{A}) (torques das juntas, velocidades das juntas, comandos da garra)
Dinâmica (p(s_{t+1}\mid s_t, a_t))
Política (\pi(a\mid o))

Um especialista (ou demonstrador) fornece trajetórias:

[ \tau = (o_1, a_1, o_2, a_2, \dots, o_T, a_T) ]

Um conjunto de dados de demonstrações é:

[ \mathcal{D} = {,(o_i, a_i),}_{i=1}^{N} ]

O objetivo do IL é aprender uma política (\pi_\theta) que tenha bom desempenho quando executada em malha fechada (closed-loop) no robô ou em simulação.

Clonagem Comportamental (BC): a abordagem básica

Ideia-chave

Clonagem Comportamental reduz aprendizado por imitação a aprendizado supervisionado (supervised learning):

Entradas: observações (o)
Alvos: ações do especialista (a)
Modelo: (\pi_\theta(a\mid o))

Você ajusta (\theta) para maximizar a verossimilhança das ações do especialista (ou minimizar uma perda de regressão/classificação).

Funções objetivo

O objetivo de treinamento mais comum é máxima verossimilhança (maximum likelihood):

[ \theta^* = \arg\max_\theta \sum_{(o,a)\in\mathcal{D}} \log \pi_\theta(a\mid o) ]

Formas equivalentes dependem do espaço de ações:

Ações discretas (por exemplo, “virar à esquerda / direita / frente”): perda de entropia cruzada.
Ações contínuas (típico em robótica): regressão das ações com verossimilhança Gaussiana.

Uma parametrização comum para ações contínuas:

[ \pi_\theta(a\mid o) = \mathcal{N}\big(\mu_\theta(o), \Sigma_\theta(o)\big) ]

O treinamento então minimiza a log-verossimilhança negativa. Se você fixa (\Sigma) e prevê apenas (\mu), isso se assemelha ao erro quadrático médio (mean-squared error, MSE), mas políticas probabilísticas geralmente são mais robustas e melhor calibradas.

Por que BC é popular

Simples e estável de treinar (receitas padrão de aprendizado profundo).
Eficiente em dados em comparação com RL online para muitas tarefas.
Fácil de incorporar grandes modelos de percepção (Redes Neurais, backbones de visão, transformers).

A fraqueza central: deslocamento de covariáveis (erro acumulado)

BC aprende a partir dos estados visitados pelo especialista. Mas quando a política aprendida comete pequenos erros, ela pode derivar para estados que não estão presentes no conjunto de dados. Então os erros se acumulam ao longo do tempo.

Isso é frequentemente chamado de mudança de distribuição (distribution shift):

Distribuição de treino: (o \sim d_{\pi_E}) (distribuição de estados do especialista)
Distribuição de teste: (o \sim d_{\pi_\theta}) (distribuição de estados do aprendiz)

Um resultado teórico clássico (Ross & Bagnell, 2010) mostra que BC pode incorrer em erro que cresce com o horizonte (T) sob suposições leves, porque erros movem o agente para estados desconhecidos.

Em termos de robótica: um pequeno erro de pose leva a um contato diferente, que leva a um erro maior, levando a falha.

Demonstrações: como os dados são coletados em robótica

Demonstrações em robótica frequentemente vêm de:

Teleoperação (controladores de VR, spacemouse, joystick, dispositivos hápticos)
Ensino cinestésico (kinesthetic teaching) (guiar fisicamente um robô complacente)
Controladores roteirizados ou clássicos (por exemplo, um controlador MPC gerando trajetórias “especialistas”; veja Controle)
Planejadores de movimento fornecendo trajetórias que podem ser rastreadas (veja Planejamento de Movimento)

Demonstrações tipicamente incluem:

Observações: imagens, profundidade, nuvens de pontos, estados das juntas, pose do efetuador final
Ações: velocidades/posições das juntas, comandos delta cartesianos, abrir/fechar garra
Opcional: instrução em linguagem, ID de tarefa, imagem-alvo ou rótulos de recompensa

Conselho prático: o que torna um bom conjunto de dados para BC?

Cobertura de recuperações: inclua estados “quase falhos” e como especialistas se recuperam.
Diversidade: condições iniciais variadas, poses de objetos, iluminação, fundos.
Semântica consistente de ações: evite misturar diferentes modos de controle sem rotulagem.
Sincronização e controle de latência: o alinhamento observação-ação importa muito em robôs reais.
Calibração e normalização: referenciais consistentes, unidades e escalonamento.

Essas questões interagem fortemente com a pilha mais ampla de robótica — veja Percepção → Planejamento → Controle.

Um exemplo concreto de BC (conceitual)

Considere um robô móvel que deve seguir um corredor usando uma câmera frontal. O especialista dirige com um joystick:

Observação (o_t): imagem RGB (por exemplo, 128×128)
Ação (a_t): ângulo de direção (contínuo) e velocidade (contínua)

Você treina uma rede para prever ((\text{steer}, \text{speed})) a partir de imagens. Em simulação pode funcionar bem, mas em um robô real pode derivar em direção a uma parede devido a erros acumulados e mudanças de iluminação. Correções podem incluir adicionar demonstrações de recuperação, injetar ruído durante o treino e usar uma política estocástica.

Loop mínimo de clonagem comportamental no estilo PyTorch (ilustrativo)

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader

class Policy(nn.Module):
    def __init__(self, obs_dim, act_dim, hidden=256):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(obs_dim, hidden), nn.ReLU(),
            nn.Linear(hidden, hidden), nn.ReLU()
        )
        self.mu = nn.Linear(hidden, act_dim)
        # Log-std can be state-dependent or a learned global vector
        self.log_std = nn.Parameter(torch.zeros(act_dim))

    def forward(self, obs):
        h = self.net(obs)
        mu = self.mu(h)
        std = torch.exp(self.log_std).clamp(min=1e-3, max=10.0)
        return mu, std

def gaussian_nll(mu, std, a):
    # Negative log likelihood of diagonal Gaussian
    var = std**2
    return 0.5 * (((a - mu)**2) / var + 2*torch.log(std) + torch.log(torch.tensor(2.0*3.14159265))).sum(dim=-1)

policy = Policy(obs_dim=64, act_dim=4)  # toy dimensions
opt = optim.Adam(policy.parameters(), lr=3e-4)

for epoch in range(50):
    for obs, act in DataLoader(dataset, batch_size=256, shuffle=True):
        mu, std = policy(obs)
        loss = gaussian_nll(mu, std, act).mean()

        opt.zero_grad()
        loss.backward()
        nn.utils.clip_grad_norm_(policy.parameters(), 1.0)
        opt.step()

Notas:

Para imagens, substitua a MLP por uma CNN ou um backbone de transformer de visão.
Para sequências/observabilidade parcial, use uma RNN ou transformer sobre uma janela de histórico.

Observabilidade parcial e modelos de sequência

Robôs frequentemente operam sob observabilidade parcial (partial observability): um único frame pode não revelar velocidade, estado de contato ou intenção. BC pode ser estendido ao condicionar no histórico:

Empilhamento de frames (frame stacking): (\pi(a_t \mid o_{t-k:t}))
Políticas recorrentes (recurrent policies): (\pi(a_t \mid o_t, h_t)) onde (h_t) é um estado oculto de RNN
Políticas baseadas em transformer (transformer-based policies): atenção sobre observações/ações passadas

A modelagem de sequência é particularmente útil para manipulação, onde dinâmicas de contato e intenção evoluem ao longo do tempo.

Mitigando falhas de BC: técnicas práticas

Mesmo que você fique apenas com BC, várias técnicas lidam com deslocamento de covariáveis e robustez.

1) Coletar demos melhores (cobertura + recuperação)

Um truque simples, porém poderoso: após treinar uma política inicial, deixe o especialista intervir quando o robô começar a derivar. Adicione esses segmentos corrigidos ao conjunto de dados.

Essa é a intuição por trás de Agregação de Conjunto de Dados (Dataset Aggregation, DAgger) (veja abaixo), mas você pode aplicá-la informalmente.

2) Injeção de ruído e perturbações

Torne o aprendiz robusto a pequenos desvios treinando com entradas perturbadas:

Aumento de observação (jitter de cor, desfoque, recortes aleatórios)
Perturbações de estado em simulação
Ruído de ação durante rollouts (com cuidado, por segurança)
Randomização de domínio (se conecta a Sim2Real)

3) Políticas estocásticas e multimodalidade

Muitas tarefas têm múltiplas ações válidas. Regressão pura com MSE tende a fazer média entre modos (por exemplo, “ir à esquerda” e “ir à direita” fazem média em “ir em frente”, o que pode ser inválido).

Abordagens comuns:

Prever uma distribuição (Gaussiana, mistura de Gaussianas)
Usar modelos de ação baseados em difusão (“políticas de difusão”) para controle multimodal complexo
Usar discretização + classificação para bins de ação (às vezes estável)

4) Controle híbrido: aprender decisões de alto nível, manter controle estabilizador de baixo nível

Um padrão comum em robótica:

A política aprendida gera waypoints ou alvos do efetuador final
Um controlador clássico os rastreia (PID/MPC) (veja Controle)

Isso pode melhorar muito estabilidade e segurança, e reduz a carga de aprendizado.

Além do BC “vanilla”: principais algoritmos de aprendizado por imitação

BC é o baseline; outros algoritmos de IL principalmente atacam a mudança de distribuição e/ou reduzem a necessidade de rótulos de ação.

DAgger (Dataset Aggregation)

DAgger coleta dados iterativamente sob a distribuição de estados do aprendiz, consultando o especialista pela ação correta:

Treine (\pi_1) em demos do especialista.
Execute um rollout de uma mistura de especialista e aprendiz para visitar “estados do aprendiz”.
Peça ao especialista a ação correta nas observações visitadas.
Agregue em (\mathcal{D} \leftarrow \mathcal{D} \cup \mathcal{D}_{\text{new}}) e retreine.

Isso mira diretamente o problema de deslocamento de covariáveis e tem fortes garantias teóricas sob suposições.

Em robótica, DAgger frequentemente se parece com autonomia compartilhada (shared autonomy): o robô age e o humano corrige.

Aprendizado por Reforço Inverso (Inverse Reinforcement Learning, IRL)

Em vez de aprender (\pi(a\mid o)) diretamente, IRL aprende uma função de recompensa (r(s,a)) que explica o comportamento do especialista e então deriva uma política via RL/planejamento.

Prós:

Pode generalizar melhor entre dinâmicas/objetivos se a recompensa capturar a intenção.
Pode ser combinado com pilhas de planejamento.

Contras:

Mais complexo; tipicamente exige mais computação; frequentemente precisa de interação com o ambiente.

Uma forma moderna popular é a imitação adversarial (abaixo).

Imitação adversarial: GAIL / AIRL

GAIL (Generative Adversarial Imitation Learning) aprende uma política cujas trajetórias correspondem às trajetórias do especialista usando um discriminador que tenta distinguir especialista vs. aprendiz.

Útil quando ações do especialista são ruidosas ou indisponíveis, mas trajetórias de estados são.
Tipicamente requer rollouts on-policy (mais parecido com RL), o que pode ser caro em robôs reais.

Onde o aprendizado por imitação se encaixa na pilha de robótica

IL raramente é “apenas uma rede neural”. Ele precisa se integrar com:

Percepção (extração de características de câmeras, profundidade, tato)
Planejamento (opcional: gerar referências ou restrições)
Controle (rastreamento, estabilização, proteções de segurança)

Veja Percepção → Planejamento → Controle para como essas peças se conectam.

Exemplo: manipulação com controle delta do efetuador final

Uma configuração comum de BC para manipulação:

Observação: imagem RGB-D + propriocepção do robô
Ação: ((\Delta x, \Delta y, \Delta z, \Delta \text{yaw}, \text{grip}))
Controlador de baixo nível: converte deltas em comandos de juntas e impõe limites

Essa decomposição muitas vezes supera prever torques diretamente, porque é mais fácil de aprender e mais seguro de implantar.

Avaliação: como saber se BC realmente funciona

Métricas supervisionadas offline não são suficientes. Você deve medir:

Métricas offline (úteis, mas limitadas)

MSE de ação / log-verossimilhança negativa em um conjunto de demos separado
Acurácia de classificação (ações discretas)
Calibração da incerteza prevista (para políticas estocásticas)

Métricas online (o que importa)

Taxa de sucesso da tarefa sob condições iniciais randomizadas
Tempo até falha, taxa de colisão
Desvio de trajetória em relação ao especialista (se fizer sentido)
Robustez sob perturbações (ruído na pose do objeto, mudanças de iluminação)

Em robótica, avalie primeiro em simulação, depois cuidadosamente no mundo real com checagens de segurança (veja Segurança em Robótica).

Considerações práticas de implantação

Segurança e proteções

Proteções comuns em torno de uma política de IL:

Clipping de ação e imposição de limites das juntas
Limites de velocidade/aceleração
Restrições de espaço de trabalho (zonas proibidas)
Parada de emergência e override humano
Controlador de “fallback” (por exemplo, parar, recuar ou trocar para um planejador seguro)

Transferência sim-para-real

Políticas de BC treinadas em simulação frequentemente enfrentam um gap de realidade:

Diferenças visuais (texturas, iluminação)
Incompatibilidade de dinâmica (atrito, complacência, folga mecânica)
Ruído e latência de sensores

Mitigações:

Randomização de domínio e aumento (Sim2Real)
Ajuste fino (fine-tuning) com demonstrações reais
Uso de representações robustas a mudança de aparência

Escala do conjunto de dados e modelos de base

Tendências recentes incluem treinar políticas grandes e multitarefa a partir de conjuntos de dados robóticos diversos (frequentemente com condicionamento por linguagem). Esses sistemas ainda dependem fortemente de perdas no estilo imitação, mas podem incorporar:

Encoders de visão pré-treinados
Modelos de sequência com transformer
Conjuntos de dados heterogêneos em grande escala, entre robôs e tarefas

Mesmo nesses sistemas modernos, objetivos no estilo BC permanecem um ingrediente central, com mecanismos adicionais para melhorar generalização e segurança.

Quando usar aprendizado por imitação vs. aprendizado por reforço

IL é uma boa opção quando:

Especialistas conseguem demonstrar a tarefa com segurança.
Projetar a recompensa é difícil ou ambíguo.
Você precisa de iteração rápida e treino estável.

RL é atraente quando:

Demonstrações não estão disponíveis ou são insuficientes.
Você precisa de otimização super-humana além de demos humanas.
Desempenho fino é importante e você pode simular ou explorar com segurança.

Uma receita prática comum é IL → ajuste fino com RL (RL fine-tuning):

Use BC para inicializar uma política competente.
Ajuste com RL para melhorar robustez e desempenho (frequentemente em simulação primeiro).

Armadilhas comuns e checklist de troubleshooting

Boa perda de validação, rollouts ruins: provavelmente deslocamento de covariáveis; adicione dados de recuperação, considere intervenções no estilo DAgger.
Ações tremidas: adicione suavização de ações, preveja distribuições ou use um controlador de nível mais baixo para suavização.
Média de comportamentos multimodais: use políticas estocásticas/multimodais (densidade por mistura, difusão) ou adicione condicionamento por objetivo.
Problemas de latência: corrija alinhamento temporal; inclua observações passadas; garanta consistência da taxa de controle.
Overfitting ao fundo: aumentos mais fortes; maior diversidade de dados; considere aprendizado de representações.

Resumo

Aprendizado por imitação aprende políticas de robôs a partir de demonstrações, muitas vezes com muito menos tentativa e erro do que aprendizado por reforço. Clonagem Comportamental é a abordagem mais simples e amplamente usada: tratar o aprendizado de política como aprendizado supervisionado a partir de pares ((o, a)).

O principal desafio conceitual é o deslocamento de covariáveis — erros se acumulam à medida que a política aprendida visita estados não cobertos por demonstrações. Correções práticas vão desde coletar dados de recuperação e adicionar perturbações, até abordagens fundamentadas como DAgger, e métodos mais avançados como IRL e imitação adversarial.

Em sistemas robóticos reais, o sucesso do aprendizado por imitação depende tanto de coleta de dados, avaliação, restrições de segurança e integração com controladores e planejadores quanto do próprio algoritmo de aprendizado.