
Los drafts de NVIDIA para Qwen3.8-27B en 16 GB: 43 tokens por segundo contra 88 del MTP
NVIDIA publicó tres modelos borrador para acelerar Qwen3.8-27B. Los convertí a GGUF y los medí en una RTX 4070 Ti SUPER con los mismos tokens de mi post anterior: en llama.cpp aceleran como mucho 14 % en el agregado, con muestreo solo ayudan en código y agentes, rinden lo mismo que un Qwen3.5-0.8B sin entrenar, y el de 4B no cabe junto al modelo. El MTP llega a 88 tokens por segundo.
En septiembre medí ExLlamaV3 contra llama.cpp con Qwen3.8-27B en mi RTX 4070 Ti SUPER de 16 GB. La decodificación especulativa con MTP más que duplicaba la velocidad en los dos motores. El 17 de noviembre NVIDIA publicó tres modelos borrador entrenados para ese mismo Qwen3.8-27B. Según su tabla, el de 4B deja 5,58 tokens por paso de verificación contra 3,81 de la cabeza MTP del propio modelo; los otros dos quedan cerca o por debajo del MTP.
Los convertí a GGUF y los puse en la misma batería de septiembre, con los mismos tokens de entrada. En llama.cpp, el mejor borrador de NVIDIA que cabe llegó a 43,5 tokens por segundo en modo greedy, contra 38,3 sin borrador y 88,0 con MTP. Con muestreo, la política para la que los entrenaron, ayudó en código y agentes y frenó en texto creativo y traducción; en el agregado quedó igual que sin borrador. Un Qwen3.5-0.8B sin entrenar rindió lo mismo que el de NVIDIA, y el de 4B no cupo; reduciendo el modelo para que entrara, fue más lento que sin borrador.
Qué publicó NVIDIA
Tres modelos completos, no cabezas: Qwen3.5-0.8B, Qwen3.5-4B y Llama-3.2-1B con el vocabulario de Qwen. Los entrenaron con Model Optimizer para imitar la distribución de salida de Qwen3.8-27B. El borrador propone un bloque de tokens y el modelo grande lo verifica de una pasada; en teoría, lo que sale es lo mismo que el grande habría escrito solo.
Su ficha dice que están pensados para el LPU Groq 3 y que también cargan en vLLM, SGLang y TRT-LLM. Con bloques de 16 tokens y muestreo a temperatura 1, en promedio sobre 11 categorías, el de 4B deja 5,58 tokens por paso, el de 0,8B 3,92, el Llama-1B 3,42 y la cabeza MTP 3,81. Esas cifras no las reproduje: son de NVIDIA, en su hardware, y no dicen cuánto tarda cada paso.
Mi pregunta es otra: qué pasa en llama.cpp, en una tarjeta de 16 GB, contra el MTP que ya uso.
Cómo lo medí
- Modelo grande: el mismo
Q3_K_Mde septiembre, 13,5 GB (12,57 GiB), recuantizado desde elQ8_0de Unsloth con la matriz de importancia del post de cuantización a medida. - Motor: llama.cpp del 18 de noviembre (commit
98d67c8, ya en la serie 1.0), compilado con CUDA 12.9. - Borradores: los tres de NVIDIA convertidos con
convert_hf_to_gguf.py, el MTP de 1,37 GB que publica Unsloth, y como línea base un Qwen3.5-0.8B original, sin ningún entrenamiento para esto. Si el borrador de NVIDIA no le gana a ese, su entrenamiento no se nota aquí. - Prompts: los 15 de la batería de ExLlamaV3 que caben en 16 mil tokens de contexto (código, agentes con herramientas, traducción, texto creativo), los mismos ids de tokens de septiembre, hasta 1 024 tokens nuevos por prompt.
- Dos modos: greedy, como en septiembre, y muestreo con la política que NVIDIA declara (temperatura 1, top-k 20, top-p 0,95, aceptación probabilística del borrador).
La velocidad es tokens generados sobre tiempo de generación, sumada sobre los 15 prompts. Esa suma pesa por largo de respuesta: los dos prompts agénticos aportan menos de 150 tokens y los de texto creativo y traducción varios miles. Por eso doy también cifras por categoría.
La GPU es compartida, con ComfyUI y el escritorio (525 MiB entre los dos) y un servicio que detuve mientras medía. Una primera batería completa salió contaminada por otro trabajo que usó la GPU a mitad de camino, y la descarté. La definitiva espera a que la GPU quede sin procesos ajenos, la vigila mientras mide y repite cualquier configuración donde aparezca uno. Hay una ejecución por configuración y, con muestreo, una sola semilla. Como control de ruido tengo la mitad greedy de la batería descartada: en las cuatro configuraciones que se ejecutaron antes de la interferencia coincidió con la definitiva a 1,2 % como máximo, sobre el mismo texto.
Ese último detalle importa. En greedy, llama.cpp no reproduce bit a bit cuando verifica en lote: 3 de los 15 prompts, todos de texto creativo, generan respuestas de largo distinto según el borrador, también con el MTP. Las velocidades de esos tres comparan textos un poco distintos; los otros 12 son idénticos en todas las configuraciones.
La ficha con las reglas de decisión la escribí después de la batería principal y antes del experimento con el modelo reducido; está en el repositorio con su fecha.
Los tropiezos
- La caché no cabía como en septiembre. Con decodificación especulativa, llama.cpp guarda varias copias del estado recurrente del modelo, y el MTP con la caché en f16 y 16 mil tokens no cargó. La pasé a
q8_0, la misma que septiembre usó en sus pruebas de contexto largo, y entró con 15 555 MiB de pico. - El borrador de 4B no cabe. En
Q4_K_Mpesa 2,74 GB y no cargó. Lo bajé aQ3_K_S(2,07 GB) y aQ2_K(1,97 GB): tampoco; enQ2_Kfalla al reservar los 272 MiB de su propia caché. Es con 525 MiB ya ocupados, 16 mil tokens y caché q8_0: en una tarjeta sin escritorio o con menos contexto podría entrar. - El Llama-1B en
Q8_0tampoco. Pesa 1,59 GB por el vocabulario de 248 mil tokens de Qwen. Lo medí enQ4_K_M, 1,01 GB.
Velocidad: el MTP duplica, los borradores apenas aceleran
- MTP · ventana 383,9
- Sin borrador38,3
- NVIDIA 0,8B · ventana 637,7
- Qwen3.5-0.8B sin entrenar · ventana 637,3
- NVIDIA Llama-1B · ventana 336,3
- NVIDIA 0,8B · ventana 1234,9
RTX 4070 Ti SUPER 16 GB, llama.cpp 98d67c8, contexto 16k con caché q8_0. Mismos ids de tokens que la batería de septiembre. Tokens generados sobre tiempo de generación, sumado sobre los 15 prompts. Una ejecución por configuración, sin procesos ajenos en la GPU.
En greedy los borradores rinden un poco más, porque aciertan más cuando el modelo grande no sortea. La ventana es el máximo que el borrador puede proponer; llama.cpp no siempre la llena. Con ventana 3, 6 y 12, el de 0,8B propuso en promedio 2,0, 3,5 y 6,5 tokens por paso, y el MTP 3,0 con ventana 3. No investigué de dónde sale ese corte.
| Configuración | Greedy (tok/s) | Muestreo (tok/s) | Aceptación greedy | Aceptación muestreo |
|---|---|---|---|---|
| Sin borrador | 38,3 | 38,3 | ||
| MTP, ventana 3 | 88,0 | 83,9 | 68,8 % | 64,1 % |
| NVIDIA 0,8B, ventana 3 | 41,2 | 35,9 | 63,9 % | 50,8 % |
| NVIDIA 0,8B, ventana 6 | 43,5 | 37,7 | 45,1 % | 35,6 % |
| NVIDIA 0,8B, ventana 12 | 42,2 | 34,9 | 28,8 % | 21,3 % |
| Qwen3.5-0.8B sin entrenar, ventana 3 | 41,5 | 36,2 | 63,5 % | 51,3 % |
| Qwen3.5-0.8B sin entrenar, ventana 6 | 46,1 | 37,3 | 48,0 % | 34,9 % |
| NVIDIA Llama-1B, ventana 3 | 40,6 | 36,3 | 56,5 % | 46,1 % |
| NVIDIA Llama-1B, ventana 6 | 41,2 | 34,6 | 37,9 % | 27,8 % |
El mejor resultado de un borrador fue el Qwen3.5-0.8B sin entrenar, con 46,1 tokens por segundo en greedy: un 20 % sobre no usar borrador. El de NVIDIA del mismo tamaño aceptó prácticamente lo mismo: 63,9 % contra 63,5 % con ventana de 3. Con una sola ejecución por configuración no afirmo que uno sea mejor que otro. Afirmo que, en llama.cpp, el entrenamiento no produjo una diferencia que se vea en esta prueba.
Antes de escribir eso revisé que no fuera la conversión. Generé con el Qwen3.8-27B las respuestas a los mismos prompts y medí cuánto le cuesta a cada modelo chico predecir ese texto (perplexity, menor es mejor). En GGUF, el de NVIDIA dio 5,06 y el original 3,88. Con los pesos originales en transformers, sin pasar por GGUF, 5,81 y 4,62. La conversión no cambia el orden: el borrador de NVIDIA predice peor que el original este texto del 27B, leído sin su prompt y escrito en greedy. NVIDIA lo entrenó con respuestas a temperatura 1 y con su prompt delante, así que esta prueba no lo descalifica; solo descarta que el empate venga de un GGUF roto.
Por categoría, con muestreo, el borrador de NVIDIA sí ayuda en algunas. En código pasa de 39,2 a 48,2 tokens por segundo con ventana 6. En los dos prompts agénticos, de 38,0 a 57,2 y de 37,2 a 59,7, aunque cada uno deja apenas 51 y 75 tokens, así que esas dos cifras son ruidosas. En la repetición trivial, un solo prompt, llega a 146,7 con ventana 12, más que los 118,9 del MTP. En texto creativo y traducción, en cambio, todos los borradores externos quedaron por debajo de no usar borrador, y como son las respuestas más largas, mandan en el agregado.
Por qué: el costo de cada paso
La decodificación especulativa avanza por pasos. En cada uno, el borrador propone unos tokens y el modelo grande los verifica de una pasada; sale lo aceptado más un token del modelo grande. La velocidad final es cuántos tokens deja cada paso dividido por lo que tarda.
El MTP deja más tokens por paso y además cada paso le cuesta 23 ms menos que al borrador de NVIDIA. Los pasos se derivan de los contadores: tokens generados menos tokens aceptados, porque cada paso deja lo aceptado más uno.
Sin borrador, cada token cuesta 26,1 ms. El MTP gasta 34,7 ms por paso en greedy y saca 3,05 tokens: le sobra margen. El borrador de 0,8B de NVIDIA gasta entre 55,8 y 67,9 ms por paso y saca entre 2,30 y 2,87 tokens. Con eso apenas le gana a no usar borrador: entre 8 y 14 %.
¿De dónde sale la diferencia? La comparación más limpia es el borrador de NVIDIA con ventana 3 contra el MTP: el borrador propone en promedio 2,0 tokens por paso y su paso cuesta 55,8 ms; el MTP propone 3,0 y el suyo cuesta 34,7. Son 21 ms más proponiendo menos. Mi primera explicación fue que el borrador escribe su propuesta token por token antes de cada verificación. La medí y no alcanza: el de 0,8B, solo en la GPU, genera 454 tokens por segundo sin contexto y 420 con 8 mil tokens de contexto, entre 2,2 y 2,4 ms por token. Dos tokens son unos 5 ms. Quedan unos 16 ms en el camino del borrador externo dentro de llama.cpp: dos contextos que se sincronizan y lo que haga falta para deshacer lo rechazado en un modelo con estado recurrente. No lo aislé. La cabeza MTP es una capa extra que reutiliza el estado del modelo grande, y su paso cuesta 8,6 ms más que un token sin borrador.
Con ventana 12 el borrador propone más, pero con muestreo acierta el 21 %: gasta más tiempo y la mayor parte se descarta.
Hay partes que no puedo separar. NVIDIA midió en vLLM sobre un LPU, donde ejecutar el borrador puede costar mucho menos que en una tarjeta de consumo con llama.cpp, y su ficha lista Blackwell como hardware soportado; la mía es Ada. Su tabla de tokens por paso no dice nada del tiempo de cada paso, y en esta tarjeta el tiempo es lo que decide. Además, NVIDIA entrenó los borradores con secuencias de hasta 12 288 tokens y prompts de menos de 3 072; seis de mis prompts tienen entre 9 y 13,7 mil tokens, y tres pasan los 12 288.
La memoria: el MTP entra justo
- Sin borrador: línea base
- + MTP · 1,37 GB: el más rápido
- + NVIDIA 0,8B · Q8_0: 0,81 GB
- + NVIDIA Llama-1B · Q4_K_M: 1,01 GB
Los picos incluyen los 525 MiB que ocupan ComfyUI y el escritorio. El de 4B no aparece porque no llegó a cargar.
¿Y si reduzco el modelo para que entre el de 4B?
El de 4B es el único al que la tabla de NVIDIA le da una ventaja clara sobre el MTP, así que lo probé de la única forma que entra: reduciendo el modelo grande. Con el dial de cuantización a medida (el PR #15550 de llama.cpp, mismo commit y misma matriz de importancia que en septiembre) le pedí a llama-quantize un Qwen3.8-27B con --target-size 10.5g. Salió un archivo de 10,74 GB, 3,14 bits por peso, contra los 13,5 GB del Q3_K_M. Antes de ejecutarlo dejé escrita la regla: el de 4B gana solo si supera al MTP sobre el Q3_K_M por más de 5 % en los dos modos, y si el modelo reducido queda a menos de 2 puntos de acuerdo con el Q8_0.
Con ese modelo, el de 4B en Q4_K_M cargó con un pico de entre 14 348 y 14 352 MiB.
| Sobre el modelo de 10,74 GB | Greedy (tok/s) | Muestreo (tok/s) | Tokens por paso (greedy) | ms por paso (greedy) |
|---|---|---|---|---|
| Sin borrador | 45,1 | 45,1 | 1,00 | 22,2 |
| MTP, ventana 3 | 85,4 | 83,3 | 2,91 | 34,0 |
| NVIDIA 4B, ventana 3 | 36,3 | 33,0 | 2,54 | 70,1 |
| NVIDIA 4B, ventana 6 | 38,1 | 31,6 | 3,18 | 83,4 |
| NVIDIA 4B, ventana 12 | 34,2 | sin medir | 3,66 | 107,0 |
El de 4B es el que más tokens deja por paso de todo lo que medí: 3,66 con ventana 12, más que los 2,91 del MTP, que con ventana 3 no puede dejar más de 4. Y aun así es el más lento, porque cada paso le cuesta 107 ms. Con cualquier ventana queda por debajo del mismo modelo sin borrador. El MTP sobre este modelo llega a 85,4, casi lo mismo que sobre el Q3_K_M, aunque su aceptación baja de 68,8 % a 63,8 %: el borrador MTP es el mismo archivo, pero el modelo grande cambió.
La calidad la medí con llama-perplexity y la divergencia KL contra el Q8_0, contexto de 512 tokens, sobre el texto de evaluación del post del dial. Estas cifras no son comparables con las de los posts anteriores, que usaron otras herramientas u otros textos: la perplexity de aquí no es sobre wikitext, por eso no es el 7,19 que publiqué entonces, y la divergencia del Q3_K_M en el post de ExLlamaV3 salió de qbench.
- Q3_K_M (13,5 GB): divergencia media 0,049, mismo token más probable que el Q8_0 en el 90,7 % de las posiciones, perplexity 5,85.
- A medida de 10,74 GB: divergencia media 0,108, mismo token en el 85,5 %, perplexity 6,13.
El modelo reducido pierde 5,2 puntos de acuerdo con la referencia. La regla dice que el de 4B no gana: va más lento y obliga a usar un modelo peor.
Una celda quedó sin medir: el de 4B con ventana 12 y muestreo. En sus cuatro intentos apareció en la GPU otro trabajo de video, y el script descartó las cuatro ejecuciones.
Mi opinión
Para Qwen3.8-27B en una GPU de 16 GB con llama.cpp, el MTP es la decodificación especulativa que conviene, y por mucho: dobla la velocidad, en los dos modos, y cabe. En llama.cpp, los borradores de NVIDIA aceptan lo mismo que un modelo chico de la misma familia sin entrenar. Y en este motor y en esta tarjeta cada paso con un borrador externo cuesta demasiado, mientras el modelo ya trae uno más barato. Si escribes código o usas agentes con muestreo, el de 0,8B ayuda algo; el MTP ayuda el doble.
Lo que no puedo decir es que no sirvan en lo que NVIDIA los pensó. En un servidor con vLLM y hardware donde el borrador sale casi gratis, sus tokens por paso pueden convertirse en velocidad. No lo medí.
Cuándo sí y cuándo no
- Sí: si tu motor no soporta MTP para este modelo, o si sirves sobre el hardware para el que NVIDIA los entrenó. Con muestreo, en código y agentes el de 0,8B aceleró, y en texto muy repetitivo, un solo prompt, pasó al MTP.
- No: en una GPU de consumo con llama.cpp y MTP disponible; con muestreo en texto creativo o traducción, donde todos los borradores externos quedaron por debajo de no usar ninguno; y el de 4B en mi tarjeta: junto al Q3_K_M de 13,5 GB no carga, y reduciendo el modelo para que entre va más lento que sin borrador.
Fuentes
- Scripts y ficha de esta medición: el arnés, el resumen, el KLD y la receta de compilación. Datos crudos en
lab/drafts-nvidia-qwen38/del repositorio del sitio. - NVIDIA, Qwen3.5-0.8B-Qwen3.8-27B-Draft, Qwen3.5-4B-Qwen3.8-27B-Draft y Llama-3.2-1B-Qwen3.8-27B-Draft, fichas y tablas de aceptación, 17 de noviembre de 2026.
- unsloth/Qwen3.8-27B-GGUF: el
Q8_0de origen y el borrador MTPmtp-Qwen3.8-27B-Q4_0.gguf. - Qwen/Qwen3.5-0.8B, la línea base sin entrenar.
- llama.cpp, commit 98d67c8, el
llama-serverde la batería. - llama.cpp, PR #15550, el dial
--target-size, compilado del commit 325319b. - ExLlamaV3 v1.5.0, eval/spec_decode.py: los prompts de la batería.
Medido del 18 al 20 de noviembre de 2026 en una RTX 4070 Ti SUPER de 16 GB con Ryzen 7 7800X3D y NixOS, llama.cpp 98d67c8 con CUDA 12.9, Qwen3.8-27B Q3_K_M de 13,5 GB.
BOLETÍN · MEDIDO
Una medición nueva, cuando la hay.
Cada post con sus números, sus fallos y los scripts para repetirlo. Entre uno y tres correos al mes. Te das de baja con un clic.
LO ÚLTIMO QUE LLEGÓ
- Tirón de la red cada minutopico ×42,6 menor al azar
- SMS de la muerteAndroid 12 a 17
- Unlimited-OCR 2 en 16 GBempate con Chandra 2, sin memoria a las 80 páginas
Uso Listmonk en mi propio servidor; tu correo no sale de ahí. Confirmas por correo antes de recibir nada.
Comentarios
Todavía no hay comentarios. El primero es tuyo.