💬 NLP

Teaching Language Models to Think in Code

O artigo apresenta o ThinC, um framework que desloca o raciocínio de modelos de linguagem de uma intercalação de linguagem natural e código para um paradigma centrado em código, onde o próprio código atua como o principal raciocinador, alcançando desempenho de última geração em benchmarks de matemática de nível competitivo por meio da destilação de trajetórias de código e do emprego de ajuste fino supervisionado seguido por aprendizado por reforço.

Autores originais: Hyeon Hwang, Jiwoo Lee, Jaewoo Kang

Publicado 2026-05-11

📖 5 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Hyeon Hwang, Jiwoo Lee, Jaewoo Kang

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 resolver um quebra-cabeça matemático muito complicado. Você tem duas maneiras de fazê-lo:

O Jeito Antigo (Raciocínio Intercalado): Você fala consigo mesmo em inglês, planejando os passos. "Certo, primeiro preciso multiplicar 500 por 0,12..." Então, você fica um pouco inseguro, então pede a uma calculadora (a ferramenta de código) para verificar seu trabalho. Mas aqui está a pegadinha: se você cometeu um erro no seu raciocínio em inglês (como dizer que 500 vezes 0,12 é 50 em vez de 60), você pode acidentalmente digitar esse número errado na calculadora. A calculadora apenas faz o que você manda; ela não sabe que você cometeu um erro. Ela calcula com base no seu número errado, e você obtém uma resposta errada.
O Jeito Novo (THINC): Você tira um pequeno momento para planejar sua estratégia em inglês ("Preciso encontrar a área desta forma"), e então entrega imediatamente todo o trabalho para um programador robô. O robô escreve código, executa-o, vê o resultado, escreve mais código com base nesse resultado e continua até que a resposta apareça. Você não faz nenhuma matemática na cabeça ou em frases em inglês; o robô faz todo o trabalho pesado.

Este artigo apresenta o THINC (Pensando em Código), uma nova maneira de ensinar modelos de IA a resolver problemas matemáticos, permitindo que o próprio código seja o pensador, em vez de ser apenas uma ferramenta que a IA usa para verificar seu trabalho.

O Problema com o Jeito Antigo

Os autores afirmam que os modelos de IA atuais que misturam raciocínio em inglês com código (chamados de Raciocínio Integrado a Ferramentas) têm três falhas principais, que eles chamam de "limitações estruturais":

O Verificador "Post-Hoc": A IA frequentemente escreve toda a solução em inglês primeiro, e depois executa o código apenas para dizer: "Sim, está certo". O código não está realmente fazendo o pensamento; é apenas um selo de aprovação no final.
O "Erro Silencioso": Se a IA comete um erro matemático em seus pensamentos em inglês (como calcular 12% de 500 como 50 em vez de 60), ela pode copiar esse número errado para o código. O código então calcula com o número errado, e a IA nunca percebe. O erro é "silencioso" porque o código apenas segue ordens.
O "Trabalho Duplo": A IA frequentemente escreve uma longa explicação em inglês de como resolver o problema, e depois escreve código que faz exatamente a mesma coisa. É como escrever uma receita em inglês e depois escrever a mesma receita exata em francês, apenas para provar que você sabe cozinhar. É redundante e confuso.

A Solução THINC

O THINC muda as regras do jogo. Em vez de a IA falar sobre a matemática, a IA fala na matemática (via código).

O Plano: A IA começa com uma única frase curta em inglês para definir a estratégia (por exemplo, "Vou iterar sobre números para encontrar a resposta").
O Trabalho: Após essa única frase, tudo acontece em blocos de código. A IA escreve um trecho de código, executa-o, vê a saída e, em seguida, escreve o próximo trecho de código com base nessa saída.
O Resultado: A resposta final vem diretamente da calculadora do computador (o interpretador), e não de um palpite da IA em inglês.

Como Eles Ensinaram a IA

Os pesquisadores não apenas disseram à IA para fazer isso; eles a ensinaram através de um processo de três etapas:

Destilação (O Professor): Eles pegaram um modelo de IA muito inteligente e grande e pediram que ele resolvesse problemas matemáticos usando esse novo estilo "Código Primeiro". Eles coletaram 12.200 exemplos dessas soluções perfeitas "Código Primeiro".
Ajuste Fino Supervisionado (O Aluno): Eles ensinaram dois modelos de IA menores (um com 1,7 bilhão de "células cerebrais" e outro com 4 bilhões) a imitar esses exemplos. Isso ensinou aos modelos o hábito de pensar em código.
Aprendizado por Reforço (O Treinador): Eles deixaram os modelos praticarem em milhares de problemas matemáticos. Se o modelo obtivesse a resposta correta, recebia uma "recompensa". Se falhasse, aprendia a tentar uma estratégia de código diferente. Isso tornou os modelos muito mais inteligentes e confiáveis.

Os Resultados: Modelos Pequenos, Grandes Vitórias

O artigo testou esses novos modelos em concursos matemáticos muito difíceis e de nível competitivo (como AIME e HMMT).

Derrotando os Gigantes: O pequeno modelo THINC de 4 bilhões de parâmetros obteve 78,1% em média. Isso é melhor que o modelo de 1,7B, melhor que outros modelos "Integrados a Ferramentas" e até melhor que um modelo massivo de 235 bilhões de parâmetros que pensa apenas em inglês!
Confiabilidade: Em 99,2% dos casos, a resposta final foi extraída diretamente da saída do código do computador. A IA não chutou; ela calculou.
Recuperando-se: Se o código cometesse um erro e travasse (um erro), o modelo THINC era surpreendentemente bom em corrigi-lo no próximo bloco de código, sem precisar "falar" para sair da situação. Outros modelos que misturam inglês e código tendem a desmoronar quando encontram um erro de código.

A Conclusão

O artigo afirma que, ao forçar a IA a parar de "falar" sobre a matemática e começar a "fazer" a matemática em código, os modelos tornam-se mais precisos, cometem menos erros aritméticos bobos e resolvem problemas difíceis com mais eficiência. É como trocar um humano tentando fazer divisão longa na cabeça por um humano que sabe programar uma calculadora para fazer isso por ele, passo a passo, sem nunca cometer um erro de cálculo mental.

Resumo Técnico: Ensinar Modelos de Linguagem a Pensar em Código (THINC)

Declaração do Problema

Embora o Raciocínio Integrado a Ferramentas (TIR) tenha se tornado um paradigma dominante para a resolução de problemas matemáticos em Modelos de Linguagem de Grande Escala (LLMs), a configuração "intercalada" predominante — onde o raciocínio em linguagem natural (NL) alterna com a execução de código — sofre de três limitações estruturais:

Verificação Post-hoc: Os modelos frequentemente completam derivações em NL e usam o código apenas para confirmar a resposta, tornando o interpretador um verificador passivo em vez de um raciocinador ativo.
Cálculo NL Não Confiável: Etapas intermediárias de aritmética ou álgebra realizadas em NL são propensas a erros. Quando esses valores errôneos são copiados para blocos de código subsequentes como constantes codificadas manualmente, o interpretador não consegue detectar o erro, levando à propagação silenciosa de erros.
Papéis Mal Distribuídos: NL e código frequentemente realizam tarefas sobrepostas. O NL descreve frequentemente algoritmos passo a passo que o código posteriormente reimplanta, falhando em aproveitar as forças distintas de cada modalidade (NL para planejamento de alto nível, código para execução precisa).

Metodologia

Os autores propõem o THINC (Thinking in Code), um framework de treinamento projetado para deslocar o principal fardo do raciocínio da linguagem natural para a execução de código.

1. O Formato de Trajetória THINC

Diferentemente das trajetórias TIR padrão ( $q, t_1, c_1, o_1, t_2, c_2, o_2, \dots$ ), uma trajetória THINC ( $q, t_1, c_1, o_1, c_2, o_2, \dots$ ) impõe uma separação estrutural estrita:

Única Etapa de Planejamento ( $t_1$ ): O modelo gera um único bloco breve em NL no início para definir a estratégia de alto nível ou a reestruturação algébrica do problema. Crucialmente, este bloco não contém derivação passo a passo ou cálculo numérico.
Raciocínio Centrado em Código: Todo o raciocínio subsequente se desenrola através de blocos de código ( $c_i$ ) conectados apenas por suas saídas de execução ( $o_i$ ). Não há blocos de pensamento em NL intermediários entre as execuções de código.
Interpretador como Raciocinador: Os blocos de código realizam as derivações, auto-correções e verificações. A resposta final é derivada diretamente da saída do interpretador.

2. Pipeline de Treinamento

O framework é realizado através de três etapas:

Destilação de Trajetória: Um modelo professor (Qwen3.5-27B) é instruído com exemplos few-shot para gerar 12.200 trajetórias centradas em código. Estas são filtradas para garantir correção, execução bem-sucedida, um mínimo de três blocos de código e que o pensamento de planejamento constitua menos de 50% do total de tokens.
Ajuste Fino Supervisionado (SFT): Modelos estudantes (Qwen3-1.7B e Qwen3-4B-Thinking-2507) são ajustados finamente no conjunto de dados THINC-SFT destilado. Isso estabelece o "priori de comportamento centrado em código", ensinando o modelo a aderir ao formato específico de trajetória.
Aprendizado por Reforço (RL): Usando Otimização de Política Relativa de Grupo (GRPO) com recompensas verificáveis (correspondência exata com a verdade fundamental), os modelos são refinados adicionalmente no conjunto de dados DAPO-Math-17k. O processo de RL emprega um currículo de três etapas com comprimentos de contexto crescentes (16K a 32K) e limites de chamadas de ferramenta para lidar com problemas mais difíceis.

Contribuições Principais

Framework THINC: Um paradigma de treinamento inovador que trata o código como o principal raciocinador em vez de uma ferramenta invocada pelo NL. Ele resolve as limitações estruturais do TIR intercalado por design.
Conjunto de Dados THINC-SFT: Um conjunto de dados curado de 12,2 mil trajetórias centradas em código que demonstram o formato de raciocínio desejado.
Modelos THINC: Dois modelos treinados, THINC-1.7B e THINC-4B, que demonstram que modelos de pequena escala podem alcançar capacidades de raciocínio de alto nível quando treinados com este paradigma específico.

Resultados Experimentais

Os modelos foram avaliados em cinco benchmarks de matemática de nível de competição: AIME 2024–2026, HMMT 2025 e BeyondAIME.

Desempenho:
- O THINC-4B alcançou uma precisão média de 78,1%, superando todas as linhas de base TIR (incluindo ASTER-4B, ReTool-32B e rStar2-Agent-14B) e ultrapassando o muito maior Qwen3-235B-A22B-Thinking (75,2%) em quatro dos cinco benchmarks.
- O THINC-1.7B atingiu 42,8% de precisão média, uma melhoria de 10,6 pontos percentuais sobre seu modelo base (Qwen3-1.7B) e superando significativamente outras linhas de base TIR de pequena escala.
Eficiência: O THINC-4B exigiu menos chamadas de ferramenta por trajetória (6,1 vs. 11,1 para o ASTER-4B) e produziu respostas mais curtas, indicando maior eficiência.
Robustez: Em experimentos medindo a recuperação de falhas iniciais de execução de código (Recuperação@k), o THINC-4B manteve uma taxa de recuperação de 64–69% mesmo após três falhas consecutivas de código. Em contraste, as linhas de base TIR intercaladas degradaram-se drasticamente, com algumas caindo para uma recuperação próxima de 0%.
Fundamentação em Código: A análise revelou que 99,2% das respostas finais do THINC-4B estavam fundamentadas na saída do interpretador, comparado a taxas significativamente menores para as linhas de base (por exemplo, 88,4% para o ReTool, 74,3% para o rStar2).

Significado

O artigo afirma que o THINC demonstra que o raciocínio centrado em código é um paradigma superior para a resolução de problemas matemáticos em comparação com o TIR intercalado. Ao restringir a linguagem natural ao planejamento de alto nível e forçar todas as derivações para código executável, o framework elimina a propagação de erros aritméticos e garante que a resposta final seja verificada pelo interpretador. Os resultados sugerem que essa mudança estrutural permite que modelos menores (4B parâmetros) superem raciocinadores significativamente maiores baseados apenas em linguagem natural (235B parâmetros) e agentes integrados a ferramentas estabelecidos, destacando a eficácia de "pensar em código" em vez de "pensar com código".