🤖 machine learning

From I/O to Code with Discovery Agent

Este artigo apresenta o DIO-Agent, um framework de descoberta que resolve o desafiador problema IO2Code ao enquadrar a síntese de programas como uma busca evolutiva guiada por erros de execução e uma "Premissa de Prioridade de Transformação" para priorizar hipóteses simples, demonstrando desempenho superior aos métodos existentes em um recém-construído IO2CodeBench.

Autores originais: Yihong Dong, Jiaru Qian, Haoran Zhang, Peixu Wang, Binhua Li, Zhi Jin, Yongbin Li, Ge Li, Xiaokang Yang, Xue Jiang

Publicado 2026-05-18

📖 5 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Yihong Dong, Jiaru Qian, Haoran Zhang, Peixu Wang, Binhua Li, Zhi Jin, Yongbin Li, Ge Li, Xiaokang Yang, Xue Jiang

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que você está tentando ensinar um robô a realizar um truque de mágica.

O Jeito Antigo (NL2Code):
Normalmente, você diz ao robô: "Por favor, ordene estes números do menor para o maior." O robô lê suas palavras, lembra de truques semelhantes que aprendeu durante seus estudos e executa a tarefa. Isso é chamado de NL2Code (Linguagem Natural para Código). É como dar a alguém uma receita e pedir que ele prepare o prato.

O Novo Desafio (IO2Code):
Agora, imagine que você não pode falar com o robô. Você não pode dar a ele uma receita. Em vez disso, você apenas mostra alguns exemplos do truque em ação:

Você coloca uma bola vermelha, e ele tira uma bola azul.
Você coloca duas bolas vermelhas, e ele tira uma bola azul e uma bola verde.
Você coloca uma bola azul, e ele não tira nada.

O robô precisa descobrir a regra secreta por trás da mágica apenas observando as entradas e as saídas. Ele precisa adivinhar a "receita" sem nunca ter sido informado sobre quais são os ingredientes. O artigo chama isso de IO2Code (Entrada-Saída para Código).

O problema é que isso é incrivelmente difícil. Se o robô apenas memorizar os exemplos ("Se vermelho, então azul"), ele falha quando você lhe dá uma nova cor. Se ele adivinhar uma regra complexa muito rapidamente, pode ficar preso em um beco sem saída.

A Solução: O "Agente Descobridor" (DIO-Agent)

Os autores criaram um novo agente de IA chamado DIO-Agent para resolver este quebra-cabeça. Eles não deixaram a IA apenas adivinhar aleatoriamente; deram a ela uma estratégia específica baseada em como programadores humanos realmente aprendem.

Veja como o DIO-Agent funciona, usando uma analogia simples:

1. O "Currículo" (Aprendizado por Etapas)

Imagine um videogame onde você começa no "Modo Fácil" e desbloqueia lentamente níveis mais difíceis.

A Estratégia: Em vez de mostrar à IA todos os exemplos de uma vez, o DIO-Agent mostra apenas os mais fáceis primeiro.
Por que ajuda: A IA aprende uma regra simples que funciona para os casos fáceis. Depois, ela recebe alguns exemplos mais difíceis. Se a regra simples falhar, a IA sabe que precisa atualizar sua regra, mas mantém as partes que já estavam funcionando. Ela constrói a complexidade passo a passo, em vez de tentar resolver todo o quebra-cabeça de uma só vez.

2. A "Prioridade de Transformação" (A Regra da Simplicidade)

O artigo usa um conceito da engenharia de software chamado Premissa de Prioridade de Transformação (TPP). Pense nisso como uma regra estrita sobre como a IA pode alterar sua suposição.

A Regra: A IA é forçada a tentar a explicação mais simples possível primeiro.
- Nível 1: "A resposta é apenas um número constante?" (Ex: Sempre retornar 5).
- Nível 2: "Depende diretamente da entrada?" (Ex: Retornar o número que você me deu).
- Nível 3: "Precisamos de uma decisão?" (Ex: Se o número for par, faça X; se for ímpar, faça Y).
- Nível 4: "Precisamos de um loop?" (Ex: Continue fazendo isso até que o número fique pequeno).
Por que ajuda: Isso impede que a IA pule diretamente para uma solução supercomplexa e confusa que, por acaso, funcione para os exemplos específicos, mas esteja na verdade errada. Isso força a IA a "esgotar" ideias simples antes de tentar as complexas, assim como um detetive descartando suspeitos simples antes de procurar um mentor.

3. O "Feedback Baseado em Erros" (Aprendendo com os Erros)

Quando a IA tenta uma suposição e falha, ela não recebe apenas uma pontuação de "Errado".

A Estratégia: O sistema mostra à IA exatamente onde ela falhou. "Você acertou os três primeiros exemplos, mas falhou no quarto porque esqueceu de lidar com números negativos."
Por que ajuda: Isso atua como um treinador apontando um erro específico em um exercício esportivo, em vez de apenas dizer "Você perdeu o jogo". Isso guia a IA a corrigir aquela falha específica em sua lógica.

Os Resultados

Os pesquisadores testaram esse novo agente em um grande conjunto de quebra-cabeças (chamado IO2CodeBench), variando de matemática simples a geometria complexa e até análise de imagem.

O Vencedor: O DIO-Agent superou todos os outros métodos, incluindo ferramentas de programação tradicionais e outros agentes de IA avançados de "evolução".
Eficiência: Ele não venceu apenas adivinhando mais vezes; venceu adivinhando melhor. Encontrou as regras corretas e simples mais rápido e com menos esforço "desperdiçado" do que seus concorrentes.
Generalização: A IA não apenas memorizou os exemplos de treinamento; ela realmente descobriu a lógica subjacente, permitindo que resolvesse corretamente novos problemas nunca antes vistos.

Em Resumo

O artigo argumenta que, embora a IA seja ótima em seguir instruções escritas (NL2Code), ela luta para descobrir regras apenas a partir do comportamento (IO2Code). Ao forçar a IA a aprender em etapas, priorizar soluções simples em vez de complexas e aprender especificamente com seus erros, o DIO-Agent consegue "descobrir" com sucesso as regras ocultas de um sistema, agindo como um verdadeiro detetive científico em vez de apenas uma máquina de memorização.

Resumo Técnico: De I/O para Código com Agente de Descoberta

Definição do Problema: IO2Code

O artigo aborda um desafio fundamental na síntese de programas, distinto do paradigma mainstream de Linguagem Natural para Código (NL2Code). Enquanto o NL2Code depende do alinhamento semântico entre descrições em linguagem natural e código adquirido durante o pré-treinamento, o IO2Code (Entrada-Saída para Código) exige a síntese de um programa generalizado estritamente a partir de um conjunto limitado de pares de entrada-saída (I/O), sem qualquer especificação em linguagem natural.

Os autores argumentam que o IO2Code apresenta desafios significativamente mais severos do que o NL2Code:

Indução vs. Composição: O NL2Code reduz-se largamente à composição e reutilização de padrões de código alinhados com descrições aprendidas. Em contraste, o IO2Code exige indução e descoberta, requerendo que o modelo descubra estruturas algorítmicas latentes, infira relações causais e construa autonomamente lógica completa a partir de comportamento computacional concreto.
Subespecificação: As observações de I/O são inerentemente subespecificadas; múltiplos programas distintos podem ser consistentes com um conjunto finito de exemplos. Isso cria um vasto espaço de hipóteses onde agentes correm o risco de sobreajustar-se a padrões espúrios (memorização) ou vagar por "becos sem saída" estruturalmente complexos, mas incorretos.
Modos de Falha: O artigo identifica dois modos de falha primários nas abordagens existentes:
1. A Armadilha do Sobreajuste: Modelos memorizam exemplos específicos (por exemplo, tabelas de consulta) em vez de generalizar, falhando em entradas não vistas.
2. A Armadilha da Mutação Cega: A busca evolutiva sem orientação estrutural produz programas sintaticamente complexos, mas semanticamente errados, levando a becos sem saída estruturais dos quais é difícil escapar.

Metodologia: DIO-Agent

Para abordar esses desafios, os autores propõem o DIO-Agent, um agente de descoberta que enquadra o IO2Code como uma busca evolutiva sobre o espaço de programas discretos. O método integra três componentes principais:

1. Evolução Baseada em Currículo

O processo de busca é organizado em estágios de dificuldade crescente.

Construção do Currículo: Exemplos visíveis são ordenados do fácil ao difícil com base na complexidade de entrada/saída.
Progressão por Estágio: O agente começa com um subconjunto de exemplos fáceis ( $C_1$ ) e introduz progressivamente exemplos mais difíceis ( $C_2, \dots, C_S$ ).
Inicialização: Para cada novo estágio $s$ , a busca é inicializada com o melhor programa encontrado no estágio $s-1$ , em vez de recomeçar do zero. Isso permite que o agente refine programas parcialmente corretos em vez de redescobrir lógica básica.

2. Mutação Guiada pela Premissa de Prioridade de Transformação (TPP)

Inspirado pela Premissa de Prioridade de Transformação (TPP) do Desenvolvimento Guiado por Testes (TDD), o DIO-Agent introduz um prior estrutural para enviesar o Modelo de Linguagem de Grande Escala (LLM) durante a mutação.

Complexidade Ordenada: O LLM é instruído a aplicar transformações em uma ordem específica de complexidade estrutural crescente: nil $\to$ constante $\to$ variável $\to$ incondicional $\to$ condicional $\to$ iteração $\to$ recursão.
Mecanismo: O agente deve esgotar hipóteses mais simples (por exemplo, retornar uma constante ou uma variável) antes de tentar construções mais complexas (por exemplo, loops ou condicionais). Isso impede que a busca salte prematuramente para soluções complexas e de sobreajuste, forçando o agente a identificar a regra mínima suficiente.
Implementação: O LLM é instruído a propor diffs SEARCH/REPLACE em vez de reescritas completas, preservando o código funcional enquanto adere à ordenação de complexidade.

3. Feedback Fundamentado em Erros

Em vez de depender apenas de pontuações de precisão escalares, o DIO-Agent utiliza artefatos de feedback estruturados.

Casos de Falha Concretos: O avaliador executa programas candidatos tanto no conjunto atual do currículo quanto em um conjunto de replay de exemplos anteriores. Ele retorna casos de falha específicos (saídas incompatíveis ou erros de tempo de execução).
Cadeia de Feedback: Esses erros concretos, juntamente com uma cadeia herdada de feedback de programas ancestrais, são injetados no prompt para mutações subsequentes. Isso fornece ao LLM evidências explícitas de depuração em vez de recompensas abstratas.
Pontuação: Uma pontuação de seleção por nível de estágio equilibra a precisão no currículo atual contra penalidades por complexidade e memorização (sobreposição entre I/Os fornecidos e código gerado).

Contribuições Principais

Formalização do IO2Code: O artigo define o IO2Code como uma tarefa distinta focada em indução e descoberta, contrastando-a com a tarefa NL2Code, rica em composição.
IO2CodeBench: Os autores constroem um novo benchmark abrangendo quatro níveis de dificuldade: Base (operações escalares/lista), Algoritmo (raciocínio complexo), Geometria (cálculo espacial) e Multimodal (extração de imagem para numérico). O benchmark inclui 125 tarefas com divisões estritas de treino-teste para evitar vazamento.
Arquitetura DIO-Agent: A proposta de um loop evolutivo estruturado combinando aprendizado por currículo, mutação guiada por TPP e feedback fundamentado em erros para navegar no espaço de programas subespecificado.
Exploração Ativa: O artigo demonstra a capacidade do agente em um cenário de "Descoberta Autônoma", onde o modelo projeta ativamente seus próprios exemplos de I/O para consultar um oráculo de verdade fundamental, validando ainda mais a capacidade do agente de resolver ambiguidades lógicas.

Resultados Experimentais

Extensos experimentos no IO2CodeBench demonstram que o DIO-Agent supera consistentemente as abordagens existentes:

Desempenho: O DIO-Agent alcança resultados de ponta em todos os níveis de dificuldade.
- Nível Base: 61,29% (igualando a melhor linha de base).
- Nível Algoritmo: 71,43% (superando todas as linhas de base).
- Nível Geometria: 61,11% (uma melhoria substancial sobre os 44,44% do CodeEvolve).
- Nível Multimodal: 40,67% (quase dobrando os 22,00% do AlphaEvolve).
Generalização: O método mostra ganhos robustos de desempenho em diversos LLMs base (DeepSeek V3.2, Qwen-3.6-Plus, Claude-Sonnet-4.6), confirmando que é agnóstico ao modelo.
Eficiência: O DIO-Agent é mais eficiente em tokens do que outras linhas de base evolutivas (por exemplo, 3.738 tokens/iteração vs. 5.829 para o CodeEvolve), indicando um processo de busca direcionado em vez de geração à força bruta.
Comparação com Escalonamento: O DIO-Agent supera significativamente estratégias de escalonamento em tempo de teste (Direto, Best-of-N, Autoconsistência), mesmo quando essas linhas de base recebem orçamentos de amostragem equivalentes (N=40). Isso sugere que o refinamento sistemático via busca iterativa é superior à amostragem independente repetida para descoberta de programas.
Estudos de Ablação: A remoção da Evolução Baseada em Currículo causou a maior queda de desempenho (58,63% $\to$ 51,33%), destacando seu papel crítico na poda de caminhos improdutivos. A remoção da TPP também levou a declínios significativos, particularmente nas tarefas de Geometria e Algoritmo.

Significado e Alegações

O artigo alega que o IO2Code representa um "santo graal" da ciência da computação que permanece em grande parte não resolvido em comparação com o NL2Code. O significado deste trabalho reside em:

Mudança de Paradigma: Ir além da geração de código impulsionada por linguagem natural para a descoberta de programas impulsionada por comportamento, o que é essencial para tarefas como migração de sistemas legados, engenharia reversa de APIs de caixa preta e abdução de algoritmos científicos.
Restrições Estruturais: Demonstrar que a aplicação de princípios de engenharia de software (especificamente a TPP do TDD) como uma restrição estrutural em agentes autônomos mitiga efetivamente o sobreajuste e guia a busca através de vastos espaços de hipóteses.
Generalização: Provar que a busca evolutiva estruturada e impulsionada por feedback pode melhorar significativamente as capacidades de indução e descoberta dos LLMs em diversos domínios e bases de modelos, empurrando o teto da descoberta automatizada de programas além do que é alcançável através de simples prompting ou escalonamento.

Os autores concluem que seu trabalho chama a atenção para o problema mais amplo da descoberta de programas a partir do comportamento de I/O e inspira exploração adicional além da geração impulsionada por linguagem natural.