# Gemma 4 (26B MoE, 4B activos) {% hint style="info" %} **Estado (abril de 2026):** Gemma 4 fue lanzado el **2 de abril de 2026** por Google como la siguiente generación de la familia Gemma de pesos abiertos. Se distribuyen dos variantes: un modelo **denso de 31B** (`google/gemma-4-31b-it`) y un **MoE de 26B con \~4B de parámetros activos** (`google/gemma-4-26b-it`). Ambos se publican bajo los términos de uso estándar de **Gemma** en [huggingface.co/google/gemma-4-26b-it](https://huggingface.co/google/gemma-4-26b-it) y [huggingface.co/google/gemma-4-31b-it](https://huggingface.co/google/gemma-4-31b-it). {% endhint %} Gemma 4 es la primera entrada MoE de Google en la línea Gemma y el primer lanzamiento de Gemma que subió a lo más alto de la LMSYS Arena (según informes del proveedor **n.º 3 en general en el lanzamiento**, superando a varios modelos cerrados en factualidad y seguimiento de instrucciones). La cifra principal es la variante MoE: **26B de parámetros totales, \~4B activos por token**, lo que te ofrece un seguimiento de instrucciones casi de frontera al coste de inferencia de un pequeño modelo denso. Para los usuarios de Clore.ai, la conclusión práctica es simple: el MoE de 26B funciona cómodamente en una sola **RTX 4090 (24GB)** con cuantización FP8 o de 4 bits (\~10 tok/s) y alcanza un rendimiento de nivel producción en una sola **H100 80GB** (\~40+ tok/s), poniendo el seguimiento de instrucciones de calidad Gemma al alcance por aproximadamente $0.5–2/día en el marketplace. La variante densa de 31B es la hermana más capaz pero más cara, y necesita 2× RTX 4090 o 1× H100 para servirla. ## Características clave * **Arquitectura MoE (variante de 26B)** — 26B de parámetros totales, \~4B activados por token; paga un coste de inferencia de clase 4B por una calidad de clase 26B * **Alternativa densa (variante de 31B)** — para equipos que prefieren la previsibilidad y la madurez de herramientas de la inferencia densa * **Ventana de contexto de 128K** — preguntas y respuestas sobre documentos largos, RAG sobre bases de código de tamaño medio, bucles de agente de múltiples turnos * **Fuerte seguimiento de instrucciones** — Gemma 4 está ajustado explícitamente para uso de herramientas, salida estructurada y seguimiento fiel de restricciones * **Multilingüe** — se mantiene la cobertura multilingüe completa de Gemma 3, además de un conjunto ampliado de benchmarks en otros idiomas * **Pesos abiertos, términos de Gemma** — gratis para la mayoría de usos comerciales; revisa la [Política de uso prohibido de Gemma](https://ai.google.dev/gemma/prohibited_use_policy) antes de ponerlo en producción * **Herramientas de primera clase** — compatible de serie con vLLM, SGLang, Ollama y Hugging Face Transformers ## Elige tu variante | Variante | Parámetros totales | Activos | Contexto | Cuantización recomendada | GPU Clore recomendada | | ---------------------------------------- | ------------------ | -------------- | -------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------------ | | **Gemma 4 26B MoE** (`gemma-4-26b-it`) | 26B | \~4B por token | 128K | FP8 o GPTQ de 4 bits | 1× [RTX 4090](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=gemma4) (24GB, cuantizado) | | **Gemma 4 31B Denso** (`gemma-4-31b-it`) | 31B | 31B (todos) | 128K | FP8 o BF16 | 1× [H100](https://clore.ai/rent-h100.html?utm_source=docs\&utm_medium=guide\&utm_campaign=gemma4) (80GB, BF16) | {% hint style="success" %} **Elección práctica:** Para el 90% de las implementaciones en una sola GPU, elige **Gemma 4 26B MoE en FP8**. Obtienes la calidad destacada de la Arena a \~10–15 tok/s en una 4090 y \~40+ tok/s en una H100, sin el coste de latencia de la inferencia densa de 31B. {% endhint %} *** ## Requisitos del servidor | Componente | 26B MoE (4 bits, 4090) | 26B MoE (FP8, H100) | 31B Denso (BF16, H100) | | --------------- | ------------------------------ | ------------------- | ---------------------- | | VRAM de la GPU | 24GB | 80GB | 80GB | | RAM del sistema | 32GB | 64GB | 64GB | | Disco | 60GB NVMe | 80GB NVMe | 90GB NVMe | | Red | 100 Mbps para extracción de HF | 1 Gbps preferido | 1 Gbps preferido | | CUDA | 12.1+ | 12.4+ | 12.4+ | | Controlador | 550+ | 555+ | 555+ | Planifica un margen extra de \~20% de VRAM por encima del tamaño estático de los pesos para cubrir la caché KV en contextos largos. Establecer `--gpu-memory-utilization 0.90` en vLLM es un buen valor predeterminado. *** ## Despliegue rápido en CLORE.AI La ruta más rápida: alquila una sola GPU, descarga la imagen estándar `vllm/vllm-openai` y sirve el modelo con una API compatible con OpenAI. A continuación se muestra la estructura docker-compose usada por el resto de estas guías: ajusta el nombre del modelo y el tamaño del paralelismo tensorial según la variante que hayas elegido arriba. ### Opción A — Gemma 4 26B MoE en una sola GPU (vLLM, FP8) ```yaml versión: "3.8" servicios: vllm: imagen: vllm/vllm-openai:latest puertos: - "8000:8000" entorno: - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN} volúmenes: - hf_cache:/root/.cache/huggingface comando: > --model google/gemma-4-26b-it --quantization fp8 --max-model-len 32768 --gpu-memory-utilization 0.90 --served-model-name gemma-4-26b --trust-remote-code despliegue: recursos: reservas: dispositivos: - driver: nvidia count: 1 capabilities: [gpu] shm_size: "8gb" volúmenes: hf_cache: ``` ```bash # Arráncalo HF_TOKEN=hf_xxx docker compose up -d # Sigue los logs mientras se descargan los pesos docker compose logs -f vllm ``` {% hint style="info" %} **Control de licencia:** Los modelos Gemma en Hugging Face requieren aceptar los términos de Google una vez por cuenta. Visita la página del modelo en un navegador, haz clic en "Acknowledge license", luego exporta `HF_TOKEN` para que el contenedor pueda descargar los pesos. {% endhint %} ### Opción B — Gemma 4 31B Denso en H100 (vLLM, BF16) ```bash docker run --gpus all -p 8000:8000 \ -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \ -v ~/.cache/huggingface:/root/.cache/huggingface \ --ipc=host \ vllm/vllm-openai:latest \ --model google/gemma-4-31b-it \ --dtype bfloat16 \ --max-model-len 32768 \ --gpu-memory-utilization 0.90 \ --served-model-name gemma-4-31b ``` ### Opción C — Gemma 4 31B Denso en 2× RTX 4090 (FP8, paralelismo tensorial) ```bash docker run --gpus all -p 8000:8000 \ -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \ -v ~/.cache/huggingface:/root/.cache/huggingface \ --ipc=host \ vllm/vllm-openai:latest \ --model google/gemma-4-31b-it \ --quantization fp8 \ --tensor-parallel-size 2 \ --max-model-len 16384 \ --gpu-memory-utilization 0.90 \ --served-model-name gemma-4-31b ``` ### Opción D — Pruebas locales rápidas con Ollama Para experimentación en portátiles, Ollama envuelve las compilaciones comunitarias GGUF. Espera que las cuantizaciones aparezcan unos días después del lanzamiento oficial. ```bash # Una vez que se publique un GGUF comunitario ollama pull gemma4:26b-moe-q4_k_m ollama run gemma4:26b-moe-q4_k_m # API compatible con OpenAI en :11434 curl http://localhost:11434/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "gemma4:26b-moe-q4_k_m", "messages": [{"role":"user","content":"Resume el enfoque de enrutamiento MoE en dos frases."}] }' ``` Consulta la [guía de Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) para la configuración general, la gestión del modelo y consejos de persistencia. *** ## Ejemplos de uso El contenedor vLLM expone una API compatible con OpenAI en `:8000`. Cualquier cosa que hable el esquema chat-completions de OpenAI funciona directamente. ### Chat completion con curl ```bash curl http://localhost:8000/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "gemma-4-26b", "messages": [ {"role": "system", "content": "Eres un redactor técnico cuidadoso."}, {"role": "user", "content": "Explica el enrutamiento MoE en tres frases sin usar analogías."} ], "max_tokens": 512, "temperature": 0.7 }' ``` ### Python (cliente OpenAI) ```python from openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY") resp = client.chat.completions.create( model="gemma-4-26b", messages=[ {"role": "system", "content": "Respondes en texto plano, sin markdown."}, {"role": "user", "content": "Dame una lista de verificación de revisión de código de 5 puntos para un manejador HTTP de Go."}, ], temperature=0.7, max_tokens=1024, ) print(resp.choices[0].message.content) ``` ### Respuestas en streaming ```python from openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY") stream = client.chat.completions.create( model="gemma-4-26b", messages=[{"role": "user", "content": "Escribe un haiku sobre la inferencia distribuida."}], stream=True, max_tokens=128, ) for chunk in stream: delta = chunk.choices[0].delta.content if delta: print(delta, end="", flush=True) print() ``` ### Hugging Face Transformers (uso sin conexión) ```python import torch from transformers import AutoModelForCausalLM, AutoTokenizer model_name = "google/gemma-4-26b-it" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.bfloat16, device_map="auto", load_in_4bit=True, # Encaja el MoE en una sola tarjeta de 24GB ) messages = [ {"role": "user", "content": "Refactoriza esta función de Python para que sea más legible:\n\ndef f(x): return [i for i in x if i%2==0 and i>10]"}, ] input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device) output = model.generate(input_ids, max_new_tokens=512, do_sample=True, temperature=0.7) print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True)) ``` *** ## Consejos de rendimiento * **Usa FP8 en Hopper.** En H100, el checkpoint FP8 ocupa aproximadamente la mitad de memoria que BF16, sin pérdida de calidad medible en tareas de seguimiento de instrucciones. Pasa `--quantization fp8` a vLLM. * **Usa GPTQ de 4 bits en Ada (RTX 4090).** Para la variante MoE en una sola 4090, una compilación GPTQ de 4 bits de la comunidad es el punto óptimo práctico: espera \~10–15 tok/s. Las compilaciones GGUF Q4\_K\_M de Ollama ofrecen una calidad similar con operaciones más sencillas. * **Paralelismo tensorial para 31B Denso.** En 2× RTX 4090, pasa `--tensor-parallel-size 2`. Ajusta el contexto a lo que realmente necesitas (`--max-model-len 16384`) — cada duplicación del contexto aproximadamente duplica el tamaño de la caché KV. * **Paralelismo de expertos para el MoE.** En configuraciones multi-GPU para el MoE de 26B, `--enable-expert-parallel` de vLLM puede aportar un aumento de rendimiento significativo con tamaños de lote más altos. Es excesivo para una sola GPU. * **Prefill por bloques para contextos largos.** Al pasar de 32K, añade `--enable-chunked-prefill` a vLLM. Esto mantiene manejable la latencia de prefill y evita bloqueos en la ruta de decodificación. * **Precarga los pesos.** Para alquileres efímeros en Clore, monta un volumen persistente en `/root/.cache/huggingface` para que las ejecuciones posteriores se salten la descarga de 50–60GB. * **Elige el backend de serving adecuado.** vLLM es el valor predeterminado seguro. SGLang a menudo gana en Hopper para cargas de trabajo de alta concurrencia; consulta la [guía de vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) para la comparación más amplia. *** ## Benchmarks {% hint style="warning" %} **Cifras publicadas por el proveedor — verificación independiente pendiente.** Las cifras siguientes proceden de los materiales de lanzamiento de Google del 2 de abril de 2026. Las reproducciones independientes en evaluaciones privadas aún están llegando. Trata la clasificación de la Arena y las puntuaciones de factualidad como orientativas, no absolutas. {% endhint %} | Benchmark | Gemma 4 26B MoE | Gemma 4 31B Denso | Referencia | | ------------------------------------- | ---------------------------------------------------------- | ----------------------------------------------------- | -------------------------- | | LMSYS Arena (general) | n.º 3 en el lanzamiento | \~n.º 5 en el lanzamiento | reportado por el proveedor | | Seguimiento de instrucciones (IFEval) | el proveedor informa fuertes mejoras frente a Gemma 3 | el proveedor informa fuertes mejoras frente a Gemma 3 | reportado por el proveedor | | Factualidad (SimpleQA / similar) | supera a varios modelos cerrados según Google | comparable | reportado por el proveedor | | Multilingüe (Global-MMLU) | el proveedor informa paridad con modelos mucho más grandes | mejor puntuación de Gemma hasta la fecha | reportado por el proveedor | El argumento de posicionamiento de Gemma 4 es "más útil por parámetro activo", no "el rey bruto de HumanEval". Si necesitas generación pura de código, compáralo con [GLM-5.1](/guides/guides_v2-es/modelos-de-lenguaje/glm-5-1.md) (codificación de frontera) o [Qwen3.5](/guides/guides_v2-es/modelos-de-lenguaje/qwen35.md) (mejor denso de clase 35B). Si necesitas bucles agenticos de largo horizonte, GLM-5.1 sigue siendo la herramienta más precisa. *** ## Solución de problemas | Problema | Solución | | -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `OutOfMemoryError` al cargar el MoE de 26B en 24GB | Cambia a FP8 (`--quantization fp8`) o 4 bits (`load_in_4bit=True` en Transformers). Reduce `--max-model-len` a 16384 para reducir la caché KV. | | `OutOfMemoryError` cargando 31B Denso en H100 | BF16 a un contexto de 32K está justo al límite en 80GB. Reduce `--max-model-len` a 16384 o cambia a FP8. | | la descarga de Hugging Face falla con 403 | No has aceptado la licencia de Gemma en la página del modelo. Abre la URL en un navegador, acepta los términos y luego vuelve a descargar con un token que tenga el permiso `read` . | | Primer token muy lento | Carga fría de pesos (\~30–60 s en la primera solicitud) más prefill en entradas largas. Ejecuta una solicitud ficticia de calentamiento después de que arranque el servidor. Añade `--enable-chunked-prefill` para cargas de trabajo de contexto largo. | | Salida corrupta / bucles de repetición | Comprueba la plantilla de chat — `tokenizer.apply_chat_template` es obligatorio; no concatenes `system`+`user` cadenas manualmente. Establece `temperature=0.7` y `top_p=0.95` para uso general. | | Salida de herramientas / JSON poco fiable | Usa el `--guided-decoding-backend` de vLLM o pasa un esquema JSON mediante `response_format`. El modelo sigue bien las restricciones, pero las indicaciones no estructuradas aún pueden desviarse. | | `cuantización no compatible` error en vLLM | Actualiza a una versión de vLLM lanzada después de abril de 2026 (`pip install -U vllm --pre`). La arquitectura de Gemma 4 necesita los parsers de configuración más recientes. | *** ## Preguntas frecuentes **¿Gemma 4 frente a Llama 4?** Formas distintas para trabajos distintos. [Llama 4 Scout](/guides/guides_v2-es/modelos-de-lenguaje/llama4.md) es 109B/17B activos con un contexto estrella de 10M — excelente cuando necesitas volcar entradas enormes al modelo. Gemma 4 26B MoE es mucho más pequeño en parámetros totales (26B frente a 109B), activa menos parámetros por token (4B frente a 17B) y está más afinado para el seguimiento de instrucciones y la factualidad. Para presupuestos de VRAM ajustados y calidad por parámetro, gana Gemma 4. Para longitudes de contexto absurdas, gana Llama 4 Scout. **¿Cuánta VRAM necesita Gemma 4 26B MoE?** * GGUF / GPTQ de 4 bits: cabe en **24GB** (una sola RTX 4090), \~10–15 tok/s. * FP8: cómodo en **40GB**, rápido en **80GB** (H100) a \~40+ tok/s. * BF16 completo: \~55GB de pesos más caché KV — planifica una **80GB** tarjeta. **¿Puedo usar Gemma 4 comercialmente?** Sí, bajo los términos de uso estándar de Gemma. Revisa la [Política de uso prohibido de Gemma](https://ai.google.dev/gemma/prohibited_use_policy) antes de desplegarlo — hay restricciones en torno a casos de uso específicos (engaño, generación de CSAM, actividad ilegal), y debes pasar las notificaciones de licencia aguas abajo a tus usuarios. No es un modelo Apache 2.0 / MIT — es de pesos abiertos bajo una política de uso. Si necesitas una licencia completamente sin restricciones, [Qwen3.5](/guides/guides_v2-es/modelos-de-lenguaje/qwen35.md) (Apache 2.0) o [GLM-5.1](/guides/guides_v2-es/modelos-de-lenguaje/glm-5-1.md) (MIT) son alternativas. **¿Gemma 4 frente a DeepSeek-V4?** [DeepSeek-V4](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v4.md) es una clase de peso distinta — \~1T de parámetros, multimodal, contexto de 1M. Usa DeepSeek-V4 cuando necesites capacidad bruta y dispongas de un rack de GPU serio. Usa Gemma 4 26B MoE cuando quieras un fuerte seguimiento de instrucciones en una **sola GPU** y te importen los alquileres de \~$1–2/día en Clore. Gemma 4 es el candidato "mejor modelo que cabe en una 4090"; DeepSeek-V4 es el candidato "pagaré por 8× H200". **¿Gemma 4 admite visión / entradas multimodales?** El lanzamiento principal de Gemma 4 es solo texto y ajustado a instrucciones (`*-it`). Google históricamente ha seguido los lanzamientos de texto con variantes de visión PaliGemma — sigue [huggingface.co/google](https://huggingface.co/google) para actualizaciones. Para un modelo abierto con capacidad de imagen hoy, mira [Kimi K2.5](/guides/guides_v2-es/modelos-de-lenguaje/kimi-k2.md) o [Llama 4 Scout](/guides/guides_v2-es/modelos-de-lenguaje/llama4.md). *** ## Guías relacionadas * [vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — backend de serving de producción usado en esta guía * [Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — la ruta más rápida para probar localmente con compilaciones GGUF * [Llama 4](/guides/guides_v2-es/modelos-de-lenguaje/llama4.md) — la alternativa MoE de Meta con 10M de contexto * [GLM-5.1](/guides/guides_v2-es/modelos-de-lenguaje/glm-5-1.md) — MoE de codificación de clase frontier (744B/40B activos) cuando el tamaño de Gemma no es suficiente * [Qwen3.5](/guides/guides_v2-es/modelos-de-lenguaje/qwen35.md) — 35B denso con Apache-2.0, la otra opción fuerte en una sola GPU * [Gemma 3](/guides/guides_v2-es/modelos-de-lenguaje/gemma3.md) — la generación anterior, útil como línea base para migración ### Enlaces * [Gemma 4 26B MoE en Hugging Face](https://huggingface.co/google/gemma-4-26b-it) * [Gemma 4 31B Denso en Hugging Face](https://huggingface.co/google/gemma-4-31b-it) * [Gemma](https://ai.google.dev/gemma/terms) * [Política de uso prohibido de Gemma](https://ai.google.dev/gemma/prohibited_use_policy) * [Documentación de vLLM](https://docs.vllm.ai) * [Repositorio de SGLang](https://github.com/sgl-project/sglang) --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/gemma4.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.