Gemma 4 en local, qué variante cabe en tu GPU

Tienes una tarjeta gráfica concreta y una pregunta concreta: cuál de las variantes de Gemma 4 te entra. Google publicó la familia el 2 de abril de 2026 con cinco tamaños y licencia Apache 2.0, y los pesos son solo la mitad del cálculo. Aquí están las cifras de memoria de cada variante, las etiquetas reales de Ollama y lo que cuesta la ventana de contexto, que es lo que suele reventar el presupuesto.

Puntos clave

• Son cinco tamaños, no cuatro: E2B, E4B, 12B Unified, 26B A4B y 31B Dense.
• La E de E2B y E4B significa parámetros efectivos; la A de 26B A4B, parámetros activos.
• Los 256K de contexto son para el 12B, el 26B y el 31B. El E2B y el E4B se quedan en 128K.
• A 4 bits el 31B pesa 20 GB en Ollama, y su ventana completa añade unos 10,8 GiB más de caché.
• La licencia es Apache 2.0, que sustituye a los términos propios que gobernaban Gemma 1, 2 y 3.

Qué es Gemma 4 y qué significan esas letras

Gemma 4 es la familia de modelos de pesos abiertos de Google DeepMind, multimodal de entrada (texto e imagen en todos, además de audio en el E2B, el E4B y el 12B) y de salida solo texto. La ficha oficial lista cinco variantes: E2B, E4B, 12B Unified, 26B A4B y 31B Dense.

Las letras no son adorno. Sobre el prefijo E, la ficha del modelo dice literalmente: "The ‘E’ in E2B and E4B stands for ‘effective’ parameters". Los dos pequeños usan Per-Layer Embeddings, tablas de incrustaciones por capa que son enormes pero que solo sirven para consultas rápidas, de modo que el recuento efectivo queda muy por debajo del total. El E2B declara 2,3B efectivos sobre 5,1B con las incrustaciones; el E4B, 4,5B sobre 8B.

La A del 26B A4B es otra cosa: parámetros activos. Es un modelo de mezcla de expertos con 25,2B totales, de los que activa 3,8B por token (8 expertos de 128, más uno compartido). Rinde como un modelo de 4B en velocidad, pero ocupa memoria como uno de 25B, porque todos los expertos tienen que estar residentes. Esa distinción se paga en la factura de VRAM y conviene tenerla clara antes de descargar nada.

Cuánta memoria ocupa cada variante

Google publica su propia tabla de memoria de inferencia. Incluye un 20% de sobrecarga de carga, pero avisa de que son "the memory required to load the static model weights" y de que no cuentan ni el software auxiliar ni la ventana de contexto. Junto a esas cifras pongo el tamaño real del GGUF que sirve Ollama, que no siempre coincide.

La sorpresa está arriba. La etiqueta genérica gemma4:e2b pesa 7,2 GB, dos veces y media la estimación de Google para 4 bits, porque esas tablas de incrustaciones por capa no bajan de precisión en el GGUF. La variante entrenada con cuantización, gemma4:e2b-it-qat, se queda en 4,3 GB. Lo mismo pasa con el E4B: 9,6 GB en la etiqueta normal frente a 6,1 GB en la QAT. En los modelos pequeños, descargar la etiqueta por defecto sale caro.

Qué etiqueta descargar en Ollama

La biblioteca de Ollama publica 50 etiquetas de gemma4 y acumula 23,8 millones de descargas. La documentación de Google resume la correspondencia: gemma4:e2b, gemma4:e4b, gemma4:26b y gemma4:31b.

ollama pull gemma4:e2b-it-qat       # portátil sin GPU, o tarjeta de 8 GB
ollama pull gemma4:12b-it-qat       # tarjeta de 12 GB
ollama pull gemma4:26b-a4b-it-qat   # 24 GB: el MoE, rápido y con 256K
ollama pull gemma4:31b-it-qat       # lo máximo en 24 GB, recortando contexto

OLLAMA_CONTEXT_LENGTH=32768 ollama serve
ollama ps                           # comprueba CONTEXT y el reparto GPU/CPU

En un Mac con Apple Silicon hay etiquetas MLX equivalentes (gemma4:31b-mlx, 19 GB) que usan el motor nativo en lugar de llama.cpp. Si todavía no tienes el motor instalado, están la guía de instalación de Ollama y la versión para Mac con Apple Silicon. Y si las siglas de cuantización te suenan a ruido, en cuantización de modelos con llama.cpp está el porqué de cada nivel.

Lo que cuesta de verdad la ventana de contexto

Aquí es donde se pierde la memoria. Los pesos son una cifra fija; el caché de claves y valores crece con cada token que metes. Gemma 4 mezcla capas de atención local con capas globales, y la ficha del modelo explica el truco: "To optimize memory for long contexts, global layers feature unified Keys and Values, and apply Proportional RoPE (p-RoPE)".

El cálculo sale de la configuración publicada del 31B. Tiene 60 capas: 50 con ventana deslizante de 1024 tokens y 10 globales. Las globales usan 4 cabezas de clave-valor de dimensión 512, con clave y valor unificados, en 16 bits. Es decir, 10 capas por 4 cabezas por 512 por 2 bytes: 40 KiB por token.

Las 50 capas deslizantes aportan unos 800 MiB fijos, porque nunca guardan más de su ventana de 1024 tokens. Sumando los 20 GB de pesos, el 31B a 256K pide unos 31 GB: una tarjeta de 24 GB no llega. A 32K sí entra, con unos 22 GB en total y poco margen.

Detalle que despista a mucha gente: Ollama no abre la ventana entera por su cuenta. Su documentación fija el contexto por defecto según la memoria disponible, 4K por debajo de 24 GiB de VRAM, 32K entre 24 y 48, y 256K a partir de ahí. Si no tocas OLLAMA_CONTEXT_LENGTH, esos 256K del titular no existen en tu equipo.

Qué tal se le da el español

Google declara soporte inmediato para más de 35 idiomas y preentrenamiento en más de 140. No publica una puntuación específica de español, así que cualquier cifra concreta al respecto habría que desconfiarla. Lo que sí hay es MMMLU, el MMLU multilingüe: 88,4% en el 31B, 86,3% en el 26B, 83,4% en el 12B, 76,6% en el E4B y 67,4% en el E2B, frente al 70,7% de Gemma 3 27B.

Traducido a la práctica: los dos grandes escriben castellano correcto y sostienen registro; el E2B se despeina en frases largas y arrastra construcciones que suenan a traducción. Si el uso es redactar en español, el salto del E4B al 12B se nota más que cualquier otro salto de la familia.

Qué cambia respecto a Gemma 2 y Gemma 3

La propia ficha incluye una columna con Gemma 3 27B sin razonamiento, y la comparación es contundente. En MMLU Pro, 85,2% del 31B contra 67,6%. En AIME 2026 sin herramientas, 89,2% contra 20,8%. En LiveCodeBench v6, 80,0% contra 29,1%. Incluso el E4B, con 4,5B efectivos, supera al 27B de la generación anterior en programación (52,0% contra 29,1%).

Los cambios de fondo son el modo de razonamiento configurable, la llamada a funciones nativa, el rol de sistema propio y la ventana larga. Si vienes de la generación de 2024, en Gemma 2, el modelo abierto de Google está el punto de partida de esta familia.

La licencia: Apache 2.0 en lugar de los términos de Gemma

Este es el cambio menos vistoso y el que más importa si vas a montar algo comercial. Gemma 1, 2 y 3 se distribuyeron bajo los Gemma Terms of Use, un acuerdo propio de Google. Obligaba a propagar las restricciones de uso como cláusula ejecutable a cualquier tercero al que redistribuyeras el modelo o un derivado, incorporaba por referencia una política de usos prohibidos y reservaba a Google el derecho de restringir el uso, incluso de forma remota.

Gemma 4 se publica bajo Apache 2.0. La página de términos antiguos lo dice sin rodeos: "For Gemma 4 terms, see the Gemma 4 license", y esa licencia es Apache 2.0 sin más. Desaparecen la propagación de restricciones y la política de usos prohibidos como obligación contractual, y queda una licencia permisiva estándar que ya sabes leer. Para un producto, la diferencia entre revisar un acuerdo a medida y aplicar Apache 2.0 se mide en horas de abogado.

Frente a Qwen y Llama en el mismo hueco

El rival directo en una tarjeta de 24 GB es Qwen3.8-27B: su etiqueta qwen3.8:27b en q4_K_M pesa 18 GB con 256K de ventana, también Apache 2.0, y sale dos gigas más barata que el 31B de Gemma. La ventaja de Gemma está en los peldaños que Qwen no cubre: el 26B A4B, que va casi tan rápido como un 4B, y la pareja E2B/E4B para equipos sin GPU.

Llama 4 sencillamente no juega en esta liga. Su etiqueta más pequeña, llama4:scout, ocupa 67 GB en q4_K_M. No hay escalón de consumo. Si quieres ver el resto de la cosecha reciente, está el repaso de modelos abiertos de agosto de 2026, y para encajar cualquiera de ellos en un flujo con herramientas, modelos abiertos con tool calling.

Veredicto por tipo de equipo

Preguntas frecuentes

¿Puedo ejecutar el 31B en una tarjeta de 24 GB?

Sí, con la ventana recortada. Los pesos de la etiqueta QAT ocupan 19 GB y a 32K tokens el caché añade unos 2 GiB, así que cabe con poco aire. A 256K son unos 31 GB y no entra.

¿Merece la pena el 26B A4B frente al 31B?

Depende de qué te duela. El 26B ocupa 3 GB menos y responde mucho más rápido, porque solo activa 3,8B de parámetros por token. El 31B gana en todos los indicadores, pero la diferencia en MMLU Pro es de 2,6 puntos. Para uso interactivo, el MoE suele ser la mejor compra.

¿Necesito una GPU de NVIDIA?

No. Ollama publica etiquetas MLX para Apple Silicon con los mismos tamaños, y las variantes E2B y E4B funcionan en CPU con una lentitud tolerable. Lo que manda es la memoria unificada o la VRAM disponible, no la marca.

Conclusión

Elegir variante de Gemma 4 es un problema de contabilidad, no de gustos. Suma los pesos de la etiqueta que vas a descargar, suma el caché del contexto que de verdad vas a usar y compara con tu memoria. Las etiquetas QAT ahorran entre uno y tres gigas frente a las genéricas y no piden nada a cambio, y el 26B A4B es el punto dulce de toda la familia en una tarjeta de 24 GB. La versión en inglés de este artículo está en Gemma 4 locally, which size fits your GPU.

Fuentes

1. Google DeepMind, ficha del modelo Gemma 4
2. Google, tabla de memoria de inferencia de Gemma 4
3. Google, anuncio de Gemma 4
4. Google, Gemma Terms of Use
5. Ollama, etiquetas de gemma4
6. Ollama, longitud de contexto por defecto
7. Hugging Face, google/gemma-4-31B-it