DGX Spark/Modelos grandes
Caso de uso · Modelos grandes

Ejecuta modelos de clase 70B a 120B en 128 GB de memoria unificada

Por Samuel Seidel · Actualizado el 10 de noviembre de 2026 · 7 min de lectura

Un DGX Spark tiene 128 GB de memoria compartida por su CPU y su GPU, así que modelos que nunca caben en una tarjeta gráfica de 24 o 32 GB se cargan de una pieza. Caber no es lo mismo que ser rápido. La memoria mueve 273 GB/s, y cada token generado lee una vez los pesos activos del modelo. En uno de mis Sparks, un Llama 3.3 70B denso generó 6,0 tokens por segundo con una sola solicitud. Un modelo mixture-of-experts solo lee una parte de sus pesos por token: gpt-oss-120b alcanza 58,7 tok/s en el mismo chip, según las mediciones publicadas. Elige el modelo según el ancho de banda y luego alquila un Spark por las horas que necesites.

Primera recarga: paga 20 $ y recibe 30 $ de crédito, unas 37 horas en un Spark. Facturado por minuto con crédito prepago. Termina la instancia cuando acabes y se deja de facturar.

Qué cabe y a qué velocidad va una solicitud

Modelo y formatoLeído por tokenUna solicitudFuente
Qwen3-Coder 30B-A3B, AWQ de 4 bitsunos 3B parámetros80,9 tok/sMi ejecución, vLLM 0.27.1, 2 sep. 2026 (log sin editar)
gpt-oss-120b, MXFP45,1B de 117B58,7 tok/sPublicado: resultados de llama.cpp en DGX Spark, build 7941, 5 feb. 2026
gpt-oss-120b, MXFP45,1B de 117B33,5 tok/sPublicado: Dendro Logic, vLLM, prompts de 1500 tokens y salida JSON, 22 abr. 2026
Nemotron-3-Super-120B-A12B, NVFP412B de 120Bunos 24 tok/sPublicado: foro de NVIDIA, vLLM con un arreglo de CUTLASS, 29 mar. 2026
Llama 3.3 70B, AWQ de 4 bitslos 70B (denso)6,0 tok/sMi ejecución, vLLM 0.27.1, 2 sep. 2026 (log sin editar)
Nemotron Super 49B v1.5, NVFP4los 49B (denso)5,79 tok/sPublicado: Dendro Logic, 22 abr. 2026
Qwen3-235B-A22B, UD-Q4_K_XL (134 GB)22B de 235Bunos 1,8 tok/s; no cabePublicado: foro de NVIDIA, llama.cpp, 17 dic. 2025

Las filas "Publicado" son mediciones de otras personas, que recopilé y comprobé con sus fuentes el 11 de octubre de 2026 para la página de benchmarks; no las he reproducido. Las dos filas de gpt-oss-120b muestran cuánto cambian el motor y la carga de trabajo un mismo modelo en un mismo chip. El número de parámetros de gpt-oss-120b procede de su ficha del modelo, a través de la calculadora de memoria.

Por qué un 70B denso es lento y un MoE de 120B no

Generar un token implica leer una vez de memoria los pesos activos, así que el techo es el ancho de banda de memoria dividido entre los bytes leídos 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)

Los motores reales quedan entre aproximadamente la mitad y cuatro quintos del techo. Por debajo de unos 10 tok/s, un modelo se nota lento en una ventana de chat, por eso un 70B denso en un Spark es un modelo para lotes: con 128 solicitudes en curso, mi ejecución de 70B llegó a 485 tok/s en total, contando tokens del prompt y generados, pero cada solicitud bajó a 1,4 tok/s. Las curvas completas de concurrencia están en la página de benchmarks.

Lo que yo ejecutaría

Ejecuta gpt-oss-120b con llama.cpp

Para un usuario cada vez, llama.cpp es el motor más rápido en este chip. Despliega DGX Spark 1× con la imagen DGX OS, abre el terminal del navegador, compila llama.cpp para el GB10 (de 5 a 10 minutos) y arranca el modelo. Los pasos de compilación son los mismos que en mi guía de 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

Cuando el log diga que el servidor está escuchando, mide tu propia velocidad desde un segundo terminal. llama-server devuelve sus tiempos con cada respuesta:

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")'

El reloj corre también durante la descarga, así que lánzala primero y ve leyendo mientras baja. Para llegar al servidor desde tu portátil, usa un túnel SSH con tu propia clave, o arráncalo con --host 0.0.0.0 --api-key y una clave aleatoria larga: cada instancia tiene su propia dirección IPv4 pública. Para varios usuarios a la vez, vLLM agrupa mejor las solicitudes; la guía de vLLM tiene los cálculos de memoria unificada.

Límites que conviene conocer antes

Precio y dónde están los Sparks

0,79 $ la hora por un Spark, facturado por minuto con crédito prepago: 6,32 $ por una jornada de ocho horas. Primera recarga: paga 20 $ y recibe 30 $ de crédito. Una instancia detenida conserva su espacio de trabajo y se factura al 75% de la tarifa por hora. Termina la instancia cuando acabes y se deja de facturar; eso borra el espacio de trabajo. Los precios no incluyen el IVA cuando corresponda.

Mis propios Sparks están en un centro de datos en Hradec Králové, República Checa. Los Sparks de socios, propiedad de socios que los alojan en sus propias instalaciones, están en EE. UU., Suecia, los Países Bajos, Eslovaquia y Hong Kong; un socio tiene acceso físico a su máquina. La consola muestra el país, y si está en el EEE, antes de desplegar. Todas las ubicaciones ofrecen las imágenes DGX OS y Ubuntu usadas arriba.

Quién está detrás

GPUwerk es nuevo. Lo dirijo yo, Samuel Seidel, a través de PRINT IT! SE, una empresa registrada en Praga. A 9 de noviembre de 2026, 94 desarrolladores han iniciado 374 instancias desde septiembre. El estado en tiempo real está en status.gpuwerk.com, y la página de contacto llega directamente a mí si quieres comprobar un modelo antes de alquilar.

Preguntas frecuentes

¿Puede un DGX Spark ejecutar un modelo de 70B?

Sí. Llama 3.3 70B en AWQ de 4 bits ocupa unos 37 GiB de pesos y cabe con margen, pero generó 6,0 tokens por segundo con una sola solicitud en uno de mis Sparks (vLLM 0.27.1, 2 de septiembre de 2026). Eso encaja mejor con trabajos por lotes que con chat.

¿Cabe gpt-oss-120b en un solo DGX Spark?

Sí. Sus pesos MXFP4 suman 65,2 GB, y lee unos 5,1B parámetros por token. Los mantenedores de llama.cpp publican 58,7 tok/s para una solicitud; Dendro Logic publica 33,5 con vLLM, con prompts más largos y salida JSON. No lo he medido en mi flota.

¿Y los modelos de más de 128 GB?

Necesitan dos Sparks enlazados. Una versión de Qwen3-235B-A22B de 134 GB funcionó a unos 1,8 tok/s en un Spark y a unos 12,5 en dos, según un informe en el foro de desarrolladores de NVIDIA. El clúster de dos nodos de GPUwerk cuesta 1,79 $ la hora cuando la consola lo ofrece.

¿Cuánto cuesta probar un modelo grande?

0,79 $ la hora por un Spark, facturado por minuto con crédito prepago; la primera descarga y la compilación de llama.cpp también cuentan. Primera recarga: paga 20 $ y recibe 30 $ de crédito, unas 37 horas. Termina la instancia cuando acabes y se deja de facturar.

Primera recarga: paga 20 $ y recibe 30 $ de crédito

Carga un modelo de 120B en un Spark solo para ti.

Un DGX Spark dedicado con 128 GB de memoria unificada, 0,79 $/h facturado por minuto. Termina la instancia cuando acabes y se deja de facturar.

Desplegar ya