Tutorial de Multi-Token Prediction: cómo acelerar los LLM

¿Qué es Multi-Token Prediction?

La mayoría de LLM generan texto token a token. El modelo predice el siguiente token, lo añade al contexto y repite el proceso. Es fiable, pero puede ser lento porque cada token nuevo suele requerir otro paso de decodificación.

Multi-Token Prediction cambia esto permitiendo que el modelo se adelante y proponga varios tokens futuros en lugar de solo uno. Estos tokens propuestos se validan con el proceso principal de decodificación. Si las predicciones son correctas, el modelo puede aceptar varios tokens de una vez. Si uno falla, vuelve a la ruta normal desde ese punto.

En la práctica, MTP funciona como un mecanismo de borradores integrado. El modelo bosqueja varios tokens probables, los verifica y conserva los válidos. Cuantos más tokens de borrador se acepten, menos pasos completos de decodificación hacen falta, lo que puede aumentar los tokens por segundo sin cambiar la calidad final de la salida.

En pocas palabras:

• Sin MTP: Generar token 1 → generar token 2 → generar token 3
• Con MTP: Bosquejar varios tokens → verificarlos → aceptar los válidos juntos

Por eso MTP puede hacer que la inferencia local con LLM se sienta mucho más rápida. En lugar de obligar al modelo a avanzar a pequeños pasos, le permite dar saltos seguros cuando sus borradores aciertan. 

En herramientas como llama.cpp y las implementaciones de estilo vLLM-style, esto está muy ligado al speculative decoding, donde los tokens de borrador solo se aceptan cuando coinciden con la salida del verificador. 

1. Configura una máquina RunPod con RTX 3090

Para esta guía, utilicé una instancia GPU de RunPod con una RTX 3090. Puedes usar otra GPU con CUDA, pero los resultados del tutorial se basan en una RTX 3090.

Primero, crea un nuevo pod en RunPod y selecciona una GPU RTX 3090.

Antes de desplegar el pod, edita la plantilla:

• Aumenta el tamaño del disco a 100 GB

• Añade un puerto HTTP adicional: 8910

• Añade una variable de entorno llamada HF_TOKEN y asígnale tu token de acceso de Hugging Face. 

El puerto HTTP extra te permitirá acceder al servidor y a la interfaz web de llama.cpp desde el navegador. El token de Hugging Face ayuda a autenticar la descarga y puede acelerar la bajada de modelos, especialmente para archivos GGUF grandes.

Tras actualizar la plantilla, despliega el pod. Cuando esté en marcha, espera a que RunPod te dé acceso a la instancia de JupyterLab. Abre JupyterLab y lanza un terminal nuevo.

Dentro del terminal, instala los paquetes de sistema necesarios:

apt update
apt install -y git cmake build-essential curl wget python3-pip

2. Clona y cambia a la rama de MTP

A continuación, muévete al directorio de trabajo donde instalaremos y compilaremos llama.cpp:

cd /workspace

Clona el repositorio de llama.cpp:

git clone --depth 1 https://github.com/ggml-org/llama.cpp.git
cd llama.cpp

Los cambios de MTP aún se están probando mediante una pull request dedicada en llama.cpp, así que traemos y cambiamos a esa rama para usar la última implementación de MTP antes de que forme parte del main estándar.

Trae la rama de MTP en local:

git fetch origin pull/22673/head:mtp-pr
git checkout mtp-pr

Esto cambia tu build local de llama.cpp a la versión con MTP activado, que usaremos en el resto de la guía.

3. Compila llama.cpp con soporte CUDA

Ahora que estás en la rama con MTP, compila llama.cpp con soporte CUDA. Así el modelo usará la GPU RTX 3090 en lugar de ejecutar la inferencia en CPU.

Ejecuta la configuración de CMake:

cmake -B build -DGGML_CUDA=ON -DCMAKE_BUILD_TYPE=Release

Luego compila los dos targets que necesitamos para esta guía:

cmake --build build --target llama-cli llama-server -j

Esto compila:

• llama-cli para hacer pruebas rápidas en línea de comandos

• llama-server para lanzar un servidor compatible con OpenAI con acceso desde el navegador

Cuando termine, copia el binario de llama-server al directorio raíz de llama.cpp:

cp ./build/bin/llama-server ./llama-server

Así será más fácil arrancar el servidor desde la raíz del proyecto en los siguientes pasos.

4. Descarga el modelo Qwen3.6-27B-MTP

Ahora descarga el modelo Qwen3.6 27B MTP en GGUF que usaremos para las pruebas. Lo ejecutaremos primero sin MTP y después con MTP activado para comparar la diferencia de velocidad.

Primero, instala las herramientas de descarga de Hugging Face:

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transfer

Luego activa las descargas rápidas de Hugging Face:

export HF_HUB_ENABLE_HF_TRANSFER=1

Esto ayuda a acelerar la descarga de modelos grandes, especialmente con archivos GGUF.

Crea ahora un directorio dedicado para el modelo:

mkdir -p /workspace/models/qwen3.6-mtp

Descarga el modelo Qwen3.6 27B MTP GGUF:

hf download froggeric/Qwen3.6-27B-MTP-GGUF \
 Qwen3.6-27B-Q4_K_M-mtp.gguf \
 --local-dir /workspace/models/qwen3.6-mtp

Si te interesa el fine-tuning de LLM, echa un vistazo a mi tutorial sobre ajustar Qwen3.6 con un dataset de preguntas médicas.

5. Ejecuta Qwen3.6-27B sin MTP

Llegamos a la parte principal: medir la velocidad del modelo antes y después de activar MTP.

Primero, ejecutaremos el modelo sin MTP. Así obtenemos una línea base limpia para comparar después. Usamos el mismo modelo, la misma GPU, el mismo contexto y la misma configuración del servidor. El único cambio importante en el siguiente paso será activar MTP.

Vuelve al directorio llama.cpp:

cd /workspace/llama.cpp

Arranca el servidor sin MTP:

./llama-server \
-m "/workspace/models/qwen3.6-mtp/Qwen3.6-27B-Q4_K_M-mtp.gguf" \
--alias qwen3.6-27b-no-mtp \
--host 0.0.0.0 \
--port 8910 \
-ngl 99 \
-c 100000 \
--cache-type-k q8_0 \
--cache-type-v q8_0 \
-np 1 \
-b 2048 \
-ub 512 \
-t 8 \
-fa on \
--temp 0.7 \
--top-k 20 \
--top-p 0.95 \
--repeat-penalty 1.1 \
--metrics

Esto inicia un servidor de llama.cpp compatible con OpenAI en el puerto 8910.

El modelo puede tardar un poco en cargar porque el servidor debe subir los pesos a la memoria de la GPU. Cuando esté listo, el terminal mostrará que el servidor está disponible en el puerto 8910.

Como expusimos este puerto al configurar la plantilla de RunPod, no tienes que tocar nada más. Vuelve al panel de RunPod y haz clic en el enlace asociado al puerto 8910. Se abrirá la interfaz web de llama.cpp en tu navegador, con el modelo local ya cargado.

Desde ahí, puedes empezar a probar prompts directamente en el navegador, como en una interfaz de chat.

En mi prueba base, el modelo generó respuestas a unos 38,86 tokens/s sin MTP. Incluso con un prompt más complejo, la velocidad se mantuvo en rangos similares. 

Para un modelo de 27B en una RTX 3090, ya es un resultado usable, especialmente teniendo en cuenta que esta GPU es más lenta y tiene menos memoria que tarjetas de data center más nuevas. 

6. Ejecuta Qwen3.6-27B con MTP activado

Ahora ejecutaremos el mismo modelo otra vez, pero con MTP activado.

Vuelve al terminal donde se está ejecutando el servidor y detenlo con:

CTRL + C

Lo importante es que no cambiamos el modelo, la GPU, la cuantización ni la mayoría de parámetros de ejecución. Solo añadimos dos flags de MTP:

--spec-type mtp
--spec-draft-n-max 3

La primera indica a llama.cpp que use speculative decoding de tipo MTP. La segunda fija el máximo de tokens de borrador en 3. Es decir, el modelo puede intentar bosquejar hasta tres tokens futuros antes de verificar.

Arranca de nuevo el servidor con MTP activado:

./llama-server \
-m "/workspace/models/qwen3.6-mtp/Qwen3.6-27B-Q4_K_M-mtp.gguf" \
--alias qwen3.6-27b-mtp \
--host 0.0.0.0 \
--port 8910 \
-ngl 99 \
-c 100000 \
--spec-type mtp \
--spec-draft-n-max 3 \
--cache-type-k q8_0 \
--cache-type-v q8_0 \
-np 1 \
-b 2048 \
-ub 512 \
-t 8 \
-fa on \
--temp 0.7 \
--top-k 20 \
--top-p 0.95 \
--repeat-penalty 1.1 \
--metrics

Cuando el servidor esté listo, recarga la página del navegador. Si no se reconecta automáticamente, ciérrala y vuelve a abrir el enlace del puerto 8910 desde tu panel de RunPod. 

Ahora prueba el modelo otra vez usando el mismo tipo de prompts.

Con MTP activado, la velocidad aumentó de forma notable. Para un prompt sencillo de saludo, el modelo alcanzó unos 65–67 tokens/s. Frente a la base de 38,86 tokens/s, es una mejora enorme con solo dos flags en la línea de comandos. 

Con un prompt más complejo, por ejemplo pedir al modelo que construya un juego sencillo en Python, la velocidad fue algo menor pero siguió siendo mucho más alta que sin MTP. En esa prueba, generó a unos 56–61 tokens/s, un resultado muy sólido para un 27B en una RTX 3090. 

En conjunto, activar MTP mejoró Qwen3.6 27B de unos 38 tokens/s a 65 tokens/s en la configuración de RunPod con RTX 3090. Eso supone una aceleración de 1,71×, o alrededor de un 71% más de rendimiento, sin cambiar de hardware ni pasar a un modelo más pequeño. 

7. Recomendación: más velocidad con TurboQuant

El benchmark de esta guía usa la configuración original de MTP en llama.cpp, sin añadir TurboQuant, parches propios u otras optimizaciones de tiempo de ejecución. Así mantenemos la prueba simple, reproducible y centrada en la ganancia por activar MTP.

Para ir más allá, el siguiente paso a explorar es MTP junto con TurboQuant. MTP mejora el rendimiento permitiendo aceptar varios tokens predichos, mientras que TurboQuant ayuda a reducir la presión de memoria del KV-cache durante la inferencia. 

Esto puede ser especialmente útil con modelos grandes, prompts de contexto largo y GPUs como la RTX 3090, donde el ancho de banda de memoria y la VRAM pueden ser cuellos de botella.

Por eso algunos resultados de la comunidad r/LocalLLaMA reportan más tokens/s que esta guía. Esas configuraciones suelen combinar MTP con TurboQuant, builds parcheadas, distintos ajustes del KV-cache o GPUs más rápidas. Como este tutorial se centra en un benchmark limpio solo con MTP, considera TurboQuant como el próximo experimento recomendado, no parte del setup actual.

Reflexiones finales 

Últimamente he seguido las publicaciones de la comunidad LocalLLaMA en Reddit y es increíble ver lo que ha avanzado la inferencia local con LLM. La gente ya ejecuta modelos como Qwen3.6 27B como agentes de programación locales, incluso en GPUs más antiguas con VRAM limitada. Algunos también montan configuraciones similares en Mac, y los resultados son realmente impresionantes.

Tras probar MTP por mi cuenta, entiendo la expectación. Con el mismo modelo y la misma RTX 3090, activar Multi-Token Prediction mejoró la velocidad de generación de unos 38 tokens/s a 65 tokens/s. Es casi un doble de velocidad sin cambiar de GPU ni pasar a un modelo más pequeño.

Esta guía se centró en un setup de MTP sencillo y reproducible con llama.cpp, pero esto parece solo el principio. El siguiente paso es experimentar con mejores cuantizaciones GGUF, MTP, TurboQuant y ajustes de runtime más finos para ver hasta dónde podemos llevar la velocidad de la inferencia local.

Lo más ilusionante es lo que esto supone para los agentes de programación locales: puedes ejecutar modelos potentes en tu propio hardware, reducir el coste por consulta, mantener tu código en privado y usar un asistente de programación con IA sin depender por completo de APIs en la nube. Los LLM locales están siendo más rápidos, prácticos y útiles que hace muy poco.