A ideia de partida: e se um tradutor reescrevesse o modelo numa linguagem nova, para um harness novo, guardando só o necessário? Ela mistura três coisas de dificuldade muito diferente: traduzir sem perder nada, cortar o que não serve e reescrever a rede como código de verdade. Eis o que cada uma pode render, por que a segunda esbarra num fenômeno chamado superposição, quanto um tradutor híbrido economizaria e o que mostrou o experimento feito aqui mesmo.
Promissoratualizado em
I
A ideia, de forma simples
Pense num livro de receitas de mil páginas escrito em latim. Você só quer fazer sobremesas. Um bom tradutor poderia fazer três coisas cada vez mais ousadas. Uma: traduzir o livro inteiro para o português, sem cortar nada. Você lê mais rápido e nada se perde. Duas: traduzir só o capítulo das sobremesas. O livro fica fino, mas se uma sobremesa diz "massa podre, ver página 212", você empaca. Três: trocar as receitas que seguem uma regra por uma fórmula ("1 ovo para cada 100 g de farinha") e manter o texto só para as exceções.
Com um modelo de IA é igual. A "linguagem" é a forma em que o modelo está escrito; o harness é o programa que o roda (como o llama.cpp num computador comum); o tradutor é a ferramenta que passa de um para o outro, otimizando no caminho.
II
Três níveis, do certo ao sonho
Os três níveis não se parecem em nada na dificuldade. O primeiro já existe em todo lugar, o segundo funciona pela metade, o terceiro só existe em brinquedos.
Comprovado
Nível 1 · Traduzir sem perder nada: a compilação
É o que faz um compilador: o mesmo cálculo, executado com mais eficiência. Fundir operações, arredondar os pesos para menos bits, adaptar o cálculo ao chip. Ganha-se normalmente de 1,5 a 3 vezes, sem mudar as respostas (ou quase, com baixa precisão). Alguns chips aceleram até os pesos nulos se eles seguirem um padrão regular: dois zeros a cada quatro, para um cálculo até duas vezes mais rápido.
O SparseGPT zera metade dos pesos dos maiores modelos abertos numa única passada, com uma perda de qualidade quase invisível. O Wanda faz tão bem quanto com uma regra ainda mais simples: um peso importa se for grande e receber sinais fortes. Esses métodos visam um modelo geral. Para uma tarefa estreita, espera-se cortar bem mais. É aí que começa a dificuldade.
Nível 3 · Reescrever a rede como código de verdade: a descompilação
O sentido inverso já funciona: o Tracr, da DeepMind, compila um pequeno programa em pesos de transformer. E já se sabe treinar transformers pequenos para que possam ser reconvertidos em programas Python legíveis. Mas ler um modelo de 8 bilhões de parâmetros e tirar código dele, ninguém consegue. O motivo tem nome.
Imaginamos uma rede como uma cômoda: uma gaveta para a química, outra para a gramática, outra para a adição. Bastaria guardar as gavetas certas. Não é assim que funciona.
Uma rede tem menos neurônios do que noções a representar. Ela as superpõe: cada neurônio participa de dezenas de noções ao mesmo tempo, cada noção se espalha por dezenas de neurônios, como vozes misturadas num coral. Elhage e coautores, na Anthropic, mostraram isso em modelos de brinquedo: assim que as noções são raras, a rede guarda muito mais delas do que tem dimensões.
Consequência direta para o nosso tradutor: um peso "inútil" para a tarefa visada pode carregar um pedaço de outra habilidade da qual a tarefa depende sem mostrar. E nunca se sabe de antemão que pergunta o usuário fará amanhã. Cortar conforme a tarefa é, portanto, uma aposta: ganha-se muito se as perguntas ficarem na pista prevista, perde-se se saírem dela.
Em vez de escolher entre guardar tudo e cortar tudo, o tradutor faria três pilhas. O que segue uma regra (cálculo, datas, formatos, conversões) vira código: exato, quase de graça e válido até além dos exemplos vistos. O que é vago (a linguagem, as nuances, o bom senso) continua como rede, num especialista podado para a tarefa. O que sai da pista volta para o modelo completo: é a saída de emergência.
É o encontro de duas ideias do caderno: a H3, "regras + exceções = compressão" onde dá para conferir, e a cascata, em que um modelo pequeno passa a vez quando duvida. O tradutor não é uma pista nova: é a ferramenta que as junta.
Vamos fixar três números. p, a parcela das perguntas que sabemos mandar para o código: digamos 20 %. s, o custo do especialista podado, como fração do modelo completo. f, a taxa de chamadas: a parcela das perguntas em que o especialista duvida e chama o modelo completo. Quando ele chama, paga-se pelos dois.
O custo médio de uma pergunta é então (1 − p) × (s + f). Com um especialista a 50 % e 10 % de chamadas: 0,8 × (0,5 + 0,1) = 0,48, o custo é dividido por 2,1. Somemos o nível 1, uma compilação que ganha 1,5 vez: 0,48 ÷ 1,5 = 0,32, ou seja, um terço do custo inicial.
Onde está o limite? O ganho some quando (1 − p) × (s + f) chega a 1. Com s = 0,5, são precisos f = 1 ÷ 0,8 − 0,5 = 75 % de chamadas para perder tudo: o sistema é robusto. Mas para dividir por 2, é preciso f ≤ 0,5 ÷ 0,8 − 0,5 = 12,5 %. Com um especialista a 30 %, a margem sobe para 32,5 %; com um especialista a 70 %, dividir por 2 fica impossível. Guarde a lição da figura: o que mais conta não é o tamanho do especialista, é ele saber reconhecer o que não sabe.
Fig. P — Quanto custa um tradutor híbrido
Especialista a 30 % do custo: ÷ 2 enquanto as chamadas ficarem abaixo de 32,5 %Especialista a 50 % do custo: ÷ 2 enquanto as chamadas ficarem abaixo de 12,5 %Especialista a 70 % do custo: nunca dividido por 2
Esquema ilustrativo: mostra a ideia, não medições.
Uma conta, não uma medição. 20 % das perguntas vão para o código, que quase não custa nada. Os outros 80 % vão para um especialista podado; quando ele duvida, chama o modelo completo e paga-se pelos dois. Custo = 0,8 × (custo do especialista + taxa de chamadas). O especialista não precisa ser perfeito: acima de tudo, precisa saber quando não sabe.VI
H10, já nascida dividida em elos
Como prometido na página "As hipóteses à prova", toda hipótese nova chega dividida em elos. Eis a H10: um tradutor pode reescrever um modelo para um harness novo e ajustá-lo a uma tarefa, dividindo o custo pelo menos por 2 sem perda visível nessa tarefa.
Elo a, 95 %: a tradução sem perda e a compilação funcionam; é o caso hoje. Elo b, 65 %: sabendo disso, cortar conforme a tarefa, com uma saída de emergência, divide o custo pelo menos por 2 sem perda visível. Esse elo depende da superposição e da taxa de chamadas. Conta: 0,95 × 0,65 = 62 %.
A forma ambiciosa acrescenta um elo c, 20 %: uma parte importante de um grande modelo pode ser reescrita como código de verdade. Ela valeria só 0,95 × 0,65 × 0,2 ≈ 12 %. Nós a guardamos como pergunta, não como hipótese.
Não temos placa de vídeo, só dois núcleos de processador. Então fizemos o experimento em miniatura, mas de verdade: um pequeno transformer de 0,8 milhão de parâmetros, treinado aqui em duas tarefas misturadas. A, uma regra: somas de dois algarismos, 20 % delas reservadas para o teste. B, um léxico com exceções: os plurais de 600 palavras inventadas, 80 % regulares (+ s), 20 % irregulares a decorar, mais 150 palavras novas nunca vistas.
Depois, os três níveis. Nível 1: um harness escrito à parte, em NumPy, relê os pesos, em 32 e depois em 8 bits. Nível 2: poda Wanda calibrada só na tarefa A, de 25 a 90 % dos pesos, e depois remoção de neurônios inteiros. Nível 3: procuramos, a partir do comportamento do modelo, o programa simples que reproduz cada tarefa; o que o programa não explica vira uma tabela de exceções.
Nossas previsões foram registradas no repositório antes da primeira execução, para que possam provar que estamos errados. As principais: o harness NumPy dá pelo menos 99,9 % de respostas idênticas; com 50 % de poda, a soma mantém pelo menos 95 % da sua precisão; acima de 70 %, o léxico sofre mais que a soma; o programa "a + b" reproduz pelo menos 99 % das respostas do modelo; a regra "+ s" reproduz 80 % ± 5; e em somas de três algarismos, nunca vistas, o modelo erra quase sempre enquanto o código acerta tudo.
O modelo (805 929 parâmetros) aprendeu em 20 minutos com dois núcleos. No início: 100 % nas somas nunca vistas, 100 % nas 600 palavras aprendidas, mas só 83,3 % nas 150 palavras novas, quando bastava acrescentar um "s": a rede pegou a regra, mas não perfeitamente. E 0 % nas somas de três algarismos: ela não entendeu a soma em geral, só a que viu.
Comprovado
Nível 1 · Traduzir: se confirma, mas não fica mais rápido
O harness NumPy, escrito à parte, dá 100 % de respostas idênticas. Em 8 bits, 99,96 % das respostas continuam idênticas e a precisão não se mexe nem um décimo de ponto, com o tamanho dividido por 3,7 (3,2 MB → 0,87 MB). Mas nosso harness, simples e sem otimização, é 7,7 vezes mais lento que o PyTorch: traduzir não deixa nada rápido por mágica; o ganho vem do trabalho do compilador.
Promissor
Nível 2 · Podar: uma previsão errada, uma lição clara
Com 50 % dos pesos retirados com base na soma, ela mantém 93,5 %: tínhamos previsto pelo menos 95 %, então errou, por pouco. Com 60 %, a soma cai para 71,9 % e o léxico para 45,2 %; com 70 %, 18,2 % contra 3,0 %: o que parecia inútil para a soma sustentava o léxico, como previsto. Calibrando no léxico, acontece o inverso: com 70 %, ele mantém 39,5 % enquanto a soma cai para 5,5 %. Remover metade dos neurônios das camadas MLP escolhidos com base na soma deixa a ela 95,9 % e faz o léxico perder 22 pontos.
Promissor
Nível 3 · Descompilar: a surpresa
O programa "a + b" reproduz 99,99 % das 10 000 respostas do modelo (uma única diferença). A regra "+ s" reproduz 80,17 %, e a tabela de exceções tem 119 palavras: 119 dos 120 irregulares, o último cai por acaso num "s". O modelo híbrido faz 100 % em tudo, inclusive onde a rede falhava: 100 % nas palavras novas (contra 83,3 %) e 100 % nas somas de três algarismos (contra 0 %). Para essas duas tarefas, duas linhas de código e uma tabela de 1071 bytes substituem um modelo de 3,2 MB.
IX
O que o experimento muda
Sete previsões de oito se confirmam; a que cai era sobre a poda, por 1,5 ponto. A dúvida mudou de lugar. A poda sozinha decepciona: mesmo num modelo minúsculo com tarefas bem separadas, tirar metade dos pesos já custa alguns pontos, e a vantagem do especialista só aparece em taxas em que a própria tarefa visada também desaba. É a superposição, medida.
Por outro lado, a extração de regras surpreende: o código não se limita a imitar a rede, ele a supera onde a rede generalizava mal. Uma rede aprende uma regra mais ou menos; depois de escrita, a regra vale em todo lugar. É o argumento mais forte a favor do tradutor híbrido.
É preciso mexer na H10? Pelas nossas próprias regras, um número só muda se um elo mudar. E um modelo de brinquedo de 0,8 milhão de parâmetros não diz quase nada sobre um de 8 bilhões: deixamos a H10 em 62 %, anotando para onde apontam os indícios. No elo b, o caminho "cortar" pesa menos e o caminho "transformar em código" pesa mais. O próximo passo seria o mesmo experimento num modelo de linguagem pequeno de verdade, com perguntas misturadas.
Segunda rodada: um modelo de linguagem pequeno de verdade
O brinquedo não bastava. Refizemos o experimento com o SmolLM2-135M, um modelo de linguagem de verdade com 135 milhões de parâmetros, num computador pessoal que podia baixá-lo. Três domínios: código Python, prosa (WikiText-2) e 200 somas de dois algarismos feitas depois de três exemplos. Sete previsões, registradas no repositório antes do lançamento. A conta levou seis minutos.
No início, o modelo prevê bem o código (perplexidade 5,1: em média, ele hesita entre cinco palavras), pior a prosa (20,5), e só acerta 14 % das somas. O código, por sua vez, acerta 100 %.
Traduzir para 8 bits: quase sem perda, mas uma previsão errada
A perplexidade se mexe 0,4 % no código e 0,5 % na prosa; o tamanho cai de 538 para 220 MB (÷ 2,45, o vocabulário continua em 32 bits). Mas só 85,5 % das respostas às somas continuam idênticas: tínhamos previsto pelo menos 95 %. Nas perguntas em que o modelo hesita, um arredondamento minúsculo basta para virar a resposta.
Promissor
Podar: o especialista existe, mas sai caro
Com 50 % podados com base no código, a perplexidade do código sobe 56 % (previsto: pelo menos 20 %) e a da prosa é multiplicada por 2,6; a soma cai para 0 %. Calibrar num domínio protege bem esse domínio: o código se sai melhor podado com base no código (7,9) do que na prosa (10,3), e a prosa melhor com base na prosa (44) do que no código (52). Mas nossa previsão "calibrado na prosa, o código é que mais sofre" falha com 50 e 60 %: a prosa é um domínio tão amplo que um especialista em prosa continua sendo um generalista.
Promissor
Saber quando não se sabe: o sinal existe, a margem não
Para trazer o especialista podado a 50 % de volta a 5 % da perda do modelo completo no código, é preciso chamar o modelo completo em 76,6 % dos trechos confiando na dúvida do especialista, contra 83,3 % ao acaso e 73,4 % com uma bússola perfeita. A dúvida é, portanto, um bom guia, quase tão bom quanto a bússola perfeita. Mas ainda é preciso chamar três vezes em cada quatro: tínhamos previsto no máximo 60 %.
XI
O que a segunda rodada muda
Quatro previsões de sete se confirmam. As três que caem contam a mesma história: um modelo pequeno não tem reserva. Arredondar o faz hesitar, podar o estraga em toda parte, e até um especialista que sabe quando duvida precisa passar a vez quase sempre.
Refaçamos a Fig. P com os números reais. Um especialista a 50 % do custo que chama o modelo completo 77 % das vezes custa 0,8 × (0,5 + 0,77) ≈ 1,01: mais caro do que não fazer nada. Nesse tamanho, o caminho "cortar" não rende nada. O caminho "transformar em código", por sua vez, se sustenta: de 14 % para 100 % na soma.
Desta vez um elo se mexe, como exigem nossas regras: o elo b cai de 65 % para 55 %, e a H10 de 62 % para 0,95 × 0,55 ≈ 52 %. Não baixamos mais, porque modelos grandes se podam muito melhor do que os pequenos: é o que mostram o SparseGPT e o Wanda. A pergunta decisiva passa a ser: a partir de que tamanho um especialista podado rende mais do que custa? Essa será a terceira rodada.
A segunda rodada deixou uma pergunta: o especialista podado está condenado ou só é pequeno demais? Pegamos três modelos da mesma família, SmolLM2 de 135 milhões, 360 milhões e 1,7 bilhão de parâmetros, e o mesmo protocolo para os três: código, prosa, somas, poda a 25 e 50 %, medição da dúvida. Sete previsões, registradas antes da execução. Tudo levou quinze minutos no chip gráfico de um Mac. O modelo de 135 milhões, medido de novo, dá quase o mesmo número da rodada anterior (77,1 % de chamadas contra 76,6 %): a medição é reprodutível.
De saída, o tamanho muda tudo na soma: 14 %, depois 87,5 %, depois 95 % de acerto. O código continua fazendo 100 %. Em 8 bits, as respostas continuam idênticas em 85,5 %, 98 % e 99 % dos casos: quanto maior o modelo, menos o arredondamento o faz hesitar.
Calibrada no código, a poda multiplica a perplexidade do código por 1,53, depois 1,29, depois 1,22: a queda com o tamanho é nítida, como previsto. O modelo de 1,7 bilhão mantém até 85,5 % de acerto nas somas com metade dos pesos, enquanto o pequeno caía para 0 %.
Promissor
A dúvida: a taxa de chamadas cai, mas não rápido o bastante
Para ficar a menos de 5 % do modelo completo no código, o especialista podado a 50 % precisa chamar o modelo completo para 77,1 %, depois 68,8 %, depois 62,5 % dos trechos. Ao acaso, seriam 82,6, 75,1 e 72,5 %: a dúvida continua um bom guia em todos os tamanhos. Tínhamos previsto no máximo 60 % para 1,7 bilhão: errou por 2,5 pontos. O custo ideal vai de 1,02 para 0,95 e depois 0,90: abaixo de 1, portanto vale a pena, mas por pouco.
Promissor
Podar a 25 %: quase de graça, em todos os tamanhos
A verdadeira surpresa vem da taxa mais suave. A 25 %, o especialista fica a menos de 5 % do modelo completo no código sem nenhuma chamada, nos três tamanhos. Custo ideal: 0,8 × (0,75 + 0) = 0,6, ou seja, custo dividido por 1,67. O código perde só 2 a 3 % de perplexidade, a prosa 6 a 8 %: a faixa da tarefa fica protegida, o resto um pouco menos.
XIII
O que muda com a terceira rodada
Seis previsões de sete se sustentam; a que cai tratava da taxa de chamadas do maior modelo, por 2,5 pontos. Uma ressalva: nossa previsão "a dúvida vence o acaso em cada taxa" não se aplica a 25 %, já que ali nenhuma chamada é necessária.
Vamos prolongar a tendência, com cautela: são só três pontos. A taxa de chamadas a 50 % cai cerca de 13 pontos cada vez que o modelo cresce 10 vezes. Para um modelo de 8 bilhões, isso daria cerca de 53 % de chamadas e um custo ideal de 0,83. Para descer a 12,5 %, o limiar que dividiria o custo por 2, seria preciso um modelo da ordem de 10 trilhões de parâmetros. Conclusão: a 50 %, a poda sozinha nunca vai dividir o custo por 2 dentro da nossa tolerância de 5 %.
O bom caminho se desenha de outro jeito: podar com suavidade (25 %, sem chamadas, custo 0,6), compilar (× 1,5: 0,6 ÷ 1,5 = 0,4) e passar para código o que segue uma regra. No papel, isso divide o custo por 2,5. Uma ressalva importante: o único padrão de poda que os chips atuais aceleram de verdade, dois zeros a cada quatro, corresponde justamente a 50 %, a taxa cara. A poda a 25 % só compensa se o chip souber aproveitá-la.
O elo b sobe então de 55 % para 60 %, e H10 de 52 % para 0,95 × 0,60 = 57 %. A próxima pergunta não é mais "a partir de que tamanho?", e sim "em qual chip uma poda a 25 % fica de fato mais rápida?".
Quarta rodada: cortar neurônios inteiros, de cronômetro na mão
O custo de 0,6 da terceira rodada era "ideal": supunha que o chip aproveita os pesos zerados. Mas zeros espalhados numa matriz do mesmo tamanho são calculados como qualquer outro número. Desta vez, retiramos neurônios inteiros dos blocos MLP de cada modelo, 12,5 %, 25 % ou 50 % deles: as matrizes encolhem de verdade, em qualquer chip. E cronometramos o resultado no chip gráfico de um Mac, em vez de calculá-lo. Nove previsões, registradas antes da execução.
O controle confirma o ponto de partida: com 25 % de zeros espalhados, o modelo leva exatamente o mesmo tempo que o modelo completo, com margem de 0,4 %, nos três tamanhos. Zeros não fazem ganhar nada neste chip.
O tempo ganho acompanha quase exatamente os pesos retirados
Retirar neurônios inteiros acelera de verdade. No modelo de 1,7 bilhão, o tempo de leitura cai para 0,91, 0,84 e depois 0,69 vez o do modelo completo, quando se retiram 12,5, 25 e depois 50 % dos neurônios MLP. O modelo fica então com 91, 82 e 65 % dos pesos: o tempo acompanha quase exatamente o tamanho. Os modelos pequenos ganham um pouco menos, porque seus blocos MLP pesam menos no total. A geração palavra por palavra ganha tanto quanto a leitura.
Comprovado
Mas o corte seco estraga mais
A 25 %, a perplexidade do código é multiplicada por 1,16, 1,12 e depois 1,10 (contra 1,02 a 1,03 com zeros espalhados), e a da prosa por mais de 2. É preciso então chamar o modelo completo para 35, 33 e depois 29 % dos trechos de código (ao acaso: 46, 44 e 42 %). Contadas essas chamadas, o custo medido fica em 1,25, 1,20 e depois 1,13: mais caro do que não cortar nada. A 50 % é pior ainda: cerca de 80 % de chamadas e um custo perto de 1,5.
Promissor
A 12,5 %: o primeiro ganho de tempo real, sem nenhuma chamada
Cortando com suavidade, o especialista fica a menos de 5 % do modelo completo no código sem nenhuma chamada, nos três tamanhos. O ganho é modesto, mas medido: 5 %, 6 % e depois 9 % a menos de tempo (custo 0,95, 0,94 e depois 0,91). O modelo de 1,7 bilhão acerta até 98 % das somas, contra 95 % do modelo completo. Já a prosa perde bastante (perplexidade × 1,4 a 1,5): o corte seguiu mesmo a faixa do código. Calibrar na prosa teria sido um erro: a 25 %, a perplexidade do código seria multiplicada por mais de 2 em vez de 1,1.
XV
O que muda com a quarta rodada
Sete previsões de nove se sustentam. A primeira que cai é a mais interessante: tínhamos apostado que nenhum corte faria ganhar tempo real depois de contadas as chamadas. Errado: a 12,5 %, o especialista é mais rápido e não precisa de nenhuma chamada. A outra se decide por um milésimo: a 25 %, a perplexidade do código do maior modelo é multiplicada por 1,099, e tínhamos previsto mais de 1,10. Uma terceira se sustenta por pouco e não pelo motivo previsto: achávamos que, no modelo pequeno, a geração ganharia menos que a leitura; as duas ganham o mesmo.
A lição cabe numa regra simples: neste chip, o tempo ganho é mais ou menos igual à parte dos pesos retirados. Dividir o custo por 2 exigiria, portanto, retirar metade do modelo quase sem chamar o completo. Sem retreinamento, estamos longe disso: a 50 %, é preciso chamá-lo para oito trechos em cada dez.
A próxima pista é conhecida: depois de um corte, um retreinamento curto conserta boa parte do estrago. O LLM-Pruner faz isso em poucas horas com um método leve; o Sheared-LLaMA constrói assim bons modelos pequenos por uma fração do custo de um treinamento completo. Se esse retreinamento levasse as chamadas com corte de 25 % para perto de zero, o ganho medido passaria de 9 % para cerca de 16 %.
Nossa regra, escrita de antemão, dizia: um custo medido abaixo de 0,9 faria subir o elo b; S9 confirmada o faria cair. O melhor custo é 0,91 e S9 cai: o elo b fica em 60 %, e H10 em 57 %. Mas o custo já não é só calculado: pela primeira vez, ele é cronometrado.
Na quarta rodada, retirar 25 % dos neurônios MLP economizava de 10 a 16 % de tempo real, mas o especialista precisava chamar o modelo completo para um terço dos trechos: o ganho sumia. Desta vez, depois do corte, o especialista faz uma curta aula de reforço. O modelo completo faz o papel de professor; o modelo cortado, o aluno, aprende a dar as mesmas probabilidades que ele no código. É a destilação. O código de treino vem de arquivos diferentes dos da avaliação, para que o aluno não decore as respostas.
Testamos duas formas de consertar. A primeira retreina diretamente os pesos dos blocos MLP cortados. A segunda, LoRA, congela esses pesos e treina só pequenas matrizes acrescentadas ao lado, como post-its nas margens de um livro, e depois as funde nos pesos: é isso que faz o modelo de 1,7 bilhão e seu professor caberem nos 24 GB de um Mac. Onze previsões, registradas antes da execução. Tudo levou cerca de uma hora e meia.
O conserto corta muito as chamadas, sem eliminá-las
Com corte de 25 %, antes do conserto, é preciso chamar o modelo completo para 35 %, 33 % e 29 % dos trechos de código (135M, 360M, 1,7B): a quarta rodada se repete ao pé da letra. Depois do conserto, bastam 6 % para o 135M e 15 % para o 360M, consertados diretamente, e 23 % para o 1,7B, consertado com LoRA. O custo medido, chamadas incluídas, cai para 0,93, 1,03 e 1,06. O modelo pequeno passa a valer a pena: 7 % de tempo economizado. Os outros dois chegam perto de 1 sem ficar abaixo. Com corte de 50 %, o conserto não basta: sobram dois terços de chamadas.
Promissor
Retreinar os pesos conserta melhor que LoRA
No mesmo modelo de 135 milhões, com o mesmo número de passos, o conserto direto deixa 6 % de chamadas e o LoRA 15 %. Os "post-its" do LoRA somam só 2,5 milhões de números ajustáveis, contra dezenas de milhões no conserto direto: corrigem menos. O modelo de 1,7 bilhão só teve LoRA, com metade dos passos, por falta de memória e de tempo: o resultado dele (23 %) é, portanto, um piso, não um teto. O conserto levou 19 minutos.
Promissor
Surpresa: a prosa também melhora
Tínhamos previsto que retreinar com código estragaria ainda mais a prosa. É o contrário, nos três tamanhos: a perplexidade da prosa cai um pouco depois do conserto (por exemplo, × 2,59 → × 2,38 no 135M). A explicação está na destilação: o aluno não aprende só a resposta certa no código, aprende toda a distribuição de probabilidades do professor, ou seja, parte do seu jeito geral de prever a continuação de um texto.
XVII
O que muda com a quinta rodada
Seis previsões de onze se sustentam: nossa rodada com menos acertos. Tínhamos apostado que o conserto levaria as chamadas para menos de 10 % e economizaria pelo menos 10 % de tempo real; ele para no meio do caminho. A direção está certa, mas o efeito é mais fraco do que imaginávamos.
O melhor resultado vem do menor modelo: cortado em 25 % e depois consertado, custa 0,93, melhor que o corte suave de 12,5 % sem conserto (0,95). Pela primeira vez, um corte seco seguido de conserto economiza tempo real, chamadas incluídas. O ganho é modesto, e a aula de reforço precisa ser paga uma vez: alguns minutos para um modelo pequeno, uns vinte para o de 1,7 bilhão.
A regra escrita de antemão dizia: um custo abaixo de 0,9 faria subir o elo b; mais de 20 % de chamadas depois do conserto em todos os tamanhos o faria cair. Nenhuma das duas coisas acontece: o elo b fica em 60 %, e H10 em 57 %. A próxima pergunta está clara: com um conserto mais longo, ou um retreino direto do modelo de 1,7 bilhão, as chamadas caem abaixo de 10 %? Vai precisar de uma máquina maior que um Mac.
Quando o conserto da quinta rodada parou, as chamadas ainda estavam caindo. Faltava só tempo? Mantivemos o mesmo corte de 25 % e consertamos por mais tempo, com verificações no caminho: depois de 300, 600 e 1.200 passos para o modelo de 360 milhões (retreino direto), depois de 150, 300 e 600 passos para o de 1,7 bilhão (LoRA). A taxa de aprendizado fica constante depois de uma curta subida, para que as verificações de uma mesma execução possam ser comparadas. Sete previsões, registradas antes da execução. Tudo levou duas horas e meia num Mac.
360 milhões: nenhuma chamada depois de 1.200 passos
As chamadas vão de 33 % antes do conserto para 10 % depois de 300 passos, 4 % depois de 600 passos e 0 % depois de 1.200 passos: em cada um dos 48 trechos de código, o especialista cortado fica a menos de 5 % do modelo completo. Sua perplexidade no código agora é multiplicada só por 1,07 (contra 1,12 antes do conserto), a prosa continua melhorando (× 2,44 → × 2,14) e as somas sobem um pouco (55 → 60 %). Enquanto isso, o aluno viu o código de treino pouco mais de uma vez: não teve tempo de decorá-lo.
Promissor
1,7 bilhão com LoRA: a queda desacelera
As chamadas vão de 29 % para 23 %, 21 % e depois 19 % após 150, 300 e 600 passos: cada vez que se dobra o tempo, agora se ganham só uns 2 pontos. O LoRA corrige menos que o retreino direto, como na quinta rodada; suas pequenas matrizes parecem chegar a um teto. O custo medido cai para 1,05 sem ficar abaixo de 1. O modelo de 1,7 bilhão precisaria de um retreino direto, pesado demais para a memória de um Mac.
Especulativo
Um cronômetro menos confiável desta vez
Sem chamadas, o custo do especialista se resume à sua velocidade. Desta vez medimos 0,97 para o modelo de 360 milhões. Mas durante essa longa execução, o próprio modelo completo ficou 10 % mais rápido entre o começo e o fim (0,68 → 0,61 segundo por lote), enquanto nas rodadas 4 e 5 essa diferença ficava abaixo de 1 %. Essas duas rodadas davam ao mesmo modelo cortado uma velocidade de 0,87 a 0,88. Nossa regra, escrita de antemão, usa o valor medido na execução: nós o mantemos. O custo real provavelmente está mais perto de 0,88: a próxima rodada cronometra de novo o mesmo modelo.
XIX
O que muda com a sexta rodada
Cinco previsões de sete se sustentam. As duas que caem tratam do custo do modelo de 360 milhões (0,97 medido, contra menos de 0,95 previsto) e do modelo de 1,7 bilhão (19 % de chamadas, contra no máximo 15 %).
A lição principal: para o modelo de 360 milhões, só faltava tempo. Um corte de 25 % seguido de uma hora de conserto dá um especialista que nunca mais precisa chamar o modelo completo no código. A questão das chamadas está resolvida para esse modelo; resta só a velocidade do corte, que as rodadas 4 e 5 mediam em 12 a 13 % de tempo economizado.
A regra escrita de antemão: um custo medido abaixo de 0,9 faria subir o elo b; mais de 20 % de chamadas nos dois tamanhos o faria cair. Nem uma coisa nem outra: o elo b fica em 60 %, e H10 em 57 %. A dúvida que resta já não é sobre as chamadas, e sim sobre o cronômetro.
Na quinta rodada, o conserto por destilação também melhorou a prosa, embora tratasse só de código. Nossa explicação: o aluno não aprende só a resposta certa, aprende todas as hesitações do professor. Para pô-la à prova, uma ideia nascida de uma conversa: pegar dois alunos idênticos, o mesmo modelo cortado em 25 % duas vezes, e confiá-los ao mesmo professor, com os mesmos textos, na mesma ordem, pelo mesmo tempo.
Só uma coisa muda: o jeito de ensinar. O aluno "nuances" aprende toda a distribuição de probabilidades do professor: "return a 70 %, yield a 20 %…". O aluno "respostas" só aprende a palavra preferida do professor, como se recebesse apenas o gabarito. Dois tamanhos (135 e 360 milhões), seis previsões registradas antes da execução, um pouco menos de uma hora num Mac.
O aluno "nuances" refaz a quinta rodada ao pé da letra
Ele usa exatamente a configuração da quinta rodada e devolve exatamente as mesmas chamadas: 6,2 % no 135M e 14,6 % no 360M. A medição se repete de um dia para o outro. Sua prosa melhora como na época (× 2,59 → × 2,38 no 135M; × 2,44 → × 2,29 no 360M).
Comprovado
O aluno "respostas" termina pior do que antes da aula
Não é só que ele avança menos: ele regride. Suas chamadas vão de 35 % para 73 % (135M) e de 33 % para 77 % (360M), sua perplexidade no código é multiplicada por 1,5 a 1,6, contra 1,12 a 1,16 antes da aula, e sua prosa também piora. E, no entanto, ele aprendeu o que se pedia: acerta cada vez mais a palavra preferida do professor. Mas a distância das probabilidades do professor aumentou durante a aula em vez de diminuir.
Promissor
Por quê: ele aprende a ter certeza demais
Quando o professor hesita entre duas palavras, o aluno "respostas" aprende a pôr todo o peso na primeira. Ele fica confiante demais. Num texto de verdade, toda vez que a segunda palavra era a certa, ele é fortemente penalizado. O aluno "nuances", ao contrário, aprende a hesitar onde o professor hesita. É o "conhecimento oculto" que Hinton e seus colegas descreveram em 2015: as respostas erradas que o professor acha plausíveis ensinam quase tanto quanto a certa.
XXI
O que muda com a sétima rodada
Seis previsões de seis se sustentam: uma estreia neste caderno. Nossa explicação da quinta rodada passa no teste, e com mais clareza do que o previsto. Copiar as nuances do professor é o que conserta; copiar só as respostas estraga.
Uma boa notícia para o cronômetro: desta vez ele foi estável (o modelo completo leva o mesmo tempo no começo e no fim, com margem de 1 %). O modelo de 360 milhões cortado em 25 % roda a 0,87 do tempo do modelo completo, como nas rodadas 4 e 5. O especialista consertado por 1.200 passos na sexta rodada, que não precisava mais de nenhuma chamada, custaria então cerca de 0,87.
Esse número ficaria abaixo do limiar de 0,9 que faria subir o elo b. Mas ele junta duas rodadas, e nossa regra trata de uma medição feita numa mesma execução. O elo b fica, portanto, em 60 %, e H10 em 57 %, à espera de uma execução de confirmação: o conserto de 1.200 passos e o cronômetro estável juntos, com a previsão escrita de antemão.
Juntas, as rodadas 6 e 7 sugeriam um especialista que nunca chama o modelo completo e roda a 0,87 do tempo dele. Mas nossa regra exige que tudo seja medido numa mesma execução. Então refizemos o conserto de 1.200 passos do modelo de 360 milhões cortado em 25 % e depois cronometramos alternando: modelo completo, especialista, completo, especialista… sete medições ao todo. Se a máquina acelerar ou desacelerar no caminho, os dois modelos são afetados igualmente. Cinco previsões, registradas antes da execução.
Comprovado
Zero chamadas, de novo
Depois de 600 passos, é preciso chamar o modelo completo para 4,2 % dos trechos; depois de 1.200 passos, para nenhum. A perplexidade do código agora é multiplicada só por 1,065, a prosa continua melhorando e as somas voltam a 60 %. Os números da sexta rodada se repetem quase ao pé da letra.
Comprovado
Um cronômetro enfim sob controle
As quatro medições do modelo completo diferem no máximo 1,7 %, contra 10 % na sexta rodada. O especialista leva 0,88 do tempo do modelo completo, e essa razão quase não muda de uma volta para outra (0,882, 0,884, 0,882). Retirar um quarto dos neurônios MLP economiza 12 % de tempo real.
Comprovado
Um custo medido abaixo de 0,9
Sem nenhuma chamada, o custo medido se resume a essa razão: 0,88. Pela primeira vez, numa mesma execução e com um cronômetro estável, um especialista cortado e depois consertado é mais rápido que o modelo completo, sem se afastar mais de 5 % dele em nenhum trecho de código.
XXIII
O que muda com a oitava rodada
Cinco previsões de cinco se sustentam. A regra escrita de antemão dizia: se o cronômetro for estável e o custo ficar abaixo de 0,9, o elo b sobe de 60 para 65 %. É o caso: H10 passa de 57 para 0,95 × 0,65 ≈ 62 %.
O que isso quer dizer, sem exagero: no chip de um computador comum, uma hora de conserto basta para transformar um modelo cortado em 25 % num especialista em código 12 % mais rápido, sem perda notável. Está longe da divisão do custo por 2 que H10 anuncia; o resto do caminho terá de vir de outro lugar (um corte mais forte e mais bem consertado, compilação, passar para código o que segue uma regra). Mas o caminho "cortar, depois consertar" funciona, e agora está medido.
Nona rodada: um professor que exagera suas hesitações
A sétima rodada mostrou que aprender as hesitações do professor conserta e que aprender só as respostas estraga. Então, um professor que exagera suas hesitações ensina ainda melhor? É a ideia da "temperatura", proposta por Hinton e colegas em 2015: professor e aluno achatam suas probabilidades antes da aula. Com T = 2, "return 90 %, yield 8 %" fica mais parecido com "return 70 %, yield 20 %"; com T = 4, mais ainda. Três alunos idênticos por tamanho (T = 1, 2 e 4), mesmo professor, mesmos textos, mesma duração. Cinco previsões, registradas antes da execução.
O aluno com T = 1 segue exatamente a aula do aluno "nuances" da sétima rodada. E devolve exatamente as mesmas chamadas: 6,2 % no 135M, 14,6 % no 360M. É a terceira vez que esses números saem idênticos, nas rodadas 5, 7 e 9.
Comprovado
Quanto mais o professor exagera, menos o aluno aprende
As chamadas aumentam com a temperatura: 6 → 10 → 15 % no 135M, 15 → 17 → 21 % no 360M, com T = 1, 2 e 4. A perplexidade do código e a da prosa pioram um pouco na mesma ordem. Tínhamos apostado que T = 2 faria pelo menos tão bem quanto T = 1: errado, nos dois tamanhos.
Promissor
Por quê: nem seguro demais, nem hesitante demais
O aluno que aprende uma versão exagerada das hesitações acaba hesitando demais, assim como o aluno "respostas" da sétima rodada acabava seguro demais. Os dois se afastam do professor, em direções opostas. A temperatura ajuda quando um aluno pequeno aprende com um professor grande e muito confiante, cujas nuances são quase invisíveis. Aqui, o aluno é uma cópia danificada do professor, e seu objetivo é ficar exatamente igual a ele: o melhor é copiar as probabilidades dele como estão.
XXV
O que muda com a nona rodada
Três previsões de cinco se sustentam: a repetição com T = 1, a piora com T = 4 e a dúvida como guia melhor que o acaso. As duas que caem são as que apostavam num ganho com T = 2.
As rodadas 7 e 9 desenham juntas uma regra simples para consertar um especialista: ele deve aprender as probabilidades do professor como estão. Endurecidas demais (só as respostas) ou suavizadas demais (uma temperatura alta), elas ensinam pior. Esta rodada tratava do jeito de consertar, não do custo: H10 fica em 62 %.
O especialista da oitava rodada tinha sido consertado e avaliado com código da biblioteca padrão do Python: arquivos diferentes, mas o mesmo estilo e os mesmos autores. Ele é bom em código Python ou só em código da biblioteca padrão? Refizemos exatamente a oitava rodada, acrescentando uma segunda avaliação com código estranho: 48 trechos tirados das fontes do PyTorch e do Transformers, nunca vistos no corte nem no conserto. Cinco previsões, registradas antes da execução.
Comprovado
No seu terreno, a oitava rodada se repete
Na biblioteca padrão, os números da oitava rodada voltam idênticos: 0 % de chamadas depois de 1.200 passos, razão de velocidade de 0,88 e cronômetro estável (deriva de 1 %). Custo medido: 0,88.
Comprovado
Com código estranho, ele chama para quase um trecho em cada dois
Com o código do PyTorch e do Transformers, o especialista cortado chama o modelo completo para 71 % dos trechos antes do conserto, e ainda para 48 % depois de 1.200 passos. O conserto ajuda um pouco (perplexidade × 1,29 → × 1,16), mas bem menos que no seu terreno. Custo medido nesse código: 1,36, mais caro do que não cortar nada. O que chamávamos de "especialista em código Python" é na verdade um especialista na biblioteca padrão: o domínio dele é o do seu conserto.
Comprovado
E a dúvida dele não o guia mais
No seu terreno, seguir a dúvida do especialista sempre exigiu menos chamadas que o acaso. Com código estranho, isso deixa de valer: 48 % de chamadas seguindo a dúvida, 48 % ao acaso. O especialista não consegue reconhecer os trechos que trata mal quando eles saem do seu domínio. É um resultado importante para o tradutor: o sinal de alarme dele só vale onde foi ajustado.
XXVII
O que muda com a décima rodada
Uma previsão de cinco se sustenta: a repetição na biblioteca padrão. As outras quatro caem, e por larga margem. Nossa rodada com menos acertos, e provavelmente a mais útil.
A regra escrita de antemão dizia: mais de 20 % de chamadas com código estranho trazem o elo b de volta de 65 para 60 %. São 48 %: H10 volta a cair de 62 para 57 %. O ganho medido na oitava rodada continua valendo, mas só no terreno exato do conserto, e um tradutor de verdade precisaria saber quando sai dele: a dúvida dele não sabe.
Para chegar mais perto de dividir o custo por 2, é preciso cortar mais. Retiramos 50 % dos neurônios MLP do modelo de 360 milhões e consertamos oito vezes mais tempo que na quinta rodada, com verificações depois de 600, 1.200 e 2.400 passos. Mesma cronometragem alternada, mesma avaliação dupla (biblioteca padrão e código estranho). Cinco previsões, registradas antes da execução.
Cortado pela metade, ele leva 0,75 do tempo do modelo completo, com cronômetro estável (deriva de 0,7 %): um quarto do tempo economizado, como na quarta rodada.
Comprovado
Mas o conserto chega a um teto
Na biblioteca padrão, as chamadas vão de 81 % para 54 %, 50 % e depois 46 % após 600, 1.200 e 2.400 passos. Cada vez que se dobra o tempo, agora se ganham só 4 pontos. A perplexidade do código continua multiplicada por 1,17, e a da prosa por quase 5. Custo medido: 1,21. Com código estranho é pior: 73 % de chamadas, custo 1,48.
Especulativo
Por quê: tirou-se conhecimento demais
Com 25 %, o conserto recuperava quase tudo o que o corte tinha feito perder. Com 50 %, recupera só uma parte, mesmo com duas passadas e meia pelo código de treino. Uma explicação possível: metade dos neurônios já não basta para guardar o que o modelo sabia, e a destilação não consegue criar espaço. Trabalhos como o Sheared-LLaMA consertam com bilhões de tokens, não com alguns milhões.
XXIX
O que muda com a décima primeira rodada
Duas previsões de cinco se sustentam: as chamadas caem a cada verificação, e o especialista roda mesmo a 0,75. As outras três caem: depois de 2.400 passos ainda são precisas 46 % de chamadas, e o custo fica em 1,21.
A regra escrita de antemão não move H10: ele fica em 57 %. As rodadas 10 e 11 dizem a mesma coisa de dois jeitos: numa máquina como um Mac, cortar e depois consertar funciona para um corte moderado e num terreno preciso. Cortar mais, ou mirar mais amplo, exige um conserto de escala bem diferente.
Décima segunda rodada: estudar com dois professores, e um fiscal de alfândega
A décima rodada tinha mostrado duas fraquezas: o especialista consertado com a biblioteca padrão se saía mal com código estranho, e a dúvida dele não identificava os trechos que tratava mal. Atacamos as duas ao mesmo tempo. Primeiro, o corte e o conserto usaram uma mistura: metade biblioteca padrão, metade fontes do Transformers. Depois testamos um detector que não olha a hesitação do especialista, mas "com o que o trecho se parece": uma impressão digital dos estados internos dele no código conhecido e a distância de cada trecho novo até essa impressão. Seis previsões, registradas antes da execução.
Comprovado
Um conserto variado se sustenta em código nunca visto
Depois de 1.200 passos, o especialista chama o modelo completo para 4 % dos trechos da biblioteca padrão, 0 % dos arquivos do Transformers deixados de lado e 21 % dos trechos do PyTorch, que nenhuma etapa tinha visto. Na décima rodada, consertado só com a biblioteca padrão, ele chamava para 48 % num código estranho que misturava PyTorch e Transformers. Nos arquivos do Transformers deixados de lado, ele até se sai um pouco melhor que o modelo completo (perplexidade × 0,997).
Comprovado
O fiscal reconhece o código estranho
O detector distingue os trechos do PyTorch do código conhecido em 93 % dos pares sorteados (área sob a curva ROC de 0,93). Já a dúvida volta a falhar no PyTorch: segui-la exige mais chamadas que o acaso (21 % contra 17 %). Olhar o que o especialista lê funciona melhor do que perguntar se ele hesita.
Promissor
Num fluxo misturado, o custo fica abaixo de 1
Num fluxo de 96 trechos, metade biblioteca padrão, metade PyTorch, como num uso real, chamar primeiro os trechos que o detector considera estranhos exige 9,4 % de chamadas, contra 11,5 % seguindo a dúvida, 13,8 % ao acaso e 7,3 % para um oráculo que soubesse tudo. Com razão de velocidade de 0,88 e cronômetro estável (deriva de 1,4 %), o custo medido cai para 0,97.
XXXI
O que muda com a décima segunda rodada
Seis previsões de seis se sustentam: a segunda vez neste caderno. Cada uma das duas fraquezas da décima rodada tem seu remédio: um conserto mais variado e um detector que olha o trecho em vez da hesitação.
Nossa regra escrita de antemão pedia mais para fazer H10 subir: um custo abaixo de 0,95 no fluxo misturado. Com 0,97, ainda falta um pouco: o elo b fica em 60 %, e H10 em 57 %. Mesmo assim, o tradutor real vai tomando forma: um especialista consertado num terreno variado, um fiscal que manda o estranho para o modelo completo e um ganho modesto, mas medido, mesmo quando o fluxo mistura conhecido e desconhecido.
Décima terceira rodada: doze professores, e um fiscal apressado
Na décima segunda rodada, duas famílias de código tinham bastado para baixar as chamadas no PyTorch de 48 para 21 %. Levamos a ideia adiante: conserto com doze famílias de código Python em partes iguais (biblioteca padrão, Transformers, NumPy, pandas, SymPy, NetworkX, pip, setuptools, Rich, Pydantic, Pygments, Jinja2), com o PyTorch ainda como prova final. E testamos um fiscal apressado, que julga o trecho depois de 8 camadas de 32, em vez de esperar a última: se o achar estranho, o especialista para ali e o modelo completo assume. Seis previsões, registradas antes da execução.
Comprovado
Mais professores não ajudam no PyTorch
Depois de 1.200 passos, o especialista chama o modelo completo para 0 % dos arquivos deixados de lado das outras onze famílias: ele conhece bem o que estudou. Mas no PyTorch ele chama para 23 %, tanto quanto com duas famílias (21 %), e na biblioteca padrão volta a subir para 8 % (4 % na décima segunda rodada). Parte da explicação está na nossa montagem: em partes iguais, a menor família limitava todas as outras, e o aluno revisou três vezes um corpus menor que na décima segunda rodada.
Comprovado
O fiscal final perde o faro
Com doze famílias na impressão digital, o código conhecido fica muito variado, e o PyTorch se destaca menos: a área sob a curva ROC cai de 0,93 para 0,73. No fluxo misturado, ele ainda exige menos chamadas que a dúvida (11,5 % contra 15,6 %), mas o custo fica em 0,99.
Promissor
O fiscal apressado não vê nada, mas economiza tempo
Depois de 8 camadas, o detector já não distingue o PyTorch do código conhecido (área sob a curva ROC de 0,45, como cara ou coroa): seguindo a ordem dele, são precisas 24 % de chamadas. Mesmo assim, o custo dele é o melhor da rodada, 0,95: ler 8 camadas custa só 0,2 do modelo completo, e cada trecho devolvido cedo poupa o especialista de três quartos da leitura. O ganho vem de parar cedo, não do faro.
XXXIII
O que muda com a décima terceira rodada
Duas previsões de seis se sustentam: a boa nota nas famílias estudadas e um fiscal apressado mais barato que o final. As outras quatro caem: o PyTorch fica em 23 %, a biblioteca padrão volta a subir, o fiscal apressado não reconhece nada e o custo do fiscal final fica em 0,99.
A regra escrita de antemão exigia que as chamadas no PyTorch caíssem abaixo de 12 %: H10 fica em 57 %. A lição é dupla. Acrescentar famílias não substitui um estudo mais longo de cada uma. E um fiscal precisa de uma impressão digital nítida o bastante: quanto mais vasto o terreno conhecido, mais o estranho se confunde com ele. A melhor montagem continua sendo, por enquanto, a da décima segunda rodada.
O fiscal final da décima segunda rodada tinha faro, mas julgava depois de o especialista ter lido tudo. O da décima terceira, colocado depois de 8 camadas, economizava tempo sem ver nada. Retomamos exatamente a montagem da décima segunda rodada e colocamos seis fiscais ao longo do caminho: depois de 8, 12, 16, 20 e 24 camadas de 32, e no final. Para não escolher o melhor depois, a regra de H10 valia de antemão para um só deles, o de 16 camadas. Cinco previsões, registradas antes da execução.
Comprovado
A décima segunda rodada se repete ao pé da letra
Mesma montagem, mesmos resultados: depois de 1.200 passos, 4,2 % de chamadas na biblioteca padrão, 0 % nos arquivos do Transformers deixados de lado, 20,8 % no PyTorch, e a área sob a curva ROC do fiscal final volta a 0,93. O cronômetro é estável (deriva de 0,5 %).
Promissor
O faro só aparece bem no final
Os fiscais intermediários não veem quase nada: área sob a curva ROC de 0,63 com 8 camadas, 0,62 com 12, 0,52 com 16, 0,49 com 20, 0,69 com 24, e depois 0,93 no final. O faro não cresce aos poucos com a profundidade: ele surge na última camada. Uma explicação possível, que esta rodada não verifica: a última camada serve para prever a próxima palavra, e é ali que o vocabulário próprio de cada biblioteca deixa um rastro nítido; as camadas do meio descrevem a estrutura do código, comum a todas.
Comprovado
Parar cedo ganha sem ver
O fiscal de 16 camadas, o da nossa regra, exige 21 % de chamadas e custa 0,98, mais que o fiscal final (0,97). O mais barato continua sendo o de 8 camadas, 0,94, embora ele quase não veja nada: como na décima terceira rodada, ele ganha porque para cedo o especialista numa parte dos trechos, e não porque ordena bem. Escolher esse fiscal depois seria trapaça; nossa regra não permite.
XXXV
O que muda com a décima quarta rodada
Uma previsão de cinco se sustenta: a repetição da décima segunda rodada. As outras quatro caem: com 16 camadas o fiscal não tem faro, não mais que com 8, e o custo dele passa o do fiscal final.
A regra escrita de antemão não move H10: ele fica em 57 %. Agora sabemos que, neste modelo, reconhecer o código estranho exige ir até a última camada. Para ganhar dos dois lados, seria preciso um fiscal mais sutil que uma simples distância nos estados ocultos, por exemplo um pequeno classificador treinado para detectar o estranho já nas primeiras camadas.
A escala. Um modelo de 0,8 milhão de parâmetros em duas tarefas limpas não é um modelo de 8 bilhões diante de perguntas reais. Lá a superposição é bem mais densa, e as tarefas se misturam muito mais.
Descompilar pelo comportamento não é ler a rede. Nosso nível 3 adivinha um programa a partir das respostas, não o lê nos pesos. Isso funciona para uma regra que já sabemos nomear; achar uma regra desconhecida é outro problema, o do AlphaEvolve.
A dúvida do especialista. Toda a conta depende de um especialista que sabe quando não sabe. Os modelos costumam ser confiantes demais; um desvio que erra em silêncio custa mais do que economiza.
Os ganhos reais da poda. Zerar pesos não acelera nada se o chip calcula os zeros do mesmo jeito. É preciso cortar blocos inteiros, ou seguir os padrões que o chip sabe aproveitar, e esses cortes estragam mais.