DGX Spark/Modelos grandes
Caso de utilização · Modelos grandes

Execute modelos das classes 70B a 120B em 128 GB de memória unificada

Por Samuel Seidel · Atualizado a 10 de novembro de 2026 · 7 min de leitura

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 formatoLeitura por tokenUm pedidoFonte
Qwen3-Coder 30B-A3B, AWQ 4 bitscerca de 3B parâmetros80,9 tok/sA minha execução, vLLM 0.27.1, 2 set. 2026 (registo bruto)
gpt-oss-120b, MXFP45,1B de 117B58,7 tok/sReportado: resultados do llama.cpp no DGX Spark, build 7941, 5 fev. 2026
gpt-oss-120b, MXFP45,1B de 117B33,5 tok/sReportado: Dendro Logic, vLLM, prompts de 1500 tokens e saída JSON, 22 abr. 2026
Nemotron-3-Super-120B-A12B, NVFP412B de 120Bcerca de 24 tok/sReportado: fórum da NVIDIA, vLLM com uma correção CUTLASS, 29 mar. 2026
Llama 3.3 70B, AWQ 4 bitstodos os 70B (denso)6,0 tok/sA minha execução, vLLM 0.27.1, 2 set. 2026 (registo bruto)
Nemotron Super 49B v1.5, NVFP4todos os 49B (denso)5,79 tok/sReportado: Dendro Logic, 22 abr. 2026
Qwen3-235B-A22B, UD-Q4_K_XL (134 GB)22B de 235Bcerca de 1,8 tok/s; não cabeReportado: 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

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

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.

Primeiro carregamento: pague $ 20 e receba $ 30 em crédito

Carregue um modelo de 120B num Spark só seu.

Um DGX Spark dedicado com 128 GB de memória unificada, $ 0,79/h faturado ao minuto. Termine a instância quando acabar e a faturação para.

Implementar agora