Gemma 4 (26B MoE, 4B activo)

Despliega Gemma 4 (26B MoE, 4B activo) de Google en Clore.ai: el modelo de pesos abiertos lanzado en abril de 2026 que subió hasta

Estado (abril de 2026): Gemma 4 se lanzó el 2 de abril de 2026 por Google como la siguiente generación de la familia Gemma de pesos abiertos. Se publican dos variantes: una densa de 31B modelo (google/gemma-4-31b-it) y una MoE de 26B con ~4B parámetros activos (google/gemma-4-26b-it). Ambos se publican bajo los términos estándar de Términos de uso de Gemma en huggingface.co/google/gemma-4-26b-it y huggingface.co/google/gemma-4-31b-it.

Gemma 4 es la primera entrada MoE de Google en la línea Gemma y la primera versión de Gemma que llegó a lo más alto del LMSYS Arena (informes del proveedor #3 en general en el lanzamiento, superando por poco a varios modelos cerrados en veracidad y seguimiento de instrucciones). La cifra principal es la variante MoE: 26B de parámetros totales, ~4B activos por token, lo que te da un seguimiento de instrucciones casi de vanguardia al coste de inferencia de un modelo denso pequeño.

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 de producción en una sola H100 80GB (~40+ tok/s), poniendo el seguimiento de instrucciones de calidad Gemma al alcance por aproximadamente ~$1.04/h en el marketplace. La variante densa de 31B es la hermana más capaz pero también más cara, y necesita 2× RTX 4090 o 1× H100 para servir.

Características clave

• Arquitectura MoE (variante de 26B) — 26B de parámetros totales, ~4B activados por token; pagas un coste de inferencia de clase 4B por calidad de clase 26B

• Alternativa densa (variante de 31B) — para equipos que prefieren la previsibilidad y la madurez de las herramientas de la inferencia densa

• Ventana de contexto de 128K — preguntas y respuestas sobre documentos largos, RAG sobre bases de código medianas, bucles de agentes de múltiples turnos

• Seguimiento de instrucciones sólido — 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 heredada de Gemma 3, además de una suite de benchmarks ampliada en otros idiomas

• Pesos abiertos, términos de Gemma — gratis para la mayoría de los usos comerciales; revisa la Política de uso prohibido de Gemma antes de publicarlo

• Herramientas de primera clase — compatible desde el primer momento con vLLM, SGLang, Ollama y Hugging Face Transformers

Elige tu variante

Variante	Parámetros totales	Activo	Contexto	Cuantización recomendada	GPU de Clore recomendada
Gemma 4 26B MoE (gemma-4-26b-it)	26B	~4B por token	128K	FP8 o GPTQ de 4 bits	1× RTX 4090 (24 GB, cuantizado)
Gemma 4 31B denso (gemma-4-31b-it)	31B	31B (todos)	128K	FP8 o BF16	1× H100 (80 GB, BF16)

Elección práctica: Para el 90% de las implementaciones de una sola GPU, elige Gemma 4 26B MoE en FP8. Obtienes la calidad destacada del 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.

---

Requisitos del servidor

Componente	26B MoE (4 bits, 4090)	26B MoE (FP8, H100)	31B denso (BF16, H100)
VRAM de GPU	24GB	80 GB	80 GB
RAM del sistema	32GB	64GB	64GB
Disco	60GB NVMe	80GB NVMe	90GB NVMe
Red	100 Mbps para la descarga desde HF	Se prefiere 1 Gbps	Se prefiere 1 Gbps
CUDA	12.8+	12.8+	12.8+
Controlador	550+	555+	555+

Planifica un ~20% adicional de margen de VRAM sobre la huella fija de los pesos para cubrir la caché KV en contextos largos. La configuración --gpu-memory-utilization 0.90 en vLLM es un buen valor predeterminado.

---

Despliegue rápido en CLORE.AI

La vía 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 configuración de docker-compose usada por el resto de estas guías: ajusta el nombre del modelo y el tamaño de paralelismo tensorial según la variante que elegiste arriba.

Opción A — Gemma 4 26B MoE en una sola GPU (vLLM, FP8)

version: "3.8"
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
    volumes:
      - hf_cache:/root/.cache/huggingface
    command: >
      --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
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    shm_size: "8gb"

volumes:
  hf_cache:

# Levántalo
HF_TOKEN=hf_xxx docker compose up -d

# Sigue los registros mientras se descargan los pesos
docker compose logs -f vllm

Validación 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 "Aceptar licencia", luego exporta HF_TOKEN para que el contenedor pueda descargar los pesos.

Opción B — Gemma 4 31B denso en H100 (vLLM, BF16)

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)

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 de nivel portátil, Ollama envuelve las compilaciones comunitarias GGUF. Espera que las cuantizaciones lleguen unos días después del lanzamiento oficial.

# 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 oraciones."}]
  }'

Consulta la guía de Ollama para configuración general, gestión del modelo y consejos de persistencia.

---

Ejemplos de uso

El contenedor de vLLM expone una API compatible con OpenAI en :8000. Cualquier cosa que hable el esquema de completions de chat de OpenAI funciona directamente.

Completion de chat con curl

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 oraciones sin usar analogías."}
    ],
    "max_tokens": 512,
    "temperature": 0.7
  }'

Python (cliente de OpenAI)

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 en Go."},
    ],
    temperature=0.7,
    max_tokens=1024,
)
print(resp.choices[0].message.content)

Respuestas en streaming

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)

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,  # Cabe el MoE en una sola tarjeta de 24 GB
)

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 medible de calidad 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 comunitaria GPTQ de 4 bits 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. A través de 2× RTX 4090, pasa --tensor-parallel-size 2. Fija el contexto a lo que realmente necesitas (--max-model-len 16384) — cada duplicación del contexto aproximadamente duplica la huella de la caché KV.

• Paralelismo de expertos para el MoE. En configuraciones multigPU para el MoE de 26B, el paralelismo experto de vLLM --enable-expert-parallel puede dar un aumento notable del rendimiento con tamaños de lote altos. Es excesivo para una sola GPU.

• Prefill por fragmentos para contextos largos. Al superar los 32K, añade --enable-chunked-prefill a vLLM. Esto mantiene manejable la latencia del prefill y evita bloqueos en la ruta de decodificación.

• Descarga los pesos de antemano. Para alquileres efímeros de Clore, monta un volumen persistente en /root/.cache/huggingface para que las ejecuciones posteriores se salten la descarga de 50–60 GB.

• Elige el backend de servicio adecuado. vLLM es la opción predeterminada segura. SGLang suele ganar en Hopper para cargas de trabajo de alta concurrencia; consulta la guía de vLLM para una comparación más amplia.

---

Pruebas comparativas

Cifras publicadas por el proveedor — verificación independiente pendiente. Las cifras siguientes provienen del material de lanzamiento de Google del 2 de abril de 2026. Todavía están llegando reproducciones independientes en evaluaciones privadas. Toma la clasificación del Arena y las puntuaciones de veracidad como orientativas, no absolutas.

Benchmark	Gemma 4 26B MoE	Gemma 4 31B denso	Referencia
LMSYS Arena (global)	#3 en el lanzamiento	~#5 en el lanzamiento	según el proveedor
Seguimiento de instrucciones (IFEval)	el proveedor informa de fuertes mejoras frente a Gemma 3	el proveedor informa de fuertes mejoras frente a Gemma 3	según el proveedor
Veracidad (SimpleQA / similar)	supera a varios modelos cerrados según Google	comparable	según el proveedor
Multilingüe (Global-MMLU)	el proveedor informa de paridad con modelos mucho más grandes	la mejor puntuación de Gemma hasta la fecha	según el proveedor

El argumento de posicionamiento de Gemma 4 es "más útil por parámetro activo", no "rey absoluto de HumanEval". Si necesitas generación de código pura, compáralo con GLM-5.1 (codificación de vanguardia) o Qwen3.5 (el mejor denso de clase 35B). Si necesitas bucles agentivos de largo plazo, GLM-5.1 sigue siendo la herramienta más precisa.

---

Solución de problemas

Problema	Solución
OutOfMemoryError cargando el MoE de 26B en 24 GB	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 el 31B denso en H100	BF16 con contexto de 32K está justo al límite en 80 GB. Baja --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 lectura alcance.
Primer token muy lento	Carga fría de los 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 confusa / bucles de repetición	Comprueba la plantilla de chat — tokenizer.apply_chat_template es obligatorio; no concatenes system+user las cadenas manualmente. Configura temperature=0.7 y top_p=0.95 para uso general.
Salida de herramientas / JSON poco fiable	Usa la --guided-decoding-backend o pasa un esquema JSON mediante response_format. El modelo sigue bien las restricciones, pero las indicaciones no estructuradas seguirán desviándose.
cuantización no compatible error en vLLM	Actualiza a una versión de vLLM publicada después de abril de 2026 (pip install -U vllm --pre). La arquitectura de Gemma 4 necesita los analizadores de configuración más recientes.

---

Preguntas frecuentes

¿Gemma 4 vs Llama 4? Distintas formas para distintos trabajos. Llama 4 Scout es 109B/17B-activo con un contexto destacado de 10M — estupendo cuando necesitas volcar entradas enormes en el 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 veracidad. 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 40 GB, rápido en 80 GB (H100) a ~40+ tok/s.

• BF16 completo: ~55 GB de pesos más la caché KV — planifica una 80 GB 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 antes de desplegarlo — hay restricciones sobre casos de uso específicos (engaño, generación de CSAM, actividad ilegal) y debes pasar los avisos 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 (Apache 2.0) o GLM-5.1 (MIT) son alternativas.

¿Gemma 4 vs DeepSeek-V4? DeepSeek-V4 es una clase de pesos distinta — ~1T de parámetros, multimodal, 1M de contexto. Usa DeepSeek-V4 cuando necesites capacidad bruta y dispongas de un serio rack de GPU. Usa Gemma 4 26B MoE cuando quieras un fuerte seguimiento de instrucciones en una sola GPU y te importen las bare metal alquileres en Clore. Gemma 4 es el candidato a "mejor modelo que cabe en una 4090"; DeepSeek-V4 es el candidato a "pagaré por 8× H200".

¿Gemma 4 admite entradas de visión / multimodales? El lanzamiento principal de Gemma 4 está ajustado solo para texto (*-it). Google históricamente ha seguido los lanzamientos de texto con variantes de visión PaliGemma — sigue huggingface.co/google para actualizaciones. Para un modelo abierto con capacidad de imagen hoy, mira Kimi K2.5 o Llama 4 Scout.

---

Guías relacionadas

• vLLM — backend de servicio de producción usado en esta guía

• Ollama — la forma más rápida de probar localmente con compilaciones GGUF

• Llama 4 — la alternativa MoE de Meta con 10M de contexto

• GLM-5.1 — MoE de codificación de clase de vanguardia (744B/40B-activo) cuando la clase de tamaño de Gemma no es suficiente

• Qwen3.5 — denso de 35B con Apache 2.0, la otra opción fuerte de una sola GPU

• Gemma 3 — la generación anterior, una línea base útil para la migración

Enlaces

• Gemma 4 26B MoE en Hugging Face

• Gemma 4 31B denso en Hugging Face

• Términos de uso de Gemma

• Política de uso prohibido de Gemma

• documentación de vLLM

• repositorio SGLang