Transformers roda modelo MoE de 180 bilhões de parâmetros em Mac com 32GB de RAM

- Leitura
- 6 min
- Tabelas
- 3
- Código
- 2
- Fontes
- 1
Um projeto publicado pela Hugging Face ensina a biblioteca Transformers a buscar em disco só os pedaços de um modelo MoE que cada token realmente precisa, chegando a 14 tokens por segundo num Mac de 32GB de memória.
O obstáculo: um modelo de 180 bilhões de parâmetros não cabe em lugar nenhum
Qwen3.8-Flash-Next é um modelo MoE (mistura de especialistas) com 48 camadas de 512 experts cada, das quais só 10 são ativadas por token. Em FP8 os pesos somam 121 GB, mais uma tabela de embeddings n-gram de 51 GB. Nenhum notebook de consumo tem memória unificada suficiente para isso de uma vez.
É esse o problema que Tarek Ziadé, pesquisador da Hugging Face, descreve num post publicado no blog oficial da empresa em 18 de novembro de 2026. A ideia: fazer o Transformers, a biblioteca Python↳Python56 conteúdosVSCode + Python + Alexa: Desenvolva e teste skills para alexa localmente com pythonDev (Back & Front) · out 2025Dominando decoradores em Python: um guia completo com exemplosDev (Back & Front) · jan 2025Desenvolvimento de software: diferenças entre Python, JavaScript e JavaGestão Dev & TI · nov 2024Ver tudo em Dev (Back & Front) → mais usada para rodar modelos, carregar só os experts que o roteador realmente escolhe em cada token, buscando o resto em disco sob demanda.
Por que offload de MoE não é como qualquer offload
Em modelos MoE, os experts somam mais de 90% dos pesos totais, mas cada token usa só uma fração pequena deles. Isso deveria permitir rodar modelos enormes em GPUs modestas, desde que só os experts certos entrem em memória a cada passo. Na prática, fazer isso sem matar a velocidade é o difícil.
Antes de construir a própria solução, Ziadé mapeou como três motores já lidam com esse offload:
| Motor | Onde ficam os experts | O que atravessa o barramento a cada token | Limitação |
|---|---|---|---|
| llama.cpp | mapeados via mmap do GGUF, fixáveis no CPU (--cpu-moe, --n-cpu-moe N, -ot "exps=CPU") | só ativações, nunca pesos | thrashing de cache quando os experts não cabem na RAM |
| vLLM | RAM pinada (--cpu-offload-gb N) | peso do expert quente, de novo a cada token, via PCIe | sem cache e sem camada de disco |
| Transformers + Accelerate | pasta de offload, um módulo inteiro por vez | o banco inteiro de experts da camada, mesmo usando só 8 a 10 deles | nenhuma noção de roteamento |
O teste de referência usou Qwen3.6-35B-A3B numa GPU A10G de 24 GB, com RAM de sobra. O resultado explica por que o caminho padrão do Transformers era inviável para esse tipo de modelo:
| Motor | Decode (tok/s) |
|---|---|
| Strata, Q8_0 | 82 a 88 |
llama.cpp, Q8_0, --fit on | 63 a 64 |
vLLM, FP8, --cpu-offload-gb 16 --cpu-offload-params experts | 20,1 |
vLLM, BF16, --cpu-offload-gb 50 | 3,3 |
| Transformers + Accelerate | 0,16 |
A diferença entre 0,16 e 82 tokens por segundo não é sobre qual motor é "melhor": é sobre quem sabe reaproveitar o que já está em memória de um token para o próximo, e quem recopia tudo sempre que precisa.
A ideia central: um pool de slots que o kernel original já entende
A primeira versão do projeto de Ziadé mantinha os experts em disco com um cache LRU e rodava cada um num loop Python, expert por expert. Funcionou, mas ficou em 10,1 tokens por segundo contra 32 do Transformers vanilla rodando o modelo inteiro em memória: o gargalo não era o disco, era o loop, porque o código padrão usa grouped_mm, um kernel que processa todos os experts de uma camada de uma vez.
Quis tentar corrigir o offloading no Transformers, com o grande modelo no meu laptop como alvo, sabendo que provavelmente ficaria muito lento para meu uso.
No original: I wanted to try fixing offloading in Transformers itself, with the big model on my laptop as the target, knowing it would probably stay too slow for how I work.
A solução foi trocar o cache por um slot pool: 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 físico. Remapeando os ids do roteador para slots, o pool passa a se parecer com um banco de experts normal, e o grouped_mm original roda nele sem precisar de um matmul customizado. Essa mudança sozinha levou o OLMoE-1B-7B, usado como modelo pequeno de teste, de 10,1 para 34,6 tokens por segundo, contra 38,1 do vanilla.
Colocando em produção: experts_offload
Esse carregador virou uma opção de from_pretrained, proposta no pull request huggingface/transformers#50717. Para testar, é preciso instalar o Transformers direto do branch da PR:
pip install "git+https://github.com/huggingface/transformers.git@refs/pull/50717/head"Com isso, carregar o Qwen3.8-Flash-Next fica assim:
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",
},
)Os experts mapeados para "disk" pulam o Accelerate e passam pelo caminho de streaming: oito threads de I/O leem um bloco contíguo por expert, e os roteadores das duas próximas camadas rodam adiantados sobre o estado atual para adivinhar quais experts prefetchar. Essa combinação de quantização em 3 bits para os experts, pesos densos em 8 bits e leitura preditiva é o que torna o resultado final praticável.
O resultado no Mac de 32GB, e o preço de chegar perto do Strata
Após a conversão (que leva cerca de cinco horas), o modelo usa cerca de 18 GiB em repouso e chega a 25,4 GiB de pico com um prompt de 6 mil tokens, o limite prático antes do macOS começar a trocar memória para disco. Comparado ao Strata, motor especializado em MoE criado por Niko Veit e citado como referência no post, os números finais do Transformers ficam assim:
| Métrica | Transformers | Strata |
|---|---|---|
| Decode, 200 tokens | 13,9 tok/s | 14,8 tok/s |
| Prefill, prompt de 4K | 228 tok/s | 220 tok/s |
| Decode após documento de 6K | 12,4 tok/s | 13,7 tok/s |
Isso é cerca de 6% atrás do Strata no decode curto, com prefill ligeiramente mais rápido. Para chegar lá, Ziadé relata ajustes específicos: forçar o commit de trabalho na GPU a cada bloco (porque o PyTorch no backend MPS represa kernels pequenos até a próxima sincronização), escrever kernels Metal próprios para partes sem caminho rápido no macOS, adotar os pesos GGUF do próprio Strata para reduzir o tráfego de dados por token, e usar chunks maiores de prefill.
O gargalo que sobrou, segundo o autor, são as idas e vindas entre host e GPU: cerca de 10ms por token, a maior parte deles com a GPU ociosa esperando o Python enfileirar a próxima camada. Resolver isso de vez exigiria controle sobre a sincronização por camada, algo que o PyTorch ainda não expõe no stream do MPS.
O que isso muda pra quem desenvolve
Em resumo: isso não é um produto pronto, é uma PR em discussão que prova um conceito. A API do experts_offload ainda está sendo negociada com os mantenedores do Transformers, e a forma de quantizar experts deve migrar para o plano de quantização por camada de outra PR (#50245). Quem quiser reproduzir precisa instalar direto do branch, converter o modelo (cinco horas) e aceitar que ainda é mais lento que alternativas dedicadas como Strata ou llama.cpp quando os experts cabem em RAM.
O próprio autor é direto sobre o limite prático: 14 tokens por segundo é rápido demais para alardear, mas ainda lento demais para o jeito dele de usar agentes de código, que continua rodando numa torre com duas RTX 4090 em casa. O valor do projeto está em outro lugar: mostrar que dá para rodar um modelo de 180 bilhões de parâmetros, dos quais 121 GB são experts, num Mac comum, usando só Python, kernels Metal compilados em tempo de execução com torch.mps.compile_shader e nenhuma extensão em C++.
Para quem avalia rodar modelos grandes fora da nuvem no Brasil, onde GPU de datacenter custa em dólar e a internet para inferência remota tem latência variável, essa técnica de streaming de experts é o caminho que separa "preciso de uma GPU de 80 GB" de "um notebook de 32 GB dá conta, mais devagar". Vale testar em projetos de prototipagem ou aprendizado de sistemas, não ainda em produção onde cada segundo de latência de agente importa.
Vale notar também uma limitação cruzada: o vllm-metal, que traz offloading de experts para GPUs Apple via MLX e segue uma lógica parecida, não consegue rodar esse mesmo Qwen3.8-Flash-Next em 32 GB porque só os experts são transmitidos, a tabela n-gram de 51 GB fica inteira em memória. O projeto de Ziadé resolveu isso lendo a tabela sob demanda do disco também, um detalhe que mostra como cada modelo MoE pode esconder um gargalo diferente do óbvio.
Fonte: Hugging Face Blog
Highlights
- Transformers roda Qwen3.8-Flash-Next com 121GB de experts em Mac de 32GB a 14 tokens/segundo
- Pool de slots na GPU deixa kernel grouped_mm original trabalhar sem remapear toda camada
- Solução fica 6% atrás do Strata no decode, mais rápida no prefill de 4K tokens
- Prefetch preditivo e quantização 3-bit dos experts reduzem tráfego PCIe e SSD
- PR ainda em discussão; requer cinco horas de conversão e Transformers direto do branch
Este artigo foi escrito por Alan Andrade, colunista de inteligência artificial. Conteúdo produzido por agente de IA da redação iMasters, sob revisão editorial humana. Saiba como produzimos no expediente.
Cimed e Enter: quando o rosto do founder vira o canal de confiança da marca
No BRASA Summit Europa, Brunno Matias ouviu como Cimed e Enter usam a voz de quem faz o trabalho para construir confiança.















