Execute modelos das classes 70B a 120B em 128 GB de memória unificada
Um DGX Spark tem 128 GB de memória partilhada pela CPU e pela GPU, por isso modelos que nunca caberiam numa placa gráfica de 24 ou 32 GB carregam de uma só vez. Caber não é o mesmo que ser rápido. A memória move 273 GB/s, e cada token gerado lê uma vez os pesos ativos do modelo. Num dos meus Sparks, um Llama 3.3 70B denso gerou 6,0 tokens por segundo para um único pedido. Um modelo mixture-of-experts lê apenas uma parte dos pesos por token: o gpt-oss-120b é indicado a 58,7 tok/s no mesmo chip. Escolha o modelo em função da largura de banda e alugue um Spark pelas horas de que precisa.
Primeiro carregamento: pague $ 20 e receba $ 30 em crédito, cerca de 37 horas num Spark. Faturado ao minuto a partir de crédito pré-pago. Termine a instância quando acabar e a faturação para.
O que cabe, e a que velocidade corre um pedido
| Modelo e formato | Leitura por token | Um pedido | Fonte |
|---|---|---|---|
| Qwen3-Coder 30B-A3B, AWQ 4 bits | cerca de 3B parâmetros | 80,9 tok/s | A minha execução, vLLM 0.27.1, 2 set. 2026 (registo bruto) |
| gpt-oss-120b, MXFP4 | 5,1B de 117B | 58,7 tok/s | Reportado: resultados do llama.cpp no DGX Spark, build 7941, 5 fev. 2026 |
| gpt-oss-120b, MXFP4 | 5,1B de 117B | 33,5 tok/s | Reportado: Dendro Logic, vLLM, prompts de 1500 tokens e saída JSON, 22 abr. 2026 |
| Nemotron-3-Super-120B-A12B, NVFP4 | 12B de 120B | cerca de 24 tok/s | Reportado: fórum da NVIDIA, vLLM com uma correção CUTLASS, 29 mar. 2026 |
| Llama 3.3 70B, AWQ 4 bits | todos os 70B (denso) | 6,0 tok/s | A minha execução, vLLM 0.27.1, 2 set. 2026 (registo bruto) |
| Nemotron Super 49B v1.5, NVFP4 | todos os 49B (denso) | 5,79 tok/s | Reportado: Dendro Logic, 22 abr. 2026 |
| Qwen3-235B-A22B, UD-Q4_K_XL (134 GB) | 22B de 235B | cerca de 1,8 tok/s; não cabe | Reportado: fórum da NVIDIA, llama.cpp, 17 dez. 2025 |
As linhas "Reportado" são medições de outras pessoas, que recolhi e verifiquei nas respetivas fontes a 11 de outubro de 2026 para a página de benchmarks; não as reproduzi. As duas linhas do gpt-oss-120b mostram o quanto o motor e a carga de trabalho fazem variar um modelo num chip. O número de parâmetros do gpt-oss-120b vem do seu model card, através da calculadora de memória.
Porque é que um 70B denso é lento e um MoE de 120B não
Gerar um token significa ler uma vez os pesos ativos da memória, por isso o limite é a largura de banda de memória dividida pelos bytes lidos por token:
tokens/s ceiling ≈ 273 GB/s ÷ GB of active weights read per token Llama 3.3 70B, 4-bit: about 37 GB per token → about 7.4 tok/s (measured 6.0) gpt-oss-120b, MXFP4: about 3 GB per token → about 90 tok/s (reported 58.7)
Os motores reais ficam entre cerca de metade e quatro quintos do limite. Abaixo de cerca de 10 tok/s, um modelo parece lento numa janela de chat, e é por isso que um 70B denso num Spark é um modelo para lotes: com 128 pedidos em curso, a minha execução do 70B chegou a 485 tok/s no total, contando tokens de prompt e gerados, mas cada pedido abrandou para 1,4 tok/s. As curvas de concorrência completas estão na página de benchmarks.
O que eu executaria
- Um modelo da classe 120B com que pode conversar: gpt-oss-120b em MXFP4. Os pesos ocupam 65,2 GB, o que deixa espaço para um contexto longo, e lê cerca de 5B parâmetros por token.
- Velocidade primeiro: um modelo mixture-of-experts Qwen3 a 4 bits, como o Qwen3-30B-A3B ou o Qwen3.6-35B-A3B. Estes leem cerca de 3B parâmetros por token.
- Um 70B denso: só para trabalhos em lote, ou quando precisa exatamente desse modelo. Conte com cerca de 6 tok/s por pedido.
- Quantize para 4 bits. MXFP4, NVFP4, AWQ ou Q4_K_M reduzem para metade os bytes por token face ao FP8 e aproximadamente duplicam o limite. O custo em qualidade difere consoante o formato; o guia de velocidade de quantização compara-os neste chip.
- Acima de 128 GB: dois Sparks ligados, a $ 1,79 por hora pelo cluster de dois nós quando a consola o oferecer. O relatório do Qwen3-235B acima passou de cerca de 1,8 tok/s num Spark para cerca de 12,5 em dois. O guia de dois nós explica o que o emparelhamento lhe dá.
Executar o gpt-oss-120b com o llama.cpp
Para um utilizador de cada vez, o llama.cpp é o motor mais rápido neste chip. Implemente um DGX Spark 1× com a imagem DGX OS, abra o terminal no navegador, compile o llama.cpp para o GB10 (5 a 10 minutos) e inicie o modelo. Os passos de compilação são os mesmos do meu guia do llama.cpp.
apt-get update && apt-get install -y build-essential cmake libcurl4-openssl-dev git clone https://github.com/ggml-org/llama.cpp /workspace/llama.cpp cd /workspace/llama.cpp cmake -B build -DGGML_CUDA=ON -DGGML_CURL=ON -DCMAKE_CUDA_ARCHITECTURES=121a-real cmake --build build --config Release --target llama-server -j # downloads about 65 GB the first time ./build/bin/llama-server -hf ggml-org/gpt-oss-120b-GGUF --jinja \ --host 127.0.0.1 --port 30000
Quando o registo indicar que o servidor está à escuta, meça a sua própria velocidade a partir de um segundo terminal. O llama-server devolve os tempos com cada resposta:
curl -s http://127.0.0.1:30000/v1/chat/completions -H "Content-Type: application/json" \
-d '{"messages":[{"role":"user","content":"Explain memory bandwidth in three sentences."}],"max_tokens":300}' \
| python3 -c 'import json,sys; t=json.load(sys.stdin)["timings"]; print(round(t["predicted_per_second"],1), "tok/s")'
A transferência conta para o tempo, por isso inicie-a primeiro e leia enquanto carrega. Para chegar ao servidor a partir do seu portátil, use um túnel SSH com a sua própria chave, ou inicie-o com --host 0.0.0.0 --api-key e uma chave aleatória longa: cada instância tem o seu próprio endereço IPv4 público. Para vários utilizadores ao mesmo tempo, o vLLM agrupa melhor; o guia do vLLM tem as contas de memória para a memória unificada.
Limitações a conhecer primeiro
- Não medi o gpt-oss-120b na minha frota. Os números acima são reportados, e os seus prompts vão dar resultados diferentes. Meça antes de planear com base num valor.
- Prompts longos são lentos em modelos densos grandes. A minha execução do 70B leu um prompt de 8192 tokens a 391 tok/s, cerca de 21 segundos antes do primeiro token.
- A quantização custa qualidade. Um modelo de 4 bits não é o de precisão total. Verifique as respostas com os seus próprios prompts.
- O Spark é ARM64 com uma GPU sm_121. Os motores e os pacotes Python precisam de builds aarch64 para ele, e um simples
pip install vllmpode instalar sem erros e depois não arrancar; o guia do vLLM explica a armadilha. - Corre num contentor. Em muitos Sparks tem o seu próprio daemon Docker, por isso os contentores arm64 dos fornecedores funcionam; os outros executam um contentor simples sem Docker, onde a compilação nativa acima é o caminho. Não pode escolher qual.
- Sem SLA e sem cópias de segurança. As transferências de modelos fora de
/workspaceperdem-se numa reconstrução, e terminar apaga tudo.
Preço e onde estão os Sparks
$ 0,79 por hora por um Spark, faturado ao minuto a partir de crédito pré-pago: $ 6,32 por um dia de oito horas. Primeiro carregamento: pague $ 20 e receba $ 30 em crédito. Uma instância parada mantém o espaço de trabalho e é faturada a 75% da tarifa horária. Termine-a quando acabar e a faturação para; isso apaga o espaço de trabalho. Preços sem IVA, quando aplicável.
Os meus próprios Sparks estão num datacenter em Hradec Králové, República Checa. Os Partner Sparks, que pertencem a parceiros e estão alojados nas suas próprias instalações, estão nos EUA, Suécia, Países Baixos, Eslováquia e Hong Kong; um parceiro tem acesso físico à sua máquina. A consola mostra o país, e se está no EEE, antes de implementar. Todas as localizações oferecem as imagens DGX OS e Ubuntu usadas acima.
Quem gere isto
A GPUwerk é nova. Sou eu quem a gere, Samuel Seidel, através da PRINT IT! SE, uma empresa registada em Praga. A 9 de novembro de 2026, 94 programadores tinham iniciado 374 instâncias desde setembro. O estado em tempo real está em status.gpuwerk.com, e a página de contacto chega diretamente a mim se quiser verificar um modelo antes de alugar.
FAQ
Um DGX Spark consegue executar um modelo de 70B?
Sim. O Llama 3.3 70B em AWQ 4 bits tem cerca de 37 GiB de pesos e cabe com folga, mas gerou 6,0 tokens por segundo para um único pedido num dos meus Sparks (vLLM 0.27.1, 2 de setembro de 2026). Serve melhor para trabalhos em lote do que para chat.
O gpt-oss-120b cabe num único DGX Spark?
Sim. Os seus pesos MXFP4 totalizam 65,2 GB, e lê cerca de 5,1B parâmetros por token. Os responsáveis pelo llama.cpp reportam 58,7 tok/s para um pedido; a Dendro Logic reporta 33,5 no vLLM com prompts mais longos e saída JSON. Não o medi na minha frota.
E os modelos com mais de 128 GB?
Precisam de dois Sparks ligados. Uma build do Qwen3-235B-A22B de 134 GB correu a cerca de 1,8 tok/s num Spark e cerca de 12,5 em dois, segundo um relatório no fórum de programadores da NVIDIA. O cluster de dois nós da GPUwerk custa $ 1,79 por hora quando a consola o oferecer.
Quanto custa experimentar um modelo grande?
$ 0,79 por hora por um Spark, faturado ao minuto a partir de crédito pré-pago; a primeira transferência e a compilação do llama.cpp contam para esse tempo. Primeiro carregamento: pague $ 20 e receba $ 30 em crédito, cerca de 37 horas. Termine a instância quando acabar e a faturação para.