Next-Concept Modeling: Stanford gera texto em camadas, até 31 vezes mais rápido que a difusão

Tema: Modelos de Linguagem

Por que gerar texto palavra por palavra é um gargalo

Os modelos de linguagem que hoje escrevem, traduzem e resumem trabalham de uma forma que parece natural, mas é computacionalmente cara: preveem um token por vez, da esquerda para a direita. Um token é a unidade mínima com que o modelo opera — muitas vezes um pedaço de palavra, como “comput” e “acional”, e não a palavra inteira. Cada token exige uma passada completa pela rede neural, e cada passada depende das anteriores. Para produzir uma sequência inteira, são tantos passos quantos tokens, um atrás do outro. O cache KV, uma memória que guarda cálculos dos tokens já gerados para não repeti-los, alivia o custo, mas não elimina a fila: o próximo passo sempre espera o anterior. Esse é o paradigma autorregressivo, e é ele que faz da inferência — o ato de gerar uma resposta, não de treinar o modelo — a carga dominante em muitos sistemas de IA [1].

A alternativa mais promissora são os modelos de difusão de linguagem (DLMs, na sigla em inglês). Em vez de escrever da esquerda para a direita, eles partem de uma versão corrompida do texto — com ruído ou máscaras no lugar das palavras — e a refinam em várias rodadas, prevendo muitos tokens ao mesmo tempo. Em princípio, isso permite gerar um bloco inteiro por rodada. Na prática, a promessa esbarra em três problemas. O primeiro é que ainda são necessárias muitas rodadas de refinamento: reduzir o número de rodadas degrada a qualidade rapidamente [1]. O segundo é o custo de cada rodada: o modelo processa o texto inteiro a cada iteração, e a atenção bidirecional — o mecanismo que deixa cada palavra olhar para todas as outras, antes e depois dela — impede reaproveitar o cache KV como os modelos autorregressivos fazem [1]. O terceiro é o treino: modelos de referência como MDLM e DUO foram treinados no OpenWebText, um grande corpus de texto da web, por 11 milhões de passos, processando mais de 500 bilhões de tokens — ou seja, viram os mesmos dados muitas vezes [1].

O Next-Concept Modeling (NCM), proposto por pesquisadores de Stanford, ataca o problema por outro ângulo: em vez de reduzir os passos de um difusor, troca a unidade de geração. A ideia é simples de enunciar. Primeiro, um tokenizador — um componente que converte texto em códigos — aprende uma hierarquia de códigos discretos, isto é, símbolos tirados de um catálogo finito, organizados do mais geral ao mais detalhado. O primeiro nível captura o esboço do texto inteiro; o segundo corrige o que o primeiro deixou de fora; o terceiro corrige o que os dois primeiros não capturaram; e assim por diante, até que a soma das correções reconstrua o texto com fidelidade. Depois, um transformer — a arquitetura de rede neural por trás dos modelos de linguagem atuais — é treinado para prever todos os códigos de um nível de uma só vez, tendo os níveis anteriores como contexto. Como o número de níveis é muito menor que o número de tokens, o texto sai em poucos passos, cada um gerando uma camada inteira em paralelo [1].

Os resultados justificam o interesse. Num teste de sumarização, um modelo de cerca de 100 milhões de parâmetros — os números ajustáveis que a rede aprende — gera cada resumo em 8 passos, enquanto o difusor de linguagem mais forte da comparação precisa de 128; medido numa GPU NVIDIA H100 (a placa de vídeo usada em data centers), o NCM termina o trabalho até 31 vezes mais rápido, com qualidade igual ou melhor em sumarização de notícias e Sudoku, e resultados competitivos em tradução [1]. A partir daqui, o artigo examina de onde vem essa ideia, como o método funciona, o que os números mostram e escondem, como implementá-lo e avaliá-lo sem se enganar com métricas de eficiência, e em que casos ele vale a pena.

A linhagem: do pixel ao token, a ideia de gerar em escalas

A genealogia do NCM é mais visual do que textual, e isso explica boa parte de sua originalidade. O ponto de partida é o VQ-VAE de van den Oord, Vinyals e Kavukcuoglu, que mostrou como aprender representações discretas de imagens por meio de um codebook e de um estimador straight-through para atravessar a operação de quantização não diferenciável [7]. A quantização residual veio depois, com o SoundStream, que empilhou quantizadores para representar áudio em múltiplas escalas de detalhe [8], e com o RQ-VAE, que aplicou a mesma lógica à geração de imagens autorregressiva [9]. A ideia central é simples e poderosa: em vez de um único código discreto por posição, usar uma soma de códigos, cada um corrigindo o resíduo deixado pelos anteriores.

O salto para a geração veio com o VAR, de Tian e colaboradores, que propôs a predição da próxima escala em vez do próximo token [10]. Em imagens, o VAR gera primeiro um mapa de baixa resolução, e depois refina em escalas crescentes, prevendo todos os tokens de uma escala em paralelo. O resultado foi uma combinação rara de qualidade e velocidade, que reposicionou o debate sobre geração visual [10]. O NCM transpõe essa arquitetura para texto, mas com uma diferença crucial: em imagens, a escala tem uma correspondência espacial natural; em texto, a noção de "escala" precisa ser aprendida. É aí que entra o tokenizador multiescala, que constrói uma hierarquia de códigos com comprimentos crescentes, do mais curto ao mais longo.

Antes de chegar ao NCM, porém, o texto já tinha uma tradição de geração não autorregressiva. Os modelos autorregressivos, dominantes desde o GPT-2 de Radford e colaboradores [14], geram um token por vez e dependem de cache KV para serem viáveis. A difusão discreta surgiu como alternativa: o SEDD, de Lou, Meng e Ermon, estima razões de distribuições para realizar difusão em espaços discretos [2]; o MDLM, de Sahoo e colaboradores, simplifica a difusão mascarada e mostra que ela pode competir com autorregressivos em perplexidade [3]. O LLaDA, de Nie e colaboradores, escala a ideia para bilhões de parâmetros e mostra que a difusão de linguagem não é apenas um experimento de laboratório [4]. O Mercury, da Inception Labs, levou a difusão para produção, com foco em latência e throughput [5]. O Block Diffusion, de Arriola e colaboradores, interpolou entre autorregressivo e difusão, gerando blocos de tokens em paralelo, mas mantendo a sequencialidade entre blocos [6].

O NCM se posiciona nessa linhagem, mas não é uma variação de difusão. A diferença é estrutural: um DLM corrompe a sequência com ruído ou máscara e aprende a reconstruí-la; o NCM aprende uma representação hierárquica discreta e gera nível por nível, sem processo de ruído. O paper é explícito ao dizer que segue a predição da próxima escala para imagens [1][10], e essa filiação é mais honesta do que chamá-lo de difusão. Há, ainda, uma confusão terminológica que vale desfazer: os Large Concept Models (LCM) da Meta, descritos por seu time em arXiv:2412.08821, também falam em "conceitos", mas operam no espaço de embeddings de sentenças [11]. Nos LCM, um conceito é uma unidade semântica de nível de frase, prevista em um espaço contínuo. No NCM, um "conceito" é um código discreto em um nível da hierarquia, e a unidade mínima continua sendo o token. O termo é o mesmo; a ontologia, não.

Essa distinção não é acadêmica. Se o NCM fosse apenas um LCM com quantização, seu argumento de velocidade não se sustentaria, porque embeddings de sentença exigiriam um segmentador e um decodificador à altura. O que o NCM faz é mais modesto e mais viável: aprende, com um VQ-VAE residual, uma hierarquia de códigos que reconstroem o texto, e treina um transformer para prever essa hierarquia. A ambição não é raciocinar em conceitos abstratos, mas comprimir a sequência em escalas e gerar cada escala em paralelo. É uma engenharia de representação, não uma teoria da cognição.

O método: um tokenizador que resume, um gerador que preenche

O NCM é um sistema de dois estágios. O primeiro é um tokenizador VQ-VAE residual multiescala; o segundo é um gerador transformer que opera sobre os códigos produzidos pelo primeiro. A separação é deliberada e tem consequências — algumas boas, outras problemáticas, como se verá adiante.

O tokenizador recebe uma sequência de tokens x e a codifica em uma representação latente contínua z, com comprimento L e dimensionalidade d. A partir daí, constrói K níveis de códigos discretos com comprimentos crescentes ℓ1 < ℓ2 < ... < ℓK = L. O nível 1 é o mais curto e o mais geral; o nível K tem o mesmo comprimento da sequência original e carrega o detalhe fino. Cada nível quantiza o resíduo deixado pelos anteriores. Em linguagem acessível: o primeiro nível captura o esqueleto do texto; o segundo corrige o que o primeiro deixou de fora; o terceiro corrige o que os dois primeiros não capturaram; e assim por diante, até que a soma das correções reconstrua o texto com fidelidade.

Formalmente, o codificador E mapeia o texto em vetores latentes z, com L posições de dimensão d. Começa-se com a reconstrução cumulativa ẑ⁽⁰⁾ = 0. No nível k, o resíduo ainda não explicado, z − ẑ⁽ᵏ⁻¹⁾, é primeiro reduzido a ℓₖ posições por um operador Downₖ; cada um desses vetores é então trocado pelo índice do item mais próximo no codebook do nível. Os vetores escolhidos passam por um operador de reconstrução Rₖ, que os leva de volta ao comprimento L, e são somados à reconstrução: ẑ⁽ᵏ⁾ = ẑ⁽ᵏ⁻¹⁾ + Rₖ(eₖ(rₖ)), onde rₖ são os códigos do nível k e eₖ(rₖ) os vetores correspondentes do codebook [1]. Por fim, o decodificador do VQ-VAE transforma a reconstrução cumulativa em distribuições sobre os tokens de todas as L posições. A equação que importa é a da reconstrução cumulativa: cada nível não é uma representação independente, mas uma camada de correção sobre as anteriores — e é essa propriedade que permite ao gerador condicionar o nível k na reconstrução dos níveis 1 a k−1.

O treino do tokenizador combina três ingredientes, todos avaliados no nível de corte sorteado pelo nested dropout (descrito a seguir). O primeiro é a entropia cruzada de reconstrução, que mede se a reconstrução cumulativa ẑ⁽ᵏ⁾ permite recuperar os tokens originais. O segundo são dois termos de erro quadrático médio com stop-gradient (sg) que comparam a representação original z com essa reconstrução: β·MSE(z, sg[ẑ⁽ᵏ⁾]), o termo de compromisso, que puxa o codificador para perto do que o codebook consegue representar, e MSE(sg[z], ẑ⁽ᵏ⁾), que move os vetores do codebook em direção às saídas do codificador; β pondera o compromisso [1]. O terceiro é o estimador straight-through, que copia o gradiente através da quantização até o codificador, como se a escolha do vizinho mais próximo fosse diferenciável [1][7]. Sem ele, o gradiente morreria no codebook e o codificador não aprenderia representações úteis.

Há um detalhe que faz toda a diferença: o nested dropout. Se o tokenizador fosse treinado apenas para reconstruir a partir do nível K, nada garantiria que as reconstruções parciais fossem informativas. O gerador, afinal, precisa condicionar o nível k na reconstrução dos níveis anteriores, e se essa reconstrução fosse lixo, o condicionamento seria inútil. O nested dropout resolve isso: a cada passo de treino, sorteia-se um corte k entre 1 e K, mantêm-se apenas os k primeiros níveis, e toda a perda é calculada sobre essa reconstrução parcial [1]. O efeito é que cada prefixo da hierarquia se torna uma representação utilizável por si só: o nível 1 vira um resumo, o nível 2 vira um resumo com mais detalhe, e assim por diante [1]. É uma forma de regularização que também prepara o terreno para a geração em camadas.

O gerador é um transformer que prevê todos os códigos de um nível em paralelo, condicionado à reconstrução cumulativa dos níveis anteriores. A probabilidade de uma sequência de códigos é fatorada por nível, e dentro de cada nível por posição, mas com uma diferença em relação à fatoração autorregressiva: as posições de um mesmo nível são previstas simultaneamente. A perda é uma entropia cruzada em que cada posição do nível k recebe o peso wₖ = ℓₖ^(−α) / Σⱼ ℓⱼ^(1−α) [1]. Com α = 0, todas as posições pesam igual — e os níveis finos, que têm muito mais posições, dominam o gradiente; com α = 1, cada nível pesa o mesmo no total, independentemente de quantas posições tenha. Aumentar α, portanto, desloca a atenção do treino para os níveis mais gerais, que carregam a estrutura global. O paper não transforma α em espetáculo, mas ele é um hiperparâmetro crítico.

O condicionamento, porém, não é perfeito no momento da geração. O gerador comete erros, e esses erros se acumulam nível a nível. Para tornar o modelo robusto a eles, o treino corrompe parte dos códigos de condicionamento, substituindo-os por outros códigos do mesmo codebook, com probabilidades que variam por nível — mas mantém os códigos corretos como alvo da perda [1]. É uma forma de data augmentation no espaço discreto: o modelo aprende a gerar o nível k mesmo quando a reconstrução dos níveis anteriores está parcialmente errada. Sem essa corrupção, o gerador seria frágil, porque teria visto apenas condicionamentos perfeitos durante o treino. Com ela, aprende a corrigir o curso — ou, pelo menos, a não colapsar quando o prefixo hierárquico sai do trilho.

Para tarefas condicionais, como tradução e sumarização, o NCM usa um padrão de atenção prefix-LM. O prompt é tratado como um prefixo que os códigos gerados podem atender, mas não o contrário. Isso permite que o modelo condicione a geração no enunciado de entrada sem quebrar a fatoração por níveis. A geração com classifier-free guidance também é possível: nesse caso, cada passo do nível k é avaliado duas vezes, uma com condicionamento e outra sem, e as duas previsões são combinadas. O custo em NFE dobra, e isso precisa ser contabilizado nas comparações de velocidade.

Os Algoritmos 1 e 2 do paper condensam o processo, já com o tokenizador treinado e congelado. O Algoritmo 1 é o passo de treino do gerador: codificar o texto nos códigos-alvo de todos os níveis, corromper parte deles uniformemente, montar a reconstrução cumulativa corrompida nível a nível e prever todos os níveis numa única passada do transformer, calculando a perda ponderada contra os códigos corretos. O Algoritmo 2 é a geração: partir de ẑ⁽⁰⁾ = 0 e, para cada nível k, redimensionar a reconstrução atual para ℓₖ posições, projetá-la para a largura do modelo, prever as distribuições dos ℓₖ códigos numa passada, amostrar todos em paralelo e somar a contribuição do nível à reconstrução; ao final, o decodificador converte ẑ⁽ᴷ⁾ em tokens escolhidos por argmax [1]. A complexidade de geração é K passos, não L. É essa troca que está no coração do argumento.

Os resultados: velocidade com qualidade, e os números que o paper esconde

Os experimentos do NCM usam modelos de cerca de 100 milhões de parâmetros e comparam com baselines de difusão, fluxo e híbridos, seguindo protocolos padrão [1]. A Tabela 1 resume os resultados principais. Todos os números vêm do paper [1]; as colunas de tempo relativo são as reportadas pelos autores.

Benchmark Métrica NCM Melhor baseline Ganho
LM1B Perplexidade generativa melhor que DUO DUO ~11× menos NFE; 21× mais rápido
OpenWebText Perplexidade generativa competitivo DLM mais forte ~10× mais rápido
XSum ROUGE-1/2/L 35,0 / 12,8 / 28,0 (8 NFE) AURORA-LM: 34,7 / 12,2 / 26,6 (128 NFE) 31× mais rápido
XSum + MBR ROUGE-1/2/L 37,3 / 14,0 / 29,6 — melhora sobre o próprio NCM
WMT14 de-en BLEU 22,6 (11 NFE) E2D2: 24,8 (64 NFE); AR: 25,2 segundo lugar em BLEU, primeiro em eficiência
Sudoku fácil Tabuleiros resolvidos 99,5% (12 NFE) FMLM+: 97,7% +1,8 p.p.
Sudoku médio Tabuleiros resolvidos 96,5% (12 NFE) FMLM+: 92,8% +3,7 p.p.
Sudoku difícil Tabuleiros resolvidos 86,1% (12 NFE) FMLM+: 81,3% +4,8 p.p.

No LM1B, o NCM usa cerca de 11 vezes menos avaliações de função que o DUO e é 21 vezes mais rápido, com perplexidade generativa melhor: 93,05 com 12 passos, contra 97,30 do DUO com 128 [1]. A entropia unigrama média fica em 4,31, próxima da entropia dos dados e dos baselines: DUO tem 4,30, MDLM e FLM têm 4,33, CANDI tem 4,34 [1]. Esse detalhe é mais importante do que parece. A perplexidade generativa mede o quão provável o texto gerado é segundo um modelo de referência, o GPT-2 large; a entropia unigrama mede a diversidade lexical das amostras. Um modelo pode melhorar a primeira à custa da segunda, colapsando em frases genéricas e altamente prováveis. O NCM evita esse colapso, e o paper faz bem em reportar as duas métricas juntas.

No OpenWebText, o NCM é competitivo com o melhor modelo de difusão e roda cerca de 10 vezes mais rápido [1]. No XSum, sem guidance, alcança ROUGE-1/2/L de 35,0/12,8/28,0 com apenas 8 NFE, contra 34,7/12,2/26,6 do AURORA-LM com 128 NFE, sendo 31 vezes mais rápido [1]. Com MBR, os números sobem para 37,3/14,0/29,6 [1]. No WMT14 alemão-inglês, o NCM obtém BLEU de 22,6 com 11 NFE, atrás apenas do E2D2, que tem 24,8 com 64 NFE; o autorregressivo tem 25,2 [1]. No Sudoku, resolve 99,5%, 96,5% e 86,1% dos tabuleiros fácil, médio e difícil com 12 NFE, contra 97,7%, 92,8% e 81,3% do FMLM+ [1][12] e menos de 15% dos autorregressivos [1]. O treino no LM1B consome cerca de 13,36 bilhões de tokens, contra 66 bilhões dos baselines, uma redução de aproximadamente 4,9 vezes [1]. Os autores também escalam o modelo para 317 milhões e 725 milhões de parâmetros, e a perplexidade generativa melhora com o tamanho, mantendo a diversidade — um sinal preliminar, ainda longe da escala dos modelos de produção [1]. As medições são feitas em uma única GPU NVIDIA H100 SXM de 80 GB, gerando 1.024 sequências com lote 16 [1].

O MBR, ou decodificação de risco mínimo de Bayes, é a peça que explica o salto no XSum. Em vez de ficar com uma única amostra, o MBR gera várias candidatas e escolhe aquela com maior similaridade média em relação às demais — a candidata mais "central" do conjunto [1][13]. É uma forma de trocar diversidade por qualidade média, e funciona bem quando a métrica de avaliação é a mesma usada na utilidade. O ganho de 35,0 para 37,3 em ROUGE-1 mostra que o NCM gera um espaço de candidatas suficientemente rico para que a seleção por MBR encontre resumos melhores. Mas o custo é real: MBR exige múltiplas amostras, e o paper reporta os números com e sem MBR separadamente, o que é a atitude correta. Comparar um resultado com MBR contra um baseline sem MBR seria desonesto; felizmente, não é o que acontece.

A combinação de perplexidade generativa com entropia unigrama é o que dá credibilidade aos números. Um modelo que apenas memoriza o corpus de treino pode ter perplexidade generativa baixa e entropia baixa; um modelo que gera texto variado mas incoerente pode ter entropia alta e perplexidade alta. O NCM fica próximo dos dados nas duas métricas, e é isso que sugere que a velocidade não foi comprada com degeneração. A ressalva é que a perplexidade generativa é medida por um juiz externo, o GPT-2 large, e esse juiz tem vieses próprios. Texto que agrada ao GPT-2 large não é necessariamente texto que agrada a um leitor humano, e a métrica pode favorecer modelos que imitam o estilo do juiz.

Análise crítica: o que o paper não prova

O paper declara suas limitações com uma honestidade que nem sempre se vê em trabalhos de eficiência. A primeira é a profundidade K e os comprimentos fixos por nível: como a hierarquia tem um número fixo de níveis e cada nível tem um comprimento predefinido, até continuações curtas percorrem toda a hierarquia, gastando K passos mesmo quando bastariam um ou dois [1]. A segunda é que o tokenizador é treinado separadamente do objetivo generativo; não há garantia de que a hierarquia aprendida para reconstruir seja a hierarquia ideal para gerar [1]. Há também o tamanho dos modelos: os avaliados chegam a 725 milhões de parâmetros, e o paper trata a escala maior como direção futura, não como resultado [1]. A terceira é que, embora as gerações sejam em geral fluentes, há artefatos ocasionais nas transições entre níveis mais gerais [1].

Há limitações que o paper não declara, e é nelas que uma leitura crítica precisa insistir. A primeira é a ausência de reprodução independente. Todos os números são dos autores, medidos em uma configuração específica, com um tokenizador por conjunto de dados. Não há, até o momento, um estudo externo que confirme os ganhos de 21× ou 31× em outra implementação. Isso não invalida os resultados, mas os coloca na categoria de promessa verificável, não de fato estabelecido.

A segunda é a comparação de velocidade. As curvas de tempo de parede comparam o NCM sobretudo com difusores, não com um autorregressivo otimizado com cache KV, batching contínuo e decodificação especulativa. O paper cita o DFlash, que acelera autorregressivos por decodificação especulativa [1], mas não o inclui como baseline de velocidade. Ora, se o argumento é que a inferência é o gargalo, o concorrente relevante não é apenas o difusor lento; é também o autorregressivo rápido. O NCM pode muito bem vencer essa comparação em latência, mas o paper não a faz de forma direta. A conclusão de que "21× mais rápido" se traduz em vantagem prática precisa, portanto, de um asterisco: mais rápido que os baselines escolhidos, na configuração escolhida.

A terceira é a métrica de qualidade. A perplexidade generativa pelo GPT-2 large é um proxy, e um proxy com um viés conhecido: ela recompensa texto que se parece com a distribuição do GPT-2, não texto que um humano julgaria bom. O ROUGE do XSum tem limitações semelhantes, e o BLEU do WMT14 é notoriamente sensível a detalhes de tokenização. O paper usa as métricas padrão da área, o que é defensável, mas não substitui avaliação humana. Para sumarização, em particular, a diferença entre 28,0 e 26,6 de ROUGE-L pode ser menos importante do que a coerência global do resumo, que nenhuma dessas métricas captura bem.

A quarta é a distância entre os benchmarks e os modelos que dominam a prática. Um modelo de 100 milhões de parâmetros no LM1B não é um modelo de centenas de bilhões de parâmetros em tarefas abertas. O NCM escala para 725 milhões, o que é um sinal positivo, mas insuficiente para prever o comportamento em escala de fronteira. Em modelos grandes, a hierarquia pode sofrer colapso de codebook, os níveis podem se especializar demais, e a corrupção do condicionamento pode se tornar um gargalo de treino. Nada disso é testado.

A quinta é a mais conceitual, e arrisco aqui uma posição: a obsessão da área com amostradores de poucos passos pode estar mal direcionada. O NCM mostra que é possível reduzir o número de passos sem destilação, mudando a unidade de geração. Mas a métrica que a área usa para celebrar essa redução, o NFE, é uma medida de custo computacional, não de qualidade. Um modelo com 8 NFE e ROUGE-L de 28,0 é mais eficiente que um com 128 NFE e 26,6, mas a pergunta que importa para um produto não é quantas avaliações de função ele faz; é se o texto é bom o suficiente e se a latência cabe no orçamento. O NCM parece ganhar nas duas frentes, mas o paper não mede a segunda com a seriedade que mede a primeira.

A sexta é específica do Sudoku. O resultado é impressionante — 86,1% no difícil contra 81,3% do FMLM+ [1] —, mas Sudoku é um domínio com restrições verificáveis e uma solução única. A vantagem do NCM pode vir menos de uma superioridade geral da modelagem de linguagem e mais do encaixe entre o refinamento em camadas e a propagação de restrições: começar com um esboço da grade e refiná-lo lembra a forma como muitas pessoas resolvem Sudoku. Transpor esse ganho para raciocínio aberto, sem uma estrutura de restrições tão limpa, é uma extrapolação que o paper não faz, mas que o leitor apressado pode fazer.

Como implementar: do repositório ao treino que não está lá

O código oficial está em https://github.com/HazyResearch/ncm, sob licença MIT, e os pesos e dados tokenizados estão na coleção https://huggingface.co/collections/hazyresearch/ncm [16][17]. O grupo também mantém uma página do projeto [15] e um post de blog que apresenta o trabalho [18]. A documentação do repositório cobre a instalação e a avaliação, mas não traz instruções de treino [16]. Essa é a primeira coisa que um praticante precisa saber: o caminho documentado reproduz a avaliação, não o treino. Para quem quer usar o NCM como componente, isso basta; para quem quer treinar do zero, o mais seguro é partir dos Algoritmos 1 e 2 do paper.

A instalação segue o fluxo padrão. É necessário Python 3.10 ou mais novo e PyTorch com CUDA:

git clone https://github.com/HazyResearch/ncm.git
cd ncm
pip install -r requirements.txt
hf download hazyresearch/ncm-checkpoints --local-dir artifacts
hf download hazyresearch/ncm-datasets --repo-type dataset --local-dir data

Para as tarefas condicionais e de raciocínio, os comandos de avaliação recebem a tarefa como argumento [16]:

python evaluate.py --config config/eval/xsum.yaml --checkpoint-dir artifacts/xsum --data-dir data/xsum
python evaluate.py --config config/eval/wmt14.yaml --checkpoint-dir artifacts/wmt14 --data-dir data/wmt14
python evaluate.py --config config/eval/sudoku-easy.yaml --checkpoint-dir artifacts/sudoku-easy --data-dir data/sudoku-easy
python evaluate.py --config config/eval/sudoku-medium.yaml --checkpoint-dir artifacts/sudoku-medium --data-dir data/sudoku-medium
python evaluate.py --config config/eval/sudoku-hard.yaml --checkpoint-dir artifacts/sudoku-hard --data-dir data/sudoku-hard

Para geração incondicional, o argumento é o conjunto de dados [16]:

python evaluate.py --config config/eval/tinystories.yaml --checkpoint-dir artifacts/tinystories
python evaluate.py --config config/eval/owt.yaml --checkpoint-dir artifacts/owt
python evaluate.py --config config/eval/lm1b-small.yaml --checkpoint-dir artifacts/lm1b-small
python evaluate.py --config config/eval/lm1b-medium.yaml --checkpoint-dir artifacts/lm1b-medium
python evaluate.py --config config/eval/lm1b-large.yaml --checkpoint-dir artifacts/lm1b-large

O classifier-free guidance é ativado com --cfg <escala> nas tarefas XSum e WMT14 (a linha guiada do WMT14 no paper usa --cfg 1.0) [16]; no paper, cada passo com guidance conta como duas avaliações de função [1]. O script de avaliação espera os dados no formato tokenizado fornecido pela coleção do Hugging Face; para outros conjuntos, é preciso preparar os dados e ajustar o config.

Para treinar, o paper é o guia, e o esboço a seguir é ilustrativo — não é código oficial, não foi testado contra o repositório e serve apenas para mostrar a estrutura. O primeiro bloco implementa um quantizador residual multiescala simplificado:

import random
import torch
import torch.nn as nn
import torch.nn.functional as F

class MultiscaleResidualVQ(nn.Module):
    """Quantizador residual multiescala (esboço ILUSTRATIVO, não é o código oficial).

    Nível k usa ell[k] posições (ell[0] < ell[1] < ... < ell[-1] = L).
    Down_k: reduz o resíduo para ell[k] posições; R_k: leva os vetores do
    codebook de volta ao comprimento L.
    """
    def __init__(self, ell, codebook_size, dim, beta=0.25):
        super().__init__()
        self.ell, self.beta = ell, beta
        self.codebooks = nn.ModuleList(nn.Embedding(codebook_size, dim) for _ in ell)
        self.up = nn.ModuleList(nn.Linear(dim, dim) for _ in ell)  # parte de R_k

    def down(self, x, n):            # x: [B, L, d] -> [B, n, d]
        return F.adaptive_avg_pool1d(x.transpose(1, 2), n).transpose(1, 2)

    def reconstruct(self, k, vecs, L):   # R_k: [B, ell_k, d] -> [B, L, d]
        vecs = F.interpolate(vecs.transpose(1, 2), size=L, mode="linear",
                             align_corners=False).transpose(1, 2)
        return self.up[k](vecs)

    def forward(self, z, nested_dropout=True):
        B, L, d = z.shape
        K = len(self.ell)
        # nested dropout: mantém só os k primeiros níveis neste passo
        cutoff = random.randint(1, K) if (self.training and nested_dropout) else K
        z_hat = torch.zeros_like(z)
        codes = []
        for k in range(cutoff):
            u = self.down(z - z_hat, self.ell[k])                    # resíduo reduzido
            dist = torch.cdist(u, self.codebooks[k].weight.unsqueeze(0).expand(B, -1, -1))
            idx = dist.argmin(-1)                                    # [B, ell_k]
            e = self.codebooks[k](idx)
            e_st = u + (e - u).detach()                              # straight-through
            z_hat = z_hat + self.reconstruct(k, e_st, L)
            codes.append(idx)
        # termos de VQ no corte sorteado, como na perda do paper
        commit = F.mse_loss(z, z_hat.detach())          # beta * MSE(z, sg[z_hat])
        codebook = F.mse_loss(z.detach(), z_hat)        # MSE(sg[z], z_hat)
        return codes, z_hat, self.beta * commit + codebook

O segundo bloco mostra um passo de treino do gerador com o tokenizador congelado, seguindo o Algoritmo 1: corrupção dos códigos de condicionamento, reconstrução cumulativa corrompida e perda com o peso wₖ do paper. Por clareza, o esboço chama o gerador nível a nível; o paper prevê todos os níveis numa única passada.

def level_weights(ell, alpha):
    """w_k = ell_k^(-alpha) / sum_j ell_j^(1-alpha)  (peso por posição do nível k)."""
    denom = sum(l ** (1 - alpha) for l in ell)
    return [l ** (-alpha) / denom for l in ell]

def train_generator_step(gen, tok, x, alpha, p_corrupt, opt):
    """Esboço ILUSTRATIVO do Algoritmo 1 (não é o código oficial)."""
    tok.eval()
    with torch.no_grad():
        z = tok.encode(x)                                   # [B, L, d]
        codes, _, _ = tok.vq(z, nested_dropout=False)       # alvos r_1..r_K
    L, w = z.shape[1], level_weights(tok.vq.ell, alpha)

    loss, z_tilde = 0.0, torch.zeros_like(z)
    for k, target in enumerate(codes):
        # o nível k é previsto a partir da reconstrução (corrompida) dos níveis < k
        logits = gen(z_tilde, level=k)                      # [B, ell_k, |V_k|]
        ce = F.cross_entropy(logits.flatten(0, 1), target.flatten(), reduction="sum")
        loss = loss + w[k] * ce / x.shape[0]
        # corrompe códigos do nível k (troca por outros do mesmo codebook),
        # mas o alvo da perda continua sendo o código correto
        with torch.no_grad():
            V = tok.vq.codebooks[k].num_embeddings
            swap = torch.rand(target.shape, device=target.device) < p_corrupt[k]
            noisy = torch.where(swap, torch.randint_like(target, V), target)
            vecs = tok.vq.codebooks[k](noisy)
            z_tilde = z_tilde + tok.vq.reconstruct(k, vecs, L)

    opt.zero_grad()
    loss.backward()
    opt.step()
    return loss.item()

O esboço omite deliberadamente detalhes que o paper resolve com engenharia: a tokenização em si, a arquitetura exata do transformer, o valor de α, o número de níveis, os comprimentos ℓ_k e a estratégia de batching. A mensagem é que a estrutura é implementável com componentes padrão de PyTorch; a dificuldade está nos detalhes, não na ideia. Quem tentar reproduzir deve começar pelo tokenizador, verificar a qualidade das reconstruções parciais com e sem nested dropout, e só depois treinar o gerador. Um tokenizador ruim condena o gerador, e o papel do nested dropout é fácil de subestimar.

Como testar e avaliar sem se enganar com NFE

O evaluate.py do repositório mede coisas diferentes conforme a tarefa. No XSum, calcula ROUGE-1, ROUGE-2 e ROUGE-L e a perplexidade generativa; no WMT14, calcula sacreBLEU com e sem caixa, chrF e razão de comprimento; no Sudoku, calcula a taxa de tabuleiros resolvidos, a taxa de células corretas e a taxa de grades válidas; no TinyStories, no OpenWebText e no LM1B, calcula a perplexidade generativa pelo GPT-2 large e a entropia unigrama em cinco sementes de 256 amostras [16]. A escolha de cinco sementes é importante: a variância da perplexidade generativa entre amostras é alta, e uma única semente pode produzir conclusões enganosas.

Medir NFE e tempo de parede de forma justa exige disciplina. O NFE deve contar cada passada do modelo, incluindo cada passo do classifier-free guidance como duas avaliações, porque o modelo é chamado duas vezes. O tempo de parede deve ser medido na mesma GPU, com o mesmo lote, o mesmo número de sequências e o mesmo aquecimento; caso contrário, a comparação vira ruído. O paper usa uma H100 SXM de 80 GB, 1.024 sequências e lote 16 [1]; qualquer reprodução precisa declarar essas condições. Além disso, o tempo de parede inclui o decoder do tokenizador, que é uma etapa adicional em relação a um modelo autorregressivo; ignorá-lo infla o ganho do NCM.

As ablações que valem a pena rodar são quatro. A primeira é o número de níveis K: com K pequeno, o modelo perde detalhe; com K grande, perde eficiência e se aproxima de um autorregressivo. A segunda é o nested dropout: sem ele, as reconstruções parciais devem ser menos informativas, e o gerador deve sofrer. A terceira é a taxa de corrupção do condicionamento: baixa demais, o modelo fica frágil a erros acumulados; alta demais, o condicionamento vira ruído e o modelo ignora o prefixo. A quarta é o expoente α: ele controla o equilíbrio entre estrutura global e detalhe local, e deve ser varrido em uma faixa logarítmica.

Um checklist de reprodução ajuda a comparar com as tabelas do paper:

Item O que verificar Referência no paper
Tokenizador Reconstrução com K níveis e com prefixos parciais Seção de método [1]
Gerador Perplexidade por nível e qualidade do condicionamento Algoritmo 1 [1]
LM1B ~11× menos NFE que DUO; ~21× mais rápido; entropia ~4,31 Figura 1 e Seção 4 [1]
OpenWebText Competitivo com o melhor DLM; ~10× mais rápido Seção 4 [1]
XSum 35,0/12,8/28,0 com 8 NFE; 37,3/14,0/29,6 com MBR Seção 4 [1]
WMT14 BLEU 22,6 com 11 NFE Seção 4 [1]
Sudoku 99,5/96,5/86,1 com 12 NFE Seção 4 [1]
Treino ~13,36B tokens no LM1B vs. 66B dos baselines Figura 7 [1]

Além das métricas padrão, vale rodar testes específicos para as transições entre níveis, que é onde o paper admite artefatos. Um teste simples é gerar o mesmo texto com K níveis e com K−1 níveis e comparar a perplexidade e a coerência nas fronteiras; outro é substituir códigos do nível k por códigos aleatórios e medir a degradação do nível k+1, o que dá uma medida direta de robustez à corrupção. Um terceiro é pedir a avaliadores humanos que identifiquem onde começa e onde termina cada nível em textos gerados; se eles conseguirem, os artefatos são reais e precisam ser tratados. Por fim, vale medir a diversidade não só por entropia unigrama, mas por entropia de bigramas e por distância semântica entre amostras, porque o colapso de modo pode ocorrer sem queda de entropia unigrama.

Implicações: quando o NCM vale a pena — e quando não vale

O NCM é mais atraente onde a latência é o recurso escasso e a estrutura global do texto importa. Sumarização, tradução e tarefas com restrições verificáveis, como Sudoku, são os casos em que o refinamento em camadas tem vantagem clara: o modelo decide primeiro o esqueleto e depois preenche o detalhe, e foi justamente nessas tarefas que o paper mediu os ganhos [1]. Em aplicações de produção com orçamento de GPU apertado, a redução de NFE e de tempo de parede pode ser decisiva, sobretudo se o modelo for pequeno ou médio. Os ganhos foram medidos em uma única GPU H100 [1], o que sugere relevância para serviços de alto volume — embora o comportamento sob batching contínuo, típico de produção, não tenha sido avaliado.

O NCM é menos atraente onde a qualidade de fronteira é o que importa. Em modelos de centenas de bilhões de parâmetros, o autorregressivo ainda é o padrão, e os ganhos de eficiência do NCM não foram demonstrados nessa escala. Também é menos atraente em geração longa e aberta, onde a hierarquia fixa pode desperdiçar passos e onde a coerência de longo prazo depende de mecanismos que o NCM não aborda. E é pouco atraente como substituto direto de um autorregressivo otimizado com cache KV e decodificação especulativa, porque a comparação de velocidade contra esse concorrente não foi feita de forma direta.

Há, ainda, um uso indireto que merece atenção: o NCM como drafter em decodificação especulativa. Se o NCM gera um esboço em poucos passos, um autorregressivo pode refiná-lo e verificar sua qualidade, combinando a latência baixa do primeiro com a qualidade do segundo. O paper cita o DFlash como exemplo de drafter de difusão [1], e a mesma lógica poderia se aplicar ao NCM. É uma direção que os autores não exploram, mas que a arquitetura sugere.

A implicação mais ampla é que a hierarquia explícita pode ser uma alternativa viável à sequencialidade implícita dos autorregressivos. Durante anos, a área tratou a geração token a token como uma necessidade computacional, e não como uma escolha de representação. O NCM mostra que é possível organizar a geração em escalas e obter qualidade competitiva com muito menos passos. Se isso se sustentar em escala, o debate sobre inferência deixa de ser uma disputa entre autorregressivo e difusão e passa a ser uma disputa entre representações: plana versus hierárquica. É uma mudança de vocabulário que pode parecer pequena, mas que reposiciona o problema.

Conclusão

O NCM não é a morte do autorregressivo, e o paper não pretende que seja. É uma demonstração de que a hierarquia, importada da geração visual, pode reduzir o custo de inferência sem destilação e sem colapso de diversidade. Os números são fortes — 21× mais rápido no LM1B, 31× no XSum, 4,9× menos tokens de treino — e as limitações são reais: modelos pequenos, tokenizador separado, ausência de reprodução independente e comparação de velocidade contra um conjunto restrito de baselines [1]. A contribuição mais duradoura pode não ser o ganho de velocidade, mas a reintrodução da ideia de que texto tem escalas, e que gerar exige respeitá-las.

Três direções futuras parecem mais promissoras. A primeira é treinar o tokenizador e o gerador de forma conjunta, ou pelo menos alinhar o objetivo do tokenizador ao objetivo generativo, para que a hierarquia aprendida seja a hierarquia útil. A segunda é tornar a hierarquia adaptativa: em vez de K níveis fixos e comprimentos predefinidos, permitir que o modelo pare cedo quando a continuação é curta ou fácil, economizando passos. A terceira é testar o NCM em escala de bilhões de parâmetros e em domínios abertos, onde a estrutura não é tão clara quanto no Sudoku. Sem esses testes, o NCM permanece uma promessa elegante e bem argumentada; com eles, pode se tornar uma alternativa de fato.

Referências

[1] Kumbong, H.; Khare, I. S.; Mlauzi, I.; Woen, A.; Ding, C.; Buchanan, E. K.; Arora, S.; Mirhoseini, A.; Ré, C. (2026). Next-Concept Modeling: Fast, Parallel Coarse-to-Fine Text Generation. Stanford University e Together AI. arXiv:2610.14162. https://arxiv.org/abs/2610.14162

[2] Lou, A.; Meng, C.; Ermon, S. (2023). Discrete Diffusion Modeling by Estimating the Ratios of the Data Distribution (SEDD). arXiv:2310.16834. https://arxiv.org/abs/2310.16834

[3] Sahoo, S.; Arriola, M.; Schiff, Y.; Gokaslan, A.; Marroquin, E.; Chiu, J. T.; Rush, A.; Kuleshov, V. (2024). Simple and Effective Masked Diffusion Language Models (MDLM). arXiv:2406.07524. https://arxiv.org/abs/2406.07524

[4] Nie, S.; Zhu, F.; You, Z.; Zhang, X.; Ou, J.; Hu, J.; Zhou, J.; Lin, Y.; Wen, J.-R.; Li, C. (2025). Large Language Diffusion Models (LLaDA). arXiv:2502.09992. https://arxiv.org/abs/2502.09992

[5] Inception Labs (2025). Mercury: Ultra-Fast Language Models Based on Diffusion. arXiv:2506.17298. https://arxiv.org/abs/2506.17298

[6] Arriola, M.; Gokaslan, A.; Chiu, J. T.; Yang, Z.; Qi, Z.; Han, J.; Sahoo, S.; Kuleshov, V. (2025). Block Diffusion: Interpolating Between Autoregressive and Diffusion Language Models. arXiv:2503.09573. https://arxiv.org/abs/2503.09573

[7] van den Oord, A.; Vinyals, O.; Kavukcuoglu, K. (2017). Neural Discrete Representation Learning (VQ-VAE). arXiv:1711.00937. https://arxiv.org/abs/1711.00937

[8] Zeghidour, N.; Luebs, A.; Omran, A.; Skoglund, J.; Tagliasacchi, M. (2021). SoundStream: An End-to-End Neural Audio Codec. arXiv:2107.03312. https://arxiv.org/abs/2107.03312

[9] Lee, D.; Kim, C.; Kim, S.; Cho, M.; Han, W.-S. (2022). Autoregressive Image Generation using Residual Quantization (RQ-VAE). arXiv:2203.01941. https://arxiv.org/abs/2203.01941

[10] Tian, K.; Jiang, Y.; Yuan, Z.; Peng, B.; Wang, L. (2024). Visual Autoregressive Modeling: Scalable Image Generation via Next-Scale Prediction (VAR). NeurIPS 2024. arXiv:2404.02905. https://arxiv.org/abs/2404.02905

[11] LCM Team, Meta (2024). Large Concept Models: Language Modeling in a Sentence Representation Space. arXiv:2412.08821. https://arxiv.org/abs/2412.08821

[12] Agarwal, M.; Shah, S.; Lee, C. et al. (2026). Posterior Refinement: Fast Language Generation via Any-Order Flow Maps (FMLM+). arXiv:2606.24773. https://arxiv.org/abs/2606.24773

[13] Bertsch, A.; Xie, A.; Neubig, G.; Gormley, M. R. (2023). It's MBR All the Way Down: Modern Generation Techniques Through the Lens of Minimum Bayes Risk. arXiv:2310.01387. https://arxiv.org/abs/2310.01387

[14] Radford, A.; Wu, J.; Child, R.; Luan, D.; Amodei, D.; Sutskever, I. (2019). Language Models are Unsupervised Multitask Learners (GPT-2). OpenAI. https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf

[15] Stanford Scaling Intelligence Lab (2026). Next-Concept Modeling — Project Page. https://scalingintelligence.stanford.edu/pubs/ncm/

[16] HazyResearch (2026). NCM: Next Concept Modeling — Repositório oficial. GitHub. https://github.com/HazyResearch/ncm

[17] HazyResearch (2026). NCM — Coleção de checkpoints e dados tokenizados. Hugging Face. https://huggingface.co/collections/hazyresearch/ncm

[18] HazyResearch (2026). Next-Concept Modeling: Fast, Parallel Coarse-to-Fine Text Generation — Blog. https://hazyresearch.stanford.edu/blog/2026-10-12-ncm

Fale com a Eliza
E

Eliza

Agente assistente