A IA do amanhã Glossário
PT

← Voltar ao caderno

Aprofundamento · Folio V

Um modelo pequeno que melhora sozinho, num computador comum?

Na página anterior, um gigante servia de professor ao modelo pequeno. Aqui, nós o tiramos. Sobram um modelo de 8 bilhões de parâmetros, um computador gamer e noites livres. Nossa resposta cabe numa frase: o professor não precisa ser mais inteligente que o aluno, basta que ele saiba distinguir o certo do errado. Aqui estão o raciocínio, as contas e o teto que não é tão fácil de furar.

Promissor atualizado em

I

A ideia, de forma simples

Pense num aluno sozinho com um caderno de exercícios e o gabarito. Ninguém explica nada para ele. Ele tenta, confere com o gabarito, guarda o que funcionou e recomeça. Depois de algumas semanas, ele acerta de primeira exercícios que antes só acertava uma vez em cinco.

Um modelo de linguagem pode fazer exatamente a mesma coisa. Ele tenta o mesmo problema várias vezes, um juiz separa as tentativas certas, e o modelo treina com os próprios acertos. É o autotreinamento. O método STaR mostrou isso já em 2022, e o ReST-EM, no Google, se saiu melhor aprendendo com as próprias tentativas filtradas do que aprendendo com soluções escritas por humanos.

O ponto-chave: o juiz não é um modelo grande. É o gabarito, um teste, uma regra do jogo. Conferir é muito mais fácil do que encontrar. Conferir se uma soma está certa é imediato; encontrar a demonstração de um teorema pode levar anos. Essa assimetria permite que um professor "burro" ensine um aluno mais inteligente do que ele.

Fonte: Zelikman et al., STaR: Bootstrapping Reasoning With Reasoning (2022), Singh et al., Beyond Human Data: Scaling Self-Training for Problem-Solving (2023)

II

Por que pode funcionar: a margem escondida

Um modelo tem duas notas. A primeira é o seu acerto na primeira tentativa. A segunda é o seu acerto em muitas tentativas: a chance de pelo menos uma das tentativas estar certa. Os pesquisadores escrevem pass@1 e pass@k. A diferença entre as duas pode ser enorme: no trabalho de Brown e coautores, a fatia de problemas resolvidos sobe de forma regular a cada vez que o número de tentativas dobra.

Essa diferença é competência escondida: o modelo "sabe" achar a resposta, mas não de forma confiável. O autotreinamento transforma competência escondida em competência confiável. Ele quase não cria nada novo; torna garantido o que antes era sorte.

Esse também é o seu limite, e vamos voltar a isso: Yue e coautores observam que o reforço faz o pass@1 subir, mas que, com muitas tentativas, o modelo inicial resolve a mesma quantidade de problemas, ou até mais. Guarde a imagem: o treinamento enche o copo, não o aumenta. Boa notícia para um modelo antigo como o Llama 3 8B: menos confiável que um modelo recente, ele costuma ter o copo mais vazio, e portanto mais margem para encher.

Fonte: Brown et al., Large Language Monkeys (2024), Yue et al., Does RL Really Incentivize Reasoning Capacity Beyond the Base Model? (NeurIPS 2025)

III

Quem diz "certo" quando não há professor?

Tudo depende do juiz. Estes são os juízes que um computador comum consegue rodar sozinho, do mais seguro ao mais frágil.

Comprovado

O gabarito: exercícios com resposta conhecida

Existem milhares de problemas de matemática com a resposta final. O juiz simplesmente compara dois números. É o juiz do ReST-EM, no teste MATH: gerar, ficar com as tentativas certas, treinar de novo, repetir. Simples e sólido, mas o estoque de exercícios é finito.

Fonte: Singh et al., Beyond Human Data: Scaling Self-Training for Problem-Solving (2023)

Promissor

O teste: rodar o código e ver

Para código, o juiz é o próprio computador: roda-se o programa e vê-se se ele passa nos testes. O Absolute Zero vai além: o modelo inventa os próprios exercícios de programação, um interpretador Python confere, e ele aprende sem nenhum dado externo. Os autores relatam resultados melhores que os de modelos treinados com dezenas de milhares de exemplos escolhidos por humanos.

Fonte: Zhao et al., Absolute Zero: Reinforced Self-play Reasoning with Zero Data (2025)

Promissor

A regra do jogo: um problema que se confere sozinho

O jogo Countdown: chegar a um número-alvo com alguns números e as quatro operações. Conferir uma solução leva uma linha de conta. O TinyZero, em Berkeley, ensinou esse jogo a um modelo de 3 bilhões de parâmetros por reforço, e o modelo desenvolveu sozinho o hábito de conferir as próprias contas e procurar de outro jeito quando erra. Tudo por menos de 30 dólares de computação.

Fonte: Pan et al., TinyZero (2025)

Especulativo

Você: o usuário que corrige

No seu computador, você é um juiz de graça. O código sugerido travou? A resposta foi corrigida à mão? Cada correção é um exemplo rotulado. Essa ideia é nossa, não testada aqui: um modelo local que aprende à noite com as correções do dia. O risco: um juiz humano se cansa e erra.

Promissor

O voto: confiar na maioria das próprias respostas

Sem gabarito, dá para responder 64 vezes e tomar a resposta mais frequente como "verdade". O TTRL faz exatamente isso em problemas sem resposta conhecida e relata uma alta de cerca de 211 % na competição AIME 2024 para um modelo de 7 bilhões de parâmetros. Frágil por natureza: quando a maioria erra, o modelo aprende o próprio erro.

Fonte: Zuo et al., TTRL: Test-Time Reinforcement Learning (2025)

IV

O que já foi mostrado

Dois resultados dão a medida do que se pode esperar, um antigo e sólido, o outro recente e espetacular.

Comprovado

STaR: aprender com os próprios raciocínios (2022)

O modelo escreve um raciocínio; ficam os que levam à resposta certa. Quando ele falha, alguém sopra a resposta e ele reescreve um raciocínio que chegue até ela: é a "racionalização". No CommonsenseQA, o resultado se compara a um modelo 30 vezes maior treinado do jeito clássico.

Fonte: Zelikman et al., STaR: Bootstrapping Reasoning With Reasoning (2022)

Promissor

Um único exemplo rende muito (2025)

Com um único problema e um reforço verificado, um modelo de 1,5 bilhão de parâmetros passa de 36,0 % para 73,6 % no teste MATH500. Cuidado: boa parte do salto vem do modelo aprender a apresentar a resposta no formato certo; os autores medem 8,6 pontos além desse efeito. É a prova de que a competência já estava lá, escondida.

Fonte: Wang et al., Reinforcement Learning for Reasoning with One Training Example (2025)

V

O computador comum: cabe?

Vamos fazer as contas para o Llama 3.1 8B, ou seja, 8,03 bilhões de parâmetros. Guardados em 16 bits, eles pesam 16 GB: demais para a maioria das placas de vídeo. Dois truques mudam tudo.

Primeiro truque: arredondar os pesos para 4 bits, como no QLoRA. 8,03 bilhões × 0,5 byte = 4,0 GB. O QLoRA mostrou que assim dá para ajustar um modelo de 65 bilhões de parâmetros numa única placa de 48 GB sem perder qualidade.

Segundo truque: não mexer nos pesos, e sim acrescentar um adaptador (LoRA). Os 8 bilhões de pesos são congelados e só se treinam pequenas matrizes enxertadas ao lado. Com um posto de 16 em todas as camadas do Llama 3 8B, a conta dá 41,9 milhões de parâmetros, ou seja 0,5 % do modelo e 84 MB. O treinamento guarda para cada um quatro números de 4 bytes (o parâmetro, sua correção e duas médias do otimizador): 41,9 M × 16 bytes = 0,67 GB.

Some a memória de trabalho. Para escrever, o modelo guarda 128 KB por palavra já escrita; 16 tentativas de 1000 palavras em paralelo pedem 2,1 GB. Conte mais alguns gigabytes para o treinamento em si. Total: de 9 a 10 GB. Cabe numa placa gamer de 12 GB, e com folga em 16 ou 24 GB.

Um bônus inesperado: o adaptador esquece menos. Biderman e coautores mostram que o LoRA aprende menos que um retreinamento completo em código e matemática, mas preserva melhor o que o modelo já sabia fazer em outras áreas. Para um modelo que treina sozinho durante semanas, esquecer pouco importa mais do que aprender rápido.

Fonte: Dettmers et al., QLoRA: Efficient Finetuning of Quantized LLMs (2023), Biderman et al., LoRA Learns Less and Forgets Less (2024), Meta, Llama 3.1 8B Instruct model card (2024)

VI

Uma noite de trabalho, hora a hora

Pegue uma noite de 8 horas e divida em três partes: 6 h de tentativas, 1 h de aprendizado, 1 h de controle.

As tentativas (6 h). Uma placa gamer de ponta lê a própria memória a cerca de 1000 GB por segundo; uma placa mais modesta, de duas a três vezes mais devagar, e a noite rende então de duas a três vezes menos tentativas. Para escrever uma palavra, o modelo relê seus 4 GB de pesos: sozinho, ele ficaria em torno de 250 palavras por segundo. Rodando 16 tentativas lado a lado, a mesma leitura serve a 16 palavras. Adotamos uma hipótese prudente de 1000 palavras por segundo. Em 6 h: 6 × 3600 × 1000 = 21,6 milhões de palavras, ou cerca de 21 600 tentativas de 1000 palavras. O suficiente para tentar 2500 exercícios 8 vezes cada (20 000 tentativas), com folga.

O aprendizado (1 h). Guardam-se no máximo duas tentativas certas por exercício, portanto no máximo 5000 exemplos de cerca de 500 palavras: 2,5 milhões de palavras. Aprender custa, contando por cima, 6 operações por parâmetro e por palavra: 6 × 8 bilhões × 2,5 milhões = 1,2 × 10¹⁷ operações. A um rendimento efetivo de 40 trilhões de operações por segundo (uma hipótese, bem abaixo do máximo dessas placas), isso leva 50 minutos.

O controle (1 h). O modelo faz uma pequena prova que nunca viu, mais uma série de perguntas gerais, para conferir que melhorou sem esquecer nada. Se a nota geral cair, o adaptador da noite vai para o lixo. É o cinto de segurança do método inteiro.

A eletricidade. Um PC gamer em plena carga consome cerca de 450 W (nossa hipótese). 450 W × 8 h = 3,6 kWh. Pela tarifa regulada francesa de outubro de 2026, cerca de 0,20 € o kWh: 0,72 € por noite, uns 5 € por semana.

VII

A conta: noite após noite, até onde?

Vamos montar um modelo de brinquedo. Os exercícios não são todos igualmente difíceis para o nosso modelo: digamos que um quarto nunca é resolvido, 15 % são resolvidos uma vez em dez, 25 % seis vezes em dez e 35 % nove vezes em dez. Sua nota na primeira tentativa: 0,15 × 10 % + 0,25 × 60 % + 0,35 × 90 % = 48 %.

A cada noite, ele tenta cada exercício 8 vezes. Um exercício resolvido uma vez em dez dá pelo menos uma tentativa certa com chance de 1 − 0,9⁸ = 57 %: mais ou menos uma noite em cada duas, ele fornece um exemplo para aprender. Um exercício nunca resolvido não fornece nada, nunca.

Suponha que cada exemplo aprendido aproxime o exercício do acerto em 30 % do caminho que falta. A nota passa de 48 % para 60 % em duas noites, 73 % em uma semana, e depois desacelera. Com um aprendizado três vezes mais lento (10 %), chega-se só a 61 % em uma semana. Mas nos dois casos a curva se aproxima da mesma linha: 75 %, exatamente a fatia de exercícios que o modelo inicial resolvia pelo menos uma vez em 64 tentativas.

Eis a lei do teto, numa frase: o autotreinamento aproxima a nota da primeira tentativa da nota em muitas tentativas, não além dela. É a nossa tradução em números da observação de Yue e coautores. O modelo de brinquedo é otimista num ponto: o Llama 3.1 8B já foi ajustado depois do pré-treinamento com exercícios desse tipo, então parte da sua margem já foi gasta.

Fonte: Yue et al., Does RL Really Incentivize Reasoning Capacity Beyond the Base Model? (NeurIPS 2025)

Fig. N — Noite após noite, a nota sobe até um teto

Aprendizado rápido: 73 % após 7 noitesAprendizado lento: 61 % após 7 noites

Esquema ilustrativo: mostra a ideia, não medições.

Um modelo de brinquedo, não uma medição. Um quarto dos exercícios nunca é resolvido no início, 15 % são resolvidos uma vez em dez, 25 % seis vezes em dez, 35 % nove vezes em dez: 48 % na primeira tentativa. A cada noite, 8 tentativas por exercício; quando pelo menos uma acerta, o aprendizado aproxima esse exercício do acerto (em 30 % ou em 10 % do caminho que falta). A velocidade depende do aprendizado; o teto, por sua vez, não se mexe: um exercício nunca resolvido nunca dá nada para aprender.
VIII

Subir o teto sem um modelo grande

Se o teto é o que o modelo encontra em muitas tentativas, há três jeitos de subi-lo, e nenhum exige um gigante.

Soprar a resposta. É a racionalização do STaR: para um exercício nunca resolvido, dá-se a resposta final e pede-se um raciocínio que chegue até ela. O exercício com p = 0 finalmente dá um sinal. O risco: um raciocínio que "acerta" por um caminho errado. É preciso, então, um juiz também para o raciocínio, não só para a resposta.

Graduar os exercícios. Um exercício impossível hoje fica viável se antes se passar por versões mais simples. O modelo pode inventar esses degraus sozinho, como no Absolute Zero, em que ele propõe exercícios bem no limite do que sabe fazer. É a ideia de progressão do caderno, aplicada ao aluno sozinho.

Dar ferramentas. Uma calculadora, um interpretador Python, um buscador sobre uma biblioteca local. Com uma ferramenta, exercícios fora de alcance ficam viáveis às vezes, e esse "às vezes" basta para o ciclo começar.

Daí a nossa hipótese H9: o mundo pode servir de professor. Gabaritos, testes, regras, ferramentas, e a duração de uma noite.

Fonte: Zelikman et al., STaR: Bootstrapping Reasoning With Reasoning (2022), Zhao et al., Absolute Zero: Reinforced Self-play Reasoning with Zero Data (2025)

IX

Mil computadores comuns

E se mil voluntários emprestassem o PC à noite? A conta surpreende. Mil máquinas × 21 600 tentativas = 21,6 milhões de tentativas por noite. Nos nossos 2500 exercícios, isso dá mais de 8000 tentativas por exercício por noite. A computação deixa de ser o problema: o gargalo passa a ser o estoque de exercícios verificáveis.

O que trocar? Duas opções. Dá para trocar os adaptadores (84 MB cada) e fundi-los. Já se sabe treinar um modelo em conjunto pela internet: o DiLoCo iguala um treinamento clássico comunicando 500 vezes menos, e o INTELLECT-1, um modelo de 10 bilhões de parâmetros, foi treinado em três continentes por uns trinta provedores de computação. Mas é preciso confiar nos pesos recebidos, e não dá para relê-los.

Preferimos a segunda: trocar exemplos verificados. Uma solução certa pesa cerca de 2 KB; os 5000 exemplos de uma noite, 10 MB. Acima de tudo, qualquer um pode rodar o juiz de novo sobre um exemplo recebido em uma fração de segundo. Um trapaceiro que envia exemplos falsos é desmascarado na hora. Trocam-se provas, não pesos. Essa é a nossa proposta, não um resultado publicado.

Fonte: Douillard et al., DiLoCo: Distributed Low-Communication Training (2023), Jaghouar et al., INTELLECT-1 Technical Report (2024)

X

O que resiste

O teto. Nós o calculamos: sem exercícios novos, sem respostas sopradas e sem ferramentas, a nota para no que o modelo já encontrava em muitas tentativas.

O colapso. Um modelo que só aprende com os próprios textos pode empobrecer, geração após geração: Shumailov e coautores mostraram isso. O juiz externo limita esse risco, porque filtra pela correção e não pelo estilo, mas não o elimina: as soluções guardadas ficam cada vez mais parecidas. Manter os dados originais na mistura ajuda.

Enganar o juiz. Um modelo aprende o que é recompensado, não o que se queria. Se os testes forem fracos, ele vai aprender a contorná-los. Um juiz frouxo cria um aluno trapaceiro.

O voto que dispara. Quando o juiz é a maioria das próprias respostas, um erro frequente vira uma "verdade" que é reforçada. Numa noite, é um risco; em meses sem âncora externa, é a nossa maior preocupação.

As tarefas sem juiz. Escrever uma carta, dar um conselho: nenhum programa diz qual tentativa é a melhor. Aqui, o computador comum não substitui um professor, humano ou modelo.

Fonte: Shumailov et al., AI models collapse… (Nature, 2024), Yue et al., Does RL Really Incentivize Reasoning Capacity Beyond the Base Model? (NeurIPS 2025), Zuo et al., TTRL: Test-Time Reinforcement Learning (2025)

XI

Nossas apostas, em números

O que vem a seguir é o nosso próprio raciocínio, não um resultado publicado. Cada aposta tem um grau de confiança, como as hipóteses do caderno.

Especulativo

Uma semana de noites basta para um ganho claro · 65 %

O Llama 3.1 8B, treinado por 7 noites com as próprias tentativas filtradas por um gabarito, ganha pelo menos 5 pontos de acerto na primeira tentativa no teste MATH-500, numa única placa gamer. Esta aposta cairia se o ganho ficasse abaixo de 2 pontos.

Especulativo

O teto se mantém · 70 %

Seu acerto em 64 tentativas se mexe menos de 3 pontos. O que o ciclo acrescenta é confiabilidade, não alcance. Se esta aposta cair, é uma ótima notícia: o aluno sozinho descobriria de fato algo novo.

Especulativo

Em grupo, o gargalo é o exercício, não a computação · 70 %

Uma rede de voluntários trocando exemplos verificados melhora mais rápido do que cada um sozinho, mas logo esgota os exercícios disponíveis. O valor passa da potência de computação para os juízes e os exercícios.

Especulativo

Sem nenhuma âncora externa, ele deriva · 60 %

Um modelo que só aprende pelo voto das próprias respostas melhora no início e depois, ao longo de meses, reforça seus erros frequentes e perde diversidade. Sempre é preciso um pedaço do mundo para dizer certo ou errado.

XII

O experimento a fazer, e nossas previsões

Pegar o Llama 3.1 8B, ou o Llama 3 8B para dificultar a prova, uma placa de 24 GB e um adaptador de posto 16. Sortear 2500 problemas do conjunto de treinamento do MATH, com as respostas. A cada noite: 8 tentativas por problema, guardar no máximo duas tentativas certas, aprender e depois controlar. Sete noites.

Medir antes e depois: o acerto na primeira tentativa e em 64 tentativas no MATH-500, e uma série de perguntas gerais (MMLU) para o esquecimento.

Nossas previsões, escritas antes de qualquer experimento para que possam provar que estamos errados. Na primeira tentativa: de +5 a +12 pontos. Em 64 tentativas: menos de 3 pontos de melhora. Perguntas gerais: menos de um ponto de perda. Custo: cerca de 5 € de eletricidade. Se o ganho na primeira tentativa ficar abaixo de 2 pontos, vamos baixar a H9. Se passar de 15 pontos, ou se a nota em 64 tentativas disparar, nossa lei do teto está errada, e revisaremos o caderno com prazer.

Voltar ao topo