Limite de escala de LLM: a lei 1/largura

O limite de escala de LLM é uma consequência geométrica da superposição: o erro de interferência entre features cai como 1 sobre a largura do modelo. O artigo Superposition Yields Robust Neural Scaling, de pesquisadores do MIT, mediu esse expoente em modelos reais e obteve cerca de 0,91. O resultado explica os retornos decrescentes sem provar teto algum.

Limite de escala de LLM: o que o artigo do MIT mede

O limite de escala de LLM descrito pelo artigo Superposition Yields Robust Neural Scaling não é um teto de inteligência, e sim uma lei de erro: a parcela da perda causada por superposição cai de forma aproximadamente inversa à largura do modelo. Os autores são Yizhou Liu, Ziming Liu e Jeff Gore, do MIT, e o trabalho foi apresentado como oral no NeurIPS.

O artigo apareceu pela primeira vez em maio de 2025, segundo a descrição do próprio vídeo que originou este texto. Trata-se de um resultado de 2025, não de uma descoberta publicada às vésperas desta matéria. A contribuição central é explicar por que as leis de escala funcionam, não apenas medi-las.

Duas ressalvas moldam tudo o que vem depois. A primeira: o que o paper mede é a perda, ou seja, o erro médio de previsão, e não uma taxa de alucinação. A segunda: não há demonstração de limite rígido para a capacidade dos modelos. O que existe é um custo específico que cresce junto com a escala.

Superposição: por que a largura define o ruído

Superposição é o nome do arranjo em que o modelo guarda muito mais features do que direções tem disponíveis. Um modelo transforma cada palavra ou conceito em um vetor dentro de um espaço interno com número fixo de direções; essa contagem é, na prática, a largura da rede. Se existem poucos milhares de direções e dezenas de milhares de conceitos, não há prateleira para cada caixa.

A saída é compartilhar direções. Dois conceitos ficam em vetores que não se alinham perfeitamente, e essa convivência gera vazamento mútuo — a sobreposição propriamente dita. Ler um conceito recupera um resíduo do outro, e o acúmulo de milhares desses resíduos forma um ruído de fundo constante.

Esse ruído é o piso da perda. Um modelo perfeitamente treinado ainda carrega um pouco de erro só porque as representações se atropelam. A origem da ideia é frequentemente atribuída a um trabalho da Anthropic sobre modelos de brinquedo, de 2022, que descreveu o fenômeno em escala reduzida.

A largura age aqui como o único botão direto: mais direções significam vetores mais espalhados e menos sobreposição. É dessa geometria que sai a lei de escala, e não de um ajuste empírico solto.

A lei 1/largura e o expoente 0,91 em modelos reais

A lei 1/largura diz que o erro de superposição cai aproximadamente como o inverso da largura do modelo. Dobrar a largura corta pela metade esse componente do erro; dobrar de novo corta mais uma metade. O resultado é limpo no papel, mas cada degrau exige o dobro do tamanho anterior.

Os autores não pararam no modelo de brinquedo. Eles verificaram famílias abertas como OPT, Pythia e Qwen 2.5, cobrindo aproximadamente de 100 milhões a 70 bilhões de parâmetros, segundo a descrição do vídeo. As sobreposições medidas realmente encolhem na proporção prevista, e a perda acompanha esse movimento.

Quando ajustaram o expoente, chegaram a cerca de 0,91, valor próximo do 1 previsto pela teoria. Essa proximidade é o ponto forte do trabalho: a geometria da superposição dá conta do formato da curva em modelos de linguagem reais.

Há um detalhe de treino que muda o regime. O weight decay, ajuste que empurra os pesos em direção a zero, controla o quanto o modelo é seletivo. Com valor alto, ele guarda bem as features comuns e descarta as raras; com valor baixo, espreme tudo com sobreposição pesada. Modelos reais costumam operar no regime apertado.

Microbenchmark de kernel não vira conta de nuvem

Cada metade de erro custa mais que a anterior, e essa é a parte prática do resultado. Dobrar a largura de um modelo mais que dobra o custo de treinar e de servir. O retorno continua positivo, mas a razão entre ganho e gasto piora conforme você sobe na escala.

Aqui vale separar as coisas com cuidado. A lei 1/largura descreve o componente de perda atribuído à superposição, não a economia de uma operação isolada. Um ganho medido em uma camada, um kernel de atenção ou uma etapa de codificação não se converte automaticamente em latência fim a fim, throughput maior ou custo menor por token.

Portanto, quando você lê que determinado ajuste é várias vezes mais rápido, pergunte o que exatamente foi medido e em qual configuração. Acelerar uma fase do processamento não prova redução proporcional na fatura. Essa distinção evita transformar um número de bancada em promessa comercial.

O próprio paper é cauteloso nesse ponto: ele explica um custo que cresce com a escala, usando um modelo de brinquedo e uma checagem em modelos reais. É um resultado forte e, ao mesmo tempo, restrito ao que foi medido.

Test time compute: o outro botão de erro

Test time compute é gastar computação enquanto o modelo responde, em vez de apenas durante o treino. A largura fica congelada quando o treinamento termina, mas o esforço dedicado a uma pergunta específica continua sob seu controle. Você troca um pouco mais de tempo e dinheiro por resposta em troca de qualidade, sem mexer no tamanho do modelo.

Existem dois padrões principais. No primeiro, o modelo gera várias respostas candidatas e um verificador separado pontua cada uma, mantendo a melhor. No segundo, o modelo lê a própria resposta e a reescreve em passadas sucessivas, corrigindo o que ficou fraco. Buscar e escolher, ou revisar e melhorar.

O vídeo cita um estudo de 2024 da Universidade da Califórnia em Berkeley com o Google DeepMind medindo esse efeito. Segundo a descrição apresentada, o test time compute bem aplicado superou a abordagem ingênua em mais de quatro vezes com o mesmo orçamento. Em problemas mais fáceis, um modelo pequeno com espaço para pensar igualou um modelo 14 vezes maior sob o mesmo custo total de computação.

Esses números são atribuídos ao estudo, não a uma reprodução independente. E o mesmo estudo delimita o alcance: a vantagem aparece em problemas fáceis e médios, nos quais o modelo pequeno já tinha chance real. Nas questões mais difíceis, o modelo maior continua vencendo.

Teste A/B no seu código: contexto e verificador

O teste mais útil não exige cluster. Pegue uma tarefa real de programação contra uma biblioteca que o modelo não domina. Na configuração A, você entrega tudo a um modelo de fronteira, em uma única tentativa, sem ajuda. Na configuração B, usa um modelo menor e mais barato, mas fornece a documentação verdadeira da biblioteca e a saída dos testes que estão falhando, permitindo iteração.

A configuração B é test time compute aplicado à mão. A documentação é contexto, ou seja, a informação certa no momento em que o modelo precisa dela. Os testes que falham funcionam como verificador, uma checagem automática e barata de correção. O ciclo é ler, tentar, checar contra os testes, corrigir e repetir.

Meça três coisas em cada configuração: acerto, custo em dólares e tempo total. Não compare apenas a sensação de qualidade da resposta. O resultado da sua execução vale mais que qualquer estimativa genérica, porque ele reflete a sua biblioteca, o seu conjunto de testes e o seu orçamento.

Esse desenho também revela quando o modelo grande compensa. Se ele ganhar com folga, você identificou o tipo de problema que justifica o prêmio. Se o arranjo pequeno empatar, você acabou de igualar um modelo bem maior gastando uma fração do valor.

Quando o modelo maior ainda vence

Existem problemas genuinamente novos e difíceis, nos quais um modelo pequeno não tem chance real. Nesses casos, o modelo maior continua sendo a escolha certa, e a literatura citada concorda com isso. A escala bruta segue comprando qualidade de forma previsível.

A diferença é que ela deixou de ser o primeiro botão a apertar. Para tarefas cotidianas de código e escrita, dar contexto correto e permitir verificação contra algo concreto costuma fechar a lacuna antes de você pagar por parâmetros extras.

Retome o exemplo da função que não tinha retry algum. Um modelo maior erra esse tipo de detalhe com menos frequência e cobra por cada resposta. Um modelo menor que consegue abrir o arquivo real e conferir a própria afirmação contra o código pega o mesmo erro por bem menos.

Isso não faz a superposição desaparecer. O piso de ruído medido pelo time do MIT continua lá. O que muda é o quanto você contorna esse piso com contexto, verificação e iteração.

Perguntas frequentes sobre o limite de escala

• O que é o limite de escala de LLM proposto pelo MIT? É uma lei de erro, não um teto de capacidade. O artigo Superposition Yields Robust Neural Scaling mostra que a parcela da perda causada por superposição cai aproximadamente como o inverso da largura do modelo, o que explica os retornos decrescentes de forma geométrica.

• A lei 1/largura prova que modelos maiores não valem a pena? Não. Ela mostra que cada redução de erro custa mais que a anterior, porque dobrar a largura mais que dobra o custo de treino e de inferência. Modelos maiores seguem sendo melhores, só não são o único caminho.

• O que é test time compute na prática? É gastar computação durante a resposta: gerar várias tentativas e escolher a melhor com um verificador, ou deixar o modelo revisar e reescrever a própria saída. O estudo de 2024 citado no vídeo associa essa abordagem a ganhos de mais de quatro vezes sobre o método ingênuo com o mesmo orçamento.

• Quando ainda vale pagar por um modelo de fronteira? Em problemas novos e realmente difíceis, nos quais o modelo pequeno não tem chance mesmo com mais tempo de raciocínio. Nesses casos a vantagem do test time compute não se sustenta, e o modelo maior tende a ganhar.

• Perda menor significa menos alucinações? Não de forma direta. O artigo mede perda, o erro médio de previsão, e não taxa de alucinação. Perda acompanha qualidade, mas são métricas diferentes, e o trabalho não estabelece um limite rígido para a capacidade dos modelos.

Source video