AI Brasil
AI Avançado

Hugging Face roda modelo de 180 bilhões de parâmetros com só 32 GB de RAM

Um engenheiro da Hugging Face fez um modelo MoE de 180 bilhões de parâmetros rodar num MacBook com 32 GB de memória, a 6% da velocidade do motor especializado Strata. O relato mostra como funciona o streaming de experts e onde essa técnica ainda esbarra.

Lucas FerrazColunista

· 8 min de leitura

Este artigo foi escrito por Lucas Ferraz. Conteúdo produzido por agente de IA da redação AI Brasil, sob revisão editorial humana. Saiba como produzimos no expediente.

Imagem gerada por IA

Um modelo de 180 bilhões de parâmetros numa máquina sem GPU de datacenter

Tarek Ziadé, engenheiro da Hugging Face, publicou em 18 de novembro de 2026 no blog oficial da empresa um relato técnico de como conseguiu rodar o Qwen3.8-Flash-Next, um modelo MoE (mistura de especialistas) de 180 bilhões de parâmetros, num MacBook com apenas 32 GB de memória unificada. Ele tem duas máquinas: um PC com duas RTX 4090 (apelidado de Orthrus) para o trabalho pesado, e o laptop para o dia a dia.

O ponto de partida foi uma sugestão da comunidade: usar o Strata, um motor de inferência especializado em MoE criado por Niko Veit. Ziadé encontrou um post anterior, de outro autor, mostrando esse mesmo modelo rodando num Mac M4 de 32 GB (uma máquina diferente da sua) a 13,5 tok/s.

Um modelo MoE não ativa todos os seus parâmetros a cada token. No Qwen3.8-Flash-Next, cada camada tem 512 "especialistas" (experts) e só 10 são usados por token, escolhidos por um roteador. Esses experts somam mais de 90% do peso total do modelo. Isso significa que, em teoria, um modelo de 180B cabe numa GPU pequena, desde que só os experts realmente usados fiquem na memória rápida e o resto espere em RAM ou disco. Essa é a ideia de "streaming de experts", e o artigo testa até onde dá para levá-la usando apenas a biblioteca Transformers, sem motor especializado.

Como cada motor lida com um modelo que não cabe na memória

Antes de mexer em código, Ziadé comparou como llama.cpp, vLLM e Transformers (com Accelerate) fazem esse offload, usando o Qwen3.6-35B-A3B numa GPU A10G de 24 GB:

MotorConfiguraçãoDecodificação
StrataQ8_082 a 88 tok/s
llama.cppQ8_0, --fit on63 a 64 tok/s
llama.cppBF16, --fit on35 a 36 tok/s
vLLMFP8, --cpu-offload-gb 16 --cpu-offload-params experts20,1 tok/s
vLLMFP8, mesmas flags + --enforce-eager14,7 tok/s
vLLMFP8, --cpu-offload-gb 16 (sem filtrar experts)9,7 tok/s
vLLMBF16, --cpu-offload-gb 50 --cpu-offload-params experts7,3 tok/s
vLLMBF16, --cpu-offload-gb 503,3 tok/s
Transformers + Acceleratepadrão0,16 tok/s

O padrão do Transformers ficou absurdamente lento porque o Accelerate trata offload como cópia de módulo inteiro: a cada token, ele copia o banco completo de experts de cada camada offloaded para usar só 8 ou 10 deles, sem cache e sem noção de roteamento. Num Mac o problema piora, porque CPU e GPU compartilham a mesma memória, então "offloadar para CPU" não libera nada. Já o --cpu-offload-params experts do vLLM, que restringe o offload só aos experts roteados em vez de também mover as camadas densas, praticamente dobra a velocidade.

O conserto: um pool de slots que não quebra o kernel rápido

A correção central do projeto foi técnica e específica. Em vez de carregar cada expert isoladamente, Ziadé criou um "pool de slots": um tensor único, pré-alocado na GPU, compartilhado por todas as camadas, mais uma tabela por camada que mapeia o id de cada expert para um slot. Com os ids remapeados, o pool se parece com um banco de experts normal, e o kernel rápido do Transformers para MoE, o grouped_mm (que roda todos os experts ativos de uma camada numa única operação), continua funcionando sem alteração.

A validação inicial foi feita com um modelo pequeno, o OLMoE-1B-7B, que cabe inteiro em memória e permite comparar token a token com o Transformers padrão. A primeira versão, com um laço Python processando um expert por vez, rodou a 10,1 tok/s contra ~32 do padrão. Depois do pool de slots, subiu para 34,6 tok/s contra 38,1 do padrão, uma diferença pequena o bastante para justificar escalar a técnica para o modelo real.

O resultado virou um parâmetro novo do from_pretrained, discutido no pull request huggingface/transformers#50717:

python
path = snapshot_download("tarekziade/Qwen3.8-Flash-Next-expert-streaming")

model = AutoModelForCausalLM.from_pretrained(
 f"{path}/dense",
 dtype=torch.bfloat16,
 device_map={"": "mps", "experts.*": "disk"},
 quantization_config=MetalConfig(bits=8),
 experts_offload={
 "cache_bytes": 12 << 30,
 "quantized_experts": f"{path}/experts-q3",
 },
)

Para testar, é preciso instalar o Transformers direto do PR:

pip install "git+https://github.com/huggingface/transformers.git@refs/pull/50717/head"

Encaixar 121 GB de experts em 32 GB de memória

O Qwen3.8-Flash-Next tem 48 camadas com 512 experts cada (10 ativos por token), somando 121 GB em FP8. Isso sozinho já estoura um Mac de 32 GB, e o modelo ainda carrega uma tabela de embeddings de n-gramas de 51 GB, que precisa do próprio caminho de disco. A solução combinou três ajustes: experts quantizados para 3 bits (49 GB em disco, 12 GiB em cache no dispositivo), camadas densas em 8 bits (cerca de 5,4 GB, com perda de só 0,2% de perplexidade frente a BF16) e a tabela de n-gramas lida linha a linha direto do disco, sem cache.

A conversão do modelo para esse formato leva cerca de cinco horas. Depois de carregado, o uso de memória fica em torno de 18 GiB, mas um prompt de 6 mil tokens chega a 25,4 GiB, perto do limite: segundo o autor, é preciso fechar o navegador ou o macOS começa a trocar memória para disco.

Os números finais: a 6% do Strata

A primeira versão funcional do streaming no Qwen3.8-Flash-Next rodava a cerca de 10 tok/s, bem atrás do Strata 0.1.60 (com experts em IQ3_XXS) nos mesmos prompts: 14,8 tok/s na decodificação de 200 tokens, 220 tok/s no prefill de um prompt de 4K tokens e 13,7 tok/s na decodificação depois de um documento de 6K tokens.

Uma série de otimizações fechou boa parte dessa distância: forçar o PyTorch a enviar o trabalho para a GPU mais cedo (ganho de 10%, porque o MPS represa kernels pequenos até a próxima sincronização), escrever kernels Metal próprios para partes sem caminho rápido no macOS (Gated DeltaNet e as hyper-connections), trocar os pesos por versões no formato GGUF do próprio Strata (reduzindo o tráfego de pesos densos de 5,4 GB para 3,9 GB por token e o tamanho de cada expert de 2,15 MB para 1,75 MB) e, para prefill, usar blocos maiores enquanto a camada seguinte já lê seus experts em paralelo.

Em documentos longos, a atenção passou a rodar só sobre os blocos selecionados por um indexador, com um cache de KV que cresce no lugar em vez de ser copiado a cada token.

MétricaTransformers (final)StrataDiferença
Decodificação, 200 tokens13,9 tok/s14,8 tok/s6% mais lento
Prefill, prompt de 4K tokens228 tok/s220 tok/slevemente mais rápido
Decodificação após documento de 6K tokens12,4 tok/s13,7 tok/scerca de 10% mais lento

Isso é cerca de 6% atrás do Strata na decodificação curta, com prefill um pouco mais rápido, tudo através do Transformers.

That's about 6% behind Strata on short decode, with slightly faster prefill, all through Transformers.Tarek Ziadé, engenheiro, Hugging Face

O que ainda trava e o que o autor não resolveu

O próprio autor é direto sobre o limite: 14 tok/s continua lento demais para como ele usa agentes de código no dia a dia, e por isso Orthrus, com as duas RTX 4090, segue fazendo o trabalho real.

O gargalo restante é de cerca de 10 ms por token em idas e vindas entre CPU e GPU: o Strata enfileira o token inteiro de uma vez e a GPU espera num evento compartilhado do Metal enquanto o host lê os experts, mas o PyTorch não expõe esse controle de sincronização por camada hoje. Uma tentativa de simular isso com um kernel que fica checando uma flag escrita pela CPU não funcionou de forma confiável: a GPU levou de um segundo a nunca perceber a escrita.

Há também uma comparação reveladora com o vllm-metal, a versão do vLLM para GPUs da Apple via MLX, que ganhou offload de experts recentemente e usa a mesma ideia de cache limitado. Ele não consegue rodar esse mesmo modelo em 32 GB, porque só os experts são transmitidos sob demanda: a tabela de n-gramas inteira fica na memória, e os checkpoints MLX já ocupam 32 GB sozinhos, antes mesmo das camadas densas e do cache de experts.

O parâmetro experts_offload ainda está em discussão com os mantenedores do Transformers, e a forma final da API pode mudar: o formato de device_map usado no exemplo surgiu dessa discussão, e a quantização de experts deve migrar para o plano de quantização por camada de outro PR, o #50245, em vez de ter opção própria.

O que muda para quem constrói agente ou sistema em produção

Para quem decide onde rodar um modelo grande, o material deixa três cenários mais claros. Se os experts cabem inteiros na RAM disponível, o llama.cpp com --cpu-moe ou --fit on continua difícil de superar, porque computa os experts na própria CPU e só as ativações cruzam o barramento PCIe. Se não cabem e é preciso transmitir só o que o roteador escolhe, motores especializados como o Strata seguem na frente, mas a distância para o Transformers caiu para cerca de 6% nesse experimento, o que abre espaço para quem já trabalha nesse ecossistema (pesquisa, fine-tuning, prototipagem) sem precisar adotar um motor novo.

Para quem roda em lote real, com várias requisições simultâneas, a lição do vLLM importa mais que a do Mac: separar o offload das camadas densas do offload dos experts, com --cpu-offload-params experts, dobra a velocidade sem trocar de motor. Em compensação, rodar localmente um modelo de 180B elimina custo de API por token, mas troca isso por hardware próprio, cinco horas de conversão para o formato quantizado e uma velocidade (14 tok/s) ainda inadequada para agentes de código que precisam de resposta rápida.

Para produção com volume, GPU de nuvem ainda compensa; para pesquisa, ambientes isolados ou simplesmente para entender o que está acontecendo por baixo do capô, essa técnica tira uma classe de modelo antes restrita a cluster de datacenter e coloca dentro de um laptop de 32 GB.

Todo o código, incluindo o pacote específico do modelo e os kernels Metal, está publicado em aberto: o PR no Transformers, o Space tarekziade/moe-expert-streaming com os benchmarks completos, e os kernels Metal no Hub da Hugging Face, prontos para quem quiser reaproveitar ou medir em outro hardware.

Fonte: Hugging Face Blog

Compartilhar
Quem escreveuLucas FerrazColunista

Cobre a parte técnica da inteligência artificial para quem constrói e opera sistemas: desenvolvedores, analistas e times de TI. Compara modelos, mostra o código e o prompt, mede o resultado e diz quanto custa, para o leitor conseguir repetir na própria empresa.

Leia também

Newsletter AI Brasil

A IA da semana, para a sua profissão

Toda semana: um guia para o seu trabalho, a notícia traduzida e uma coisa nova para experimentar. Gratuita, sem spam.

Você é… (opcional)