Qwen3.6 27B: cuánta VRAM necesita realmente
Un modelo de 27B que gasta la mitad del KV cache de un Llama 3 8B. La arquitectura híbrida rompe el cálculo habitual — y decide, por menos de 1 GB, qué placas quedan fuera.
¿Con prisa? Pide el TL;DR a Claude — lee la página y la resume.
es Traducción automática por qwen3:32b, revisada por el autor. Leer el original en portugués
El Qwen3.6 27B salió en abril de 2026 como modelo denso, licencia Apache 2.0, 262 mil tokens de contexto nativo y entrada multimodal. Denso de 27B suele significar “olvida, no cabe en tu placa”.
Solo que al abrir su config.json la cuenta no cierra como se esperaría. Gasta la mitad del KV cache de un Llama 3 8B — un modelo tres veces y media más pequeño.
La razón está en una línea de la configuración que casi nadie lee.
Qwen3.6-27B · del config.json oficial
- Parámetros
- 27,8 B (denso)
- Capas
- 64
- Atención completa
- solo 16 de ellas
- Cabezas KV
- 4 (GQA 24:4)
- Dimensión de cabeza
- 256
- Contexto nativo
- 262.144 tokens
La línea que cambia todo
En el config.json, entre las claves comunes, está esta:
"full_attention_interval": 4,
"layer_types": ["linear_attention", "linear_attention", "linear_attention", "full_attention", ...]El modelo tiene 64 capas, pero solo una de cada cuatro usa atención completa. Las otras 48 usan atención lineal.
Esta distinción es lo más importante de este post, porque las dos se comportan de manera opuesta en memoria:
- Atención completa guarda un par clave/valor por token, en cada capa. Es el KV cache, y crece sin parar a medida que avanza la conversación.
- Atención lineal mantiene un estado de tamaño fijo, comprimiendo el pasado en un resumen de dimensión constante. Doble el contexto y ese estado no cambia de tamaño.
Es decir: 48 de las 64 capas simplemente no participan en el crecimiento de memoria. Quien aplique la fórmula usual — la del post anterior sobre VRAM — sobre las 64 capas se equivocará por un factor de cuatro.
El KV cache real
La fórmula sigue siendo la misma, cambiando solo cuántas capas entran en ella:
bytes por token = 2 × camadas_de_atenção_plena × cabeças_kv × dim_cabeça × bytes
2 × 16 × 4 × 256 × 2 = 65.536 bytes = 64 KiB por tokenSesenta y cuatro KiB. Para comparar, con la misma matemática:
| Modelo | Capas con KV | KiB/token | 128k de contexto (GB) |
|---|---|---|---|
| Llama 3 8B | 32 de 32 | 128 | 17,18 |
| Qwen3.6 27B (real) | 16 de 64 | 64 | 8,59 |
| Qwen3.6 27B si fuera denso | 64 de 64 | 256 | 34,36 |
Un modelo de 27 mil millones de parámetros con la mitad del costo de contexto de uno de 8 mil millones. Es contraintuitivo, y es la razón por la cual este modelo cabe donde no debería caber.
Los pesos
Con 27,8 mil millones de parámetros:
| Quantización | Pesos (GB) |
|---|---|
| BF16 | 55,6 |
| Q8_0 | 29,5 |
| Q6_K | 22,9 |
| Q5_K_M | 19,8 |
| Q4_K_M | 17,0 |
¿Cabe en tu placa?
Aquí la cuenta encuentra al hardware. Pesos en Q4_K_M, más el KV cache del contexto, más 1 GB de margen para el runtime:
| Máquina | Memoria (GB) | Sobra p/ contexto (GB) | Contexto posible |
|---|---|---|---|
| RTX 5070 · 12 GiB | 12,9 | — | no cabe |
| RTX 5070 Ti · 16 GiB | 17,2 | — | falta 0,8 GB |
| RTX 4090 · 24 GiB | 25,8 | 7,7 | 115k |
| RTX 5090 · 32 GiB | 34,4 | 16,3 | 243k |
| MacBook Pro M4 Max · 48 GiB | 51,5 | 33,5 | 262k (techo) |
| Mini PC · 96 GiB | 103,1 | 85,1 | 262k (techo) |
Mire la segunda línea. La 5070 Ti queda fuera por 0,8 GB — menos del 5% de la memoria de la placa. Los pesos solos ocupan 17,0 de los 17,2 GB que tiene; sobran 200 MB para runtime y contexto, lo que no alcanza ni para cargar.
Es el tipo de margen que hace que alguien compre la placa equivocada. Una placa de 16 GB parece cómoda para un modelo “de 17 GB” hasta que recuerdas que GB de archivo y GiB de placa no son la misma unidad, y aún faltan el cache y el overhead.
¿Qué se puede reproducir ahora
La parte aritmética de este post la puedes verificar tú mismo, sin bajar 17 GB:
# La configuración oficial, la fuente de todo lo anterior
curl -sL https://huggingface.co/Qwen/Qwen3.6-27B/raw/main/config.json \
| python3 -c "
import json,sys
from collections import Counter
t = json.load(sys.stdin)['text_config']
tipos = Counter(t['layer_types'])
plenas = tipos['full_attention']
kv = 2 * plenas * t['num_key_value_heads'] * t['head_dim'] * 2
print('camadas:', t['num_hidden_layers'], dict(tipos))
print('KV por token:', kv, 'bytes =', kv // 1024, 'KiB')
"Y, para verificar en tu propia placa después de bajar:
ollama pull qwen3.6:27b
# Con el contexto declarado: el valor por defecto del runtime no es el que vas a usar
OLLAMA_CONTEXT_LENGTH=131072 ollama run qwen3.6:27b "ok"
# Cuánto reservó de hecho, y si algo se fue a la CPU
ollama ps
nvidia-smi --query-gpu=memory.used,memory.total --format=csv¿Qué aún no sé
Siendo explícito sobre el límite entre lo que este post prueba y lo que solo sugiere.
Probado aquí: la arquitectura híbrida, el KV cache de 64 KiB/token y lo que la aritmética dice sobre cada máquina. Todo derivado del config.json oficial, reproducible con el comando anterior.
Aún no medido: el estado de las capas lineales, el consumo real en la GPU después de cargar, tokens por segundo en cada máquina, y lo que la atención lineal cobra en calidad en un contexto de 200 mil tokens — porque comprimir el pasado en un estado fijo no es gratis, y es justamente la prueba que interesa.
Esta última es la buena pregunta. Un modelo que promete 262k de contexto y cabe en una 4090 es noticia; si recuerda lo que estaba en el token 30 mil cuando llega al 200 mil es otra conversa, y nadie responde eso con aritmética.
En el próximo post lo mido, en las seis máquinas. La cuenta dice lo que cabe; solo la medición dice lo que presta.
Fuentes: config.json oficial en Hugging Face · anuncio del modelo · qwen3.6:27b en Ollama