Localizing and Correcting Errors for LLM-based Planners

O artigo propõe o Aprendizado em Contexto Localizado (L-ICL), uma técnica que corrige iterativamente os erros de planejadores baseados em Grandes Modelos de Linguagem (LLMs) ao injetar exemplos de correção específicos para as primeiras violações de restrições, resultando em planos válidos significativamente mais frequentes do que métodos tradicionais em diversas tarefas de planejamento simbólico.

O essencial

Imagine que você tem um assistente de IA muito inteligente, capaz de escrever código complexo e resolver equações matemáticas difíceis. No entanto, quando você pede a ele para planejar um caminho em um jogo de tabuleiro ou organizar blocos, ele frequentemente comete erros bobos: ele faz o personagem atravessar uma parede, pula por cima de um buraco ou tenta empurrar uma caixa para um lugar onde ela fica presa para sempre.

O problema não é que a IA não sabe as regras; o problema é que ela esquece de aplicá-las no momento certo.

Este artigo apresenta uma solução brilhante chamada L-ICL (Aprendizado em Contexto Localizado). Vamos explicar como funciona usando uma analogia simples: o "Chefe de Obra" e o "Aprendiz".

O Problema: O Aprendiz que Aprende de "Cima para Baixo"

Imagine que você está ensinando um aprendiz a construir uma casa.

• O jeito antigo (ICL Tradicional): Você mostra para o aprendiz o vídeo completo de uma casa perfeita sendo construída do início ao fim. Você diz: "Olhe, veja como ficou lindo no final!".

  • O resultado: O aprendiz vê a casa pronta, mas não entende por que ele não pode colocar uma janela no lugar da porta. Ele tenta copiar o resultado, mas erra os detalhes do meio do caminho.

• O jeito novo (L-ICL): Em vez de mostrar a casa pronta, você observa o aprendiz trabalhando. Assim que ele tenta colocar uma janela onde deveria ser uma parede, você para, aponta para aquele único erro e diz: "Ei, aqui não! Olha, se você tentar colocar a janela aqui, ela quebra. A solução correta é colocar a porta aqui."

  • Você não mostra a casa inteira de novo. Você corrige apenas o passo que deu errado, na hora que deu errado.

A Solução: Correções "Localizadas"

A técnica L-ICL funciona exatamente assim:

1. O Teste: A IA tenta resolver um problema (como um labirinto).
2. A Detecção: Um sistema "mágico" (um oráculo) verifica o plano da IA. Assim que a IA faz o primeiro erro (ex: tentar andar para a direita e bater na parede), o sistema para.
3. A Correção Local: O sistema pega aquele erro específico e cria um pequeno exemplo: "Quando o personagem está na posição X, ele não pode ir para a direita. Ele só pode ir para o norte ou sul."
4. O Acúmulo: Esse pequeno exemplo é adicionado às instruções da IA. A IA tenta de novo. Se errar em outro lugar, mais um exemplo é adicionado.

É como se você estivesse "treinando" a IA com um caderno de anotações que cresce a cada erro, mas só com as anotações que realmente importam para corrigir o comportamento.

Por que isso é tão eficiente?

O artigo mostra que essa abordagem é muito mais poderosa do que os métodos atuais por dois motivos principais:

1. Economia de Espaço (Eficiência):

   • Mostrar 20.000 caracteres de um plano perfeito (o jeito antigo) é como tentar ensinar alguém a andar de bicicleta mostrando um vídeo de uma corrida olímpica inteira. É muito informação, mas pouco útil para o passo a passo.
   • O L-ICL usa apenas 2.000 caracteres de correções pontuais. É como dar a receita exata de como não cair da bicicleta. Com muito menos texto, a IA aprende muito mais rápido.

2. Generalização (Aprende a Regra, não o Caminho):

   • A IA não decora o mapa específico do labirinto. Ela aprende a regra: "Não atravesse paredes".
   • Por isso, quando você muda o tamanho do labirinto ou a posição das paredes, a IA continua funcionando bem, porque ela aprendeu o conceito, não apenas a rota.

Os Resultados na Prática

Os pesquisadores testaram isso em vários cenários:

• Labirintos: A IA começou a acertar 89% dos planos (antes, acertava menos de 60%).
• Jogos de Bloco (Sokoban): A IA aprendeu a não empurrar caixas para cantos onde ficariam presas.
• Blocos (BlocksWorld): A IA aprendeu a organizar blocos sem derrubar a torre.

A Grande Lição

A conclusão do artigo é uma lição valiosa não só para IAs, mas para qualquer processo de aprendizado: Não adianta mostrar o sucesso final se você não corrigir os erros no momento em que eles acontecem.

O L-ICL transforma a IA de um "adivinhador" que chuta o caminho, em um "planejador" que respeita as leis da física e as regras do jogo. Ele não faz a IA pensar melhor sobre como chegar ao objetivo (estratégia), mas garante que ela não cometa erros bobos ao tentar chegar lá (validade).

Em resumo: Menos teoria, mais correção no ponto de dor. É assim que se ensina uma máquina a não atravessar paredes.

Resumo técnico

Resumo Técnico: Localizando e Corrigindo Erros para Planejadores Baseados em LLM

1. O Problema

Embora os Grandes Modelos de Linguagem (LLMs) demonstrem capacidades robustas de raciocínio em matemática e codificação, eles falham consistentemente em tarefas de planejamento clássico simbólico. Estudos anteriores e os deste trabalho mostram que planos gerados por LLMs frequentemente violam restrições de domínio explícitas (por exemplo, um agente atravessando paredes em um labirinto ou tentando empurrar um bloco quando a garra já está ocupada).

A hipótese central é que os LLMs não conseguem acessar e aplicar consistentemente o conhecimento específico do domínio presente no prompt, mesmo quando todas as informações (layout, obstáculos, regras) são fornecidas. Métodos tradicionais de In-Context Learning (ICL), que fornecem trajetórias completas de solução, são ineficazes porque demonstram que uma solução funciona, mas não explicam explicitamente por que cada passo individual é válido, deixando as regras implícitas e sujeitas a inferências falhas.

2. Metodologia: L-ICL (Localized In-Context Learning)

Os autores propõem uma nova abordagem chamada Localized In-Context Learning (L-ICL), que visa corrigir erros de forma direcionada e iterativa, em vez de fornecer exemplos completos de solução.

• Base em Program Trace Prompting (PTP): O método utiliza o PTP, onde o raciocínio é reformulado como a geração de um "rastro de execução" (trace) para um programa parcialmente especificado. O LLM recebe a documentação de sub-rotinas (assinaturas e descrições) e deve inferir o comportamento correto, sem ter o código de implementação.
• Identificação do Primeiro Falha: Para cada tarefa de treinamento, o LLM gera um rastro. Um oráculo (um simulador simbólico ou verificador) analisa esse rastro e identifica o primeiro passo onde a saída do LLM viola uma restrição de domínio.
• Correção Localizada: Em vez de rejeitar todo o plano, o sistema gera um exemplo mínimo de entrada-saída (estilo doctest do Python) que corrige especificamente aquele erro.
  • Exemplo: Se o LLM tenta mover para o leste a partir da posição (3,4) através de uma parede, o oráculo gera um exemplo: get_applicable_actions((3,4)) -> ['move north', 'move south'].
• Acúmulo Iterativo: Essas correções localizadas são injetadas na documentação da sub-rotina correspondente no prompt. O processo se repete sobre um conjunto de problemas de treinamento, acumulando um banco de exemplos direcionados que "endurecem" o prompt, ensinando ao modelo as restrições do domínio passo a passo.
• Eficiência de Inferência: Crucialmente, o oráculo é usado apenas durante o treinamento. Na inferência (testes), o LLM executa uma única passagem (single forward pass) sem dependências externas, diferentemente de métodos como ReAct que exigem verificação em tempo de execução.

3. Contribuições Principais

1. Diagnóstico Preciso: O uso do PTP permitiu medir com precisão as taxas de violação de restrições, revelando que a violação de regras é o modo de falha dominante em tarefas de planejamento, e não a incapacidade de encontrar o objetivo.
2. Novo Método (L-ICL): Introdução de uma técnica que melhora a validade do planejamento através de correções localizadas e guiadas por falhas.
3. Superioridade sobre ICL Tradicional: Demonstração de que exemplos localizados superam trajetórias completas recuperadas (RAG-ICL), mesmo quando os últimos usam 10 vezes mais contexto (caracteres).
4. Generalização: Validação consistente em múltiplos domínios (Gridworld, Mazes, Sokoban, BlocksWorld) e em várias arquiteturas de LLM (DeepSeek V3, Claude Haiku/Sonnet).
5. Recursos Abertos: Liberação de um conjunto de benchmarks e código para facilitar pesquisas futuras.

4. Resultados Experimentais

Os experimentos foram conduzidos em diversos domínios, variando de navegação simples a problemas complexos com múltiplos objetos e estados irreversíveis.

• Desempenho no Gridworld 8x8:
  • Zero-Shot: 0% de sucesso (apesar de receber todas as informações).
  • Melhor Baseline (Self-Consistency): 59% de sucesso.
  • L-ICL (com 60 exemplos): 89% de sucesso e 89% de planos válidos.
• Eficiência de Amostra: O L-ICL atinge o pico de desempenho com apenas 30 a 60 exemplos de treinamento.
• Comparação com RAG-ICL:
  • O RAG-ICL com 20.000 caracteres de trajetórias recuperadas atingiu apenas 9% de sucesso.
  • O L-ICL atingiu desempenho superior com apenas ~2.000 caracteres de correções direcionadas.
• Generalização Arquitetural: O método funcionou bem em DeepSeek V3, V3.1, Claude Haiku 4.5 e Claude Sonnet 4.5, com ganhos significativos em todos.
• Limitações Identificadas: O método resolveu eficazmente a violação de restrições (validade), mas a lacuna entre "plano válido" e "plano bem-sucedido" (estratégia) permaneceu em domínios complexos como Sokoban completo. Isso indica que, embora o L-ICL garanta que o agente não atravesse paredes, ele não necessariamente ensina a estratégia de longo prazo para evitar estados armadilha (trap states).

5. Significado e Conclusão

O artigo estabelece que a estrutura dos exemplos de demonstração é mais importante do que a quantidade. Enquanto exemplos completos de trajetória atuam como testes de ponta a ponta (end-to-end), as correções localizadas do L-ICL atuam como testes unitários para o raciocínio do LLM.

Ao transformar o conhecimento implícito em explícito no ponto exato de falha, o L-ICL "endurece" as primitivas de raciocínio do modelo. Isso permite que os LLMs aprendam as leis físicas e restrições de um domínio de forma transferível, sem memorizar layouts específicos. O trabalho sugere um paradigma onde a confiabilidade do LLM é melhorada não por mais dados brutos, mas por correções precisas e localizadas que transformam o modelo em um planejador que respeita rigorosamente as regras do domínio, servindo como uma base confiável para camadas de raciocínio estratégico mais complexas.