Como ejecutar Gemma 4 31B en local: Unsloth, Ollama, llama.cpp y HuggingFace

Google DeepMind lanzo Gemma 4 a principios de 2026, y la variante de 31B ajustada por instruccion llega a un punto ideal: lo bastante grande como para competir con modelos privativos en benchmarks de razonamiento, y lo bastante pequeno para ejecutarse en una GPU de consumo decente. Consigue un 85.2% en MMLU Pro y un 89.2% en AIME 2026 sin herramientas, lo que la pone en la misma conversacion que modelos con el doble de parametros.

El problema siempre ha sido "como ejecuto esto realmente?" Un modelo de 30.7B parametros en precision completa necesita unos 62GB de VRAM. Nadie tiene eso en una sola tarjeta. Pero con la cuantizacion adecuada y las herramientas correctas, puedes ejecutarlo en una RTX 4090 de 24GB, o incluso descargar parcialmente a CPU con una tarjeta de 16GB. Recomendamos usar LightNode como proveedor de VPS si quieres instancias GPU sin compromiso a largo plazo.

Esta guia cubre cuatro metodos, con Unsloth como la recomendacion principal para la mayoria de usuarios.

Indice

1. Vision general de la familia de modelos Gemma 4
2. Requisitos de hardware
3. Metodo 1: Unsloth Studio (Recomendado)
4. Metodo 2: Ollama
5. Metodo 3: llama.cpp
6. Metodo 4: HuggingFace Transformers
7. Entender los formatos de cuantizacion GGUF
8. Consejos de rendimiento
9. Solucion de problemas
10. Que metodo deberias elegir?

Vision general de la familia de modelos Gemma 4

Gemma 4 viene en cuatro tamanos. Elegir el correcto es importante porque el salto de hardware entre ellos es considerable.

Variante	Parametros totales	Parametros activos	Contexto	Modalidades	Mejor para
E2B	5.1B	2.3B efectivos	128K	Texto, imagen, audio	Moviles, Raspberry Pi
E4B	8B	4.5B efectivos	128K	Texto, imagen, audio	Portatiles, solo CPU
26B A4B (MoE)	25.2B	3.8B activos	256K	Texto, imagen	Inferencia rapida, menos VRAM
31B (Dense)	30.7B	30.7B	256K	Texto, imagen	Maxima calidad

La 26B A4B es la mas lista: 25.2B parametros totales, pero solo 3.8B estan activos durante la inferencia gracias a una arquitectura Mixture-of-Experts (8 expertos activos de 128, mas 1 compartido). Ejecuta casi tan rapido como un modelo de 4B mientras ofrece una calidad cercana a la 31B completa. Si tu GPU tiene 12-16GB de VRAM, la 26B A4B en cuantizacion Q4 es probablemente tu mejor opcion.

La 31B Dense es la que cubre esta guia. Es el modelo completo con todos los parametros activos en cada pasada. Mejor calidad, mayores requisitos de hardware.

Las cuatro variantes soportan modo de pensamiento configurable (razonamiento en cadena), prompts de sistema nativos, llamadas a funciones y mas de 140 idiomas.

Requisitos de hardware

Antes de elegir un metodo, averigua con que hardware cuentas.

Para Gemma 4 31B-it

Cuantizacion	VRAM necesaria	Perdida de calidad	Hardware tipico
FP16 (precision completa)	~62 GB	Ninguna	A100, multiples GPUs
Q8_0 (8-bit)	~32 GB	Despreciable	RTX 4090 (24GB) + descarga a CPU
Q5_K_M (5-bit)	~22 GB	Minima	RTX 4090, RTX 3090
Q4_K_M (4-bit)	~18 GB	Pequena	RTX 4080, RTX 3090
Q3_K_M (3-bit)	~14 GB	Notable	RTX 4070, descarga parcial

Para Gemma 4 26B A4B (MoE)

Cuantizacion	VRAM necesaria	Perdida de calidad	Hardware tipico
Q5_K_M	~14 GB	Minima	RTX 4070 Ti
Q4_K_M	~10 GB	Pequena	RTX 4070, RTX 3080
Q3_K_M	~8 GB	Notable	RTX 4060 Ti 8GB

Si solo tienes CPU, las variantes E4B o E2B funcionaran sin problemas. La 31B en CPU es tecnicamente posible pero dolorosamente lenta (espera 1-3 tokens/segundo en una CPU moderna).

Requisito de RAM: Anade 8-16GB de RAM del sistema ademas de la VRAM para la carga del entorno en ejecucion, mas si descargas capas a CPU.

Metodo 1: Unsloth Studio (Recomendado)

Unsloth es la forma mas facil de ejecutar Gemma 4 en local. Es una interfaz web que gestiona la descarga de modelos, la seleccion de cuantizacion y la inferencia en un solo paquete. Funciona en Windows, Linux, macOS y WSL.

Por que Unsloth

• Busqueda y descarga de modelos con un clic desde HuggingFace
• Selecciona automaticamente la cuantizacion GGUF adecuada para tu hardware
• Interfaz de chat integrada con soporte para imagenes, PDFs y documentos
• Llamadas a herramientas y busqueda web integradas
• Sandbox de ejecucion de codigo
• Sin complicaciones con la linea de comandos

Instalacion

macOS, Linux, WSL:

curl -fsSL https://unsloth.ai/install.sh | sh

Windows (PowerShell):

irm https://unsloth.ai/install.ps1 | iex

Docker:

docker run -d -e JUPYTER_PASSWORD="mypassword" \
  -p 8888:8888 -p 8000:8000 -p 2222:22 \
  -v $(pwd)/work:/workspace/work \
  --gpus all \
  unsloth/unsloth

Inicio

unsloth studio -H 0.0.0.0 -p 8888

Abre http://localhost:8888 en tu navegador. Veras la interfaz de Unsloth Studio.

Ejecutar Gemma 4 31B

1. Buscar el modelo: En la barra de busqueda de modelos, escribe gemma-4-31B
2. Elegir cuantizacion: Unsloth aloja archivos GGUF pre-cuantizados. Para una GPU de 24GB, selecciona Q4_K_M o Q5_K_M. Para 16GB, ve con Q3_K_M
3. Descargar: Haz clic en descargar. La variante Q4_K_M ocupa unos 18GB
4. Empezar a chatear: Una vez descargado, el modelo se carga automaticamente en la interfaz de chat

Unsloth proporciona estas variantes GGUF para Gemma 4 31B-it:

Archivo	Tamanio	Cuantizacion
gemma-4-31B-it-Q3_K_M.gguf	~14 GB	3-bit (equilibrado)
gemma-4-31B-it-Q4_K_M.gguf	~18 GB	4-bit (recomendado)
gemma-4-31B-it-Q5_K_M.gguf	~22 GB	5-bit (alta calidad)
gemma-4-31B-it-Q6_K.gguf	~26 GB	6-bit (casi sin perdida)
gemma-4-31B-it-Q8_0.gguf	~32 GB	8-bit (practicamente sin perdida)

El repositorio en HuggingFace esta en unsloth/gemma-4-31B-it-GGUF.

Usar la interfaz de chat

El chat de Unsloth Studio soporta:

• Conversaciones de texto con activacion del modo de pensamiento
• Subida de imagenes: Arrastra y suelta imagenes para preguntas y respuestas visuales
• Subida de PDF/DOCX: Extrae y discute contenidos de documentos
• Ejecucion de codigo: El modelo puede escribir y probar codigo en un sandbox
• Prompts de sistema personalizados: Configura comportamiento y personalidad

Para activar el modo de pensamiento de Gemma 4, activa la opcion "Thinking" en la configuracion del chat. Esto activa el razonamiento en cadena, donde el modelo analiza los problemas paso a paso antes de dar su respuesta final.

Fine-tuning con Unsloth

Si quieres ir mas alla de la inferencia, Unsloth tambien gestiona el entrenamiento:

• Fine-tuning LoRA: Entrena adaptadores con hasta un 70% menos de VRAM
• Aprendizaje por refuerzo GRPO: La biblioteca de RL mas eficiente disponible
• Data Recipes: Crea datasets de entrenamiento automaticamente desde PDFs, CSVs y archivos DOCX
• Soporte multi-GPU: Disponible ahora con mejoras en camino

Para hacer fine-tuning de Gemma 4 31B, necesitaras al menos una GPU de 24GB con QLoRA (entrenamiento cuantizado a 4-bit).

Actualizar Unsloth

Ejecuta el mismo comando de instalacion otra vez:

# macOS/Linux/WSL
curl -fsSL https://unsloth.ai/install.sh | sh

# Windows
irm https://unsloth.ai/install.ps1 | iex

Metodo 2: Ollama

Ollama es la forma mas rapida de empezar si prefieres la linea de comandos. Gestiona automaticamente la descarga de modelos, la deteccion de GPU y el serving.

Instalacion

# macOS
brew install ollama

# Linux
curl -fsSL https://ollama.com/install.sh | sh

# Windows
# Descarga desde https://ollama.com/download

Ejecutar Gemma 4

# Descargar y ejecutar el modelo de 31B
ollama run gemma4:31b-it

# O la variante MoE mas pequena para menos VRAM
ollama run gemma4:26b-a4b-it

# O los modelos dense mas pequenos
ollama run gemma4:e4b-it
ollama run gemma4:e2b-it

Ollama cuantiza automaticamente a Q4_K_M por defecto. Si quieres una cuantizacion diferente:

# Ejecutar con cuantizacion especifica
ollama run gemma4:31b-it-q5_K_M

Usar la API

Ollama expone una API local en el puerto 11434:

import requests

response = requests.post('http://localhost:11434/api/chat', json={
    "model": "gemma4:31b-it",
    "messages": [
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a Python function to merge two sorted lists."}
    ],
    "stream": False
})

print(response.json()['message']['content'])

Pros y contras de Ollama

Pros: Configuracion cero, deteccion automatica de GPU, CLI limpia, servidor API incluido, gestion de modelos sencilla.

Contras: Menos opciones de cuantizacion que llama.cpp, no todas las imagenes de modelos soportan funciones integradas (verifica la compatibilidad actual), menos control sobre los parametros de inferencia.

Metodo 3: llama.cpp

Para un control maximo sobre la cuantizacion, el uso de memoria y los parametros de inferencia, llama.cpp es la herramienta ideal. Es lo que alimenta a Ollama y Unsloth por debajo para la inferencia GGUF.

Compilar desde el codigo fuente

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# Con soporte CUDA (NVIDIA)
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

# Con soporte Metal (macOS Apple Silicon)
cmake -B build -DGGML_METAL=ON
cmake --build build --config Release -j$(nproc)

# Solo CPU
cmake -B build
cmake --build build --config Release -j$(nproc)

Descargar el modelo GGUF

Descarga el modelo cuantizado del repositorio de Unsloth en HuggingFace:

# Instalar huggingface-cli
pip install huggingface-hub

# Descargar Q4_K_M (recomendado para GPUs de 24GB)
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q4_K_M.gguf \
  --local-dir ./models

# O Q5_K_M para mejor calidad
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q5_K_M.gguf \
  --local-dir ./models

Ejecutar el modelo

# Chat basico
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -c 8192 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64 \
  -p "You are a helpful assistant.\nUser: Explain quantum computing in simple terms.\nAssistant:"

Parametros clave:

• -ngl 99: Descarga todas las capas a la GPU. Reduce este numero si no tienes suficiente VRAM (por ejemplo, -ngl 40 descarga aproximadamente dos tercios de las capas)
• -c 8192: Longitud de contexto en tokens. Aumentalo hasta 256K para documentos largos, pero mas contexto consume mas VRAM
• --temp 1.0: Google recomienda temperature=1.0 para Gemma 4
• --top-p 0.95 y --top-k 64: Parametros de muestreo recomendados

Iniciar un servidor

./build/bin/llama-server \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -c 8192 \
  --host 0.0.0.0 \
  --port 8080 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Luego accede a la interfaz web en http://localhost:8080 o llama a la API compatible con OpenAI:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8080/v1", api_key="unused")

response = client.chat.completions.create(
    model="gemma-4-31b",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Write a Rust function to reverse a linked list."}
    ]
)

print(response.choices[0].message.content)

Estrategia de descarga a GPU

Si tu GPU no tiene suficiente VRAM para el modelo completo, puedes dividir las capas entre GPU y CPU:

# Para una GPU de 16GB con el modelo Q4 (~18GB en total)
# Descargar unas 40 capas a GPU, el resto a CPU
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 40 \
  -c 4096

Esto funciona mas lento que la descarga completa a GPU pero cabe en tarjetas mas pequenas. Espera unos 5-15 tokens/segundo dependiendo de tu CPU y cuantas capas descargues.

Metodo 4: HuggingFace Transformers

Si estas construyendo una aplicacion y necesitas control programatico, HuggingFace Transformers te da acceso directo al modelo con precision completa o cuantizacion personalizada.

Instalacion

pip install -U transformers torch accelerate

Para soporte de imagenes:

pip install -U transformers torch torchvision accelerate

Ejecutar en precision completa (62GB+ VRAM)

from transformers import AutoProcessor, AutoModelForCausalLM

MODEL_ID = "google/gemma-4-31B-it"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain the difference between TCP and UDP."},
]

text = processor.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=False
)

inputs = processor(text=text, return_tensors="pt").to(model.device)
input_len = inputs["input_ids"].shape[-1]

outputs = model.generate(**inputs, max_new_tokens=1024)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
result = processor.parse_response(response)
print(result)

Ejecutar con cuantizacion 4-bit (18GB VRAM)

from transformers import AutoProcessor, AutoModelForCausalLM, BitsAndBytesConfig

MODEL_ID = "google/gemma-4-31B-it"

# Configuracion de cuantizacion 4-bit
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16
)

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    quantization_config=quantization_config,
    device_map="auto"
)

Procesar imagenes

El modelo de 31B soporta entrada de texto e imagen:

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "google/gemma-4-31B-it"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://example.com/photo.jpg"},
            {"type": "text", "text": "Describe what you see in this image."}
        ]
    }
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
).to(model.device)

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs, max_new_tokens=512)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
result = processor.parse_response(response)
print(result)

Activar el modo de pensamiento

Gemma 4 soporta razonamiento en cadena. Activalo configurando enable_thinking=True:

text = processor.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=True  # Activa el modo de razonamiento
)

Cuando el modo de pensamiento esta activo, el modelo genera su razonamiento interno seguido de la respuesta final. Usa processor.parse_response(response) para separar el pensamiento de la respuesta.

Entender los formatos de cuantizacion GGUF

Si estas descargando archivos GGUF, veras muchos sufijos. Aqui te explico que significan en la practica.

Formato	Bits	Tamanio (31B)	Cuando usarlo
Q8_0	8-bit	~32 GB	Mejor calidad, necesita 32GB+ VRAM
Q6_K	6-bit	~26 GB	Casi sin perdida, 24GB+ VRAM
Q5_K_M	5-bit	~22 GB	Punto ideal calidad/tamano
Q4_K_M	4-bit	~18 GB	Mejor equilibrio, cabe en GPU de 24GB
Q3_K_M	3-bit	~14 GB	GPU mas pequena, algo de perdida de calidad
Q2_K	2-bit	~10 GB	Medidas desesperadas, degradacion notable

Mi recomendacion: Q4_K_M para GPUs de 24GB, Q5_K_M si te sobran 4GB extra. La diferencia de calidad entre Q4_K_M y Q5_K_M se puede medir en benchmarks pero es dificil de notar en uso cotidiano. Ir por debajo de Q3_K_M no merece la pena a menos que no tengas otra opcion.

El sufijo _K_M significa "K-quantization, medium". Tambien hay variantes _K_S (small, mas compresion) y _K_L (large, menos compresion). _K_M es la recomendacion por defecto.

Consejos de rendimiento

Gestion de la longitud de contexto

Gemma 4 31B soporta hasta 256K tokens de contexto, pero cada token en el contexto consume VRAM. Algunas recomendaciones practicas:

• 4K tokens: Comodo en cualquier GPU que quepa el modelo
• 8K tokens: Estandar para la mayoria de conversaciones, todavia comodo
• 32K tokens: Necesita unos 4-6GB extra de VRAM segun la cuantizacion
• 128K+ tokens: Requiere VRAM sustancial o descarga agresiva

Empieza con -c 8192 y aumenta solo cuando lo necesites.

Parametros de muestreo

Google recomienda estos ajustes para Gemma 4:

temperature = 1.0
top_p = 0.95
top_k = 64

Estos son diferentes a lo que usan la mayoria de modelos. No uses temperature=0.7 con Gemma 4; esta entrenada para temperature=1.0 y produce mejores resultados con ese ajuste.

Flash Attention

Si estas usando HuggingFace Transformers, activa Flash Attention para inferencia mas rapida y menor uso de memoria:

model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    attn_implementation="flash_attention_2",
    device_map="auto"
)

Esto requiere pip install flash-attn y una GPU compatible (la mayoria de tarjetas NVIDIA RTX funcionan).

Configuracion multi-GPU

Si tienes multiples GPUs, device_map="auto" en Transformers gestiona la division automaticamente. Para llama.cpp:

./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -ts 1,1 \  # Dividir equitativamente entre 2 GPUs
  -c 8192

Solucion de problemas

Sin memoria (CUDA OOM)

El problema mas comun. Soluciones en orden de desesperacion:

1. Usa una cuantizacion menor: Cambia de Q5 a Q4, o de Q4 a Q3
2. Reduce la longitud de contexto: Baja -c de 8192 a 4096 o 2048
3. Descarga a CPU: Reduce -ngl para descargar algunas capas
4. Usa la variante 26B A4B MoE: Misma calidad, una fraccion de la VRAM
5. Usa la variante E4B: Funciona en cualquier cosa

Inferencia lenta en CPU

Si estas ejecutando en CPU, espera 1-3 tokens/segundo para el modelo de 31B. Opciones:

• Cambia al modelo E4B o E2B (10-20 tok/s en CPU)
• Usa una instancia GPU en la nube (LightNode ofrece opciones de VPS GPU)
• Compila llama.cpp con los conjuntos de instrucciones de tu CPU habilitados (AVX2, AVX-512)

Fallos en la descarga del modelo

El archivo Q4_K_M ocupa unos 18GB. Si la descarga sigue fallando:

# Usa huggingface-cli con soporte de reanudacion
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q4_K_M.gguf \
  --local-dir ./models \
  --local-dir-use-symlinks False

O usa un gestor de descargas que soporte reanudacion. La CDN de HuggingFace puede ser inestable con archivos grandes.

Errores de "Model not supported"

Asegurate de usar la ultima version de tus herramientas. Gemma 4 es nuevo y las versiones antiguas de llama.cpp, Ollama y Transformers no lo soportan:

# Actualizar llama.cpp
cd llama.cpp && git pull && cmake --build build --config Release -j$(nproc)

# Actualizar Ollama
ollama pull gemma4:31b-it  # Esto se actualiza automaticamente si es necesario

# Actualizar Transformers
pip install -U transformers

Que metodo deberias elegir?

Escenario	Mejor metodo
Quieres una GUI, sin tocar la terminal	Unsloth Studio
Quieres la configuracion mas rapida, la CLI te va bien	Ollama
Necesitas control maximo sobre la inferencia	llama.cpp
Estas construyendo una aplicacion	HuggingFace Transformers
Tienes VRAM limitada (8-16GB)	Unsloth o Ollama con Q3/Q4
Tienes 24GB+ VRAM	Cualquier metodo, usa Q4_K_M o Q5_K_M
Necesitas comprension de imagenes	Unsloth Studio o HuggingFace Transformers
Quieres hacer fine-tuning	Unsloth (entrenamiento LoRA/GRPO integrado)

Para la mayoria de gente que esta empezando, Unsloth Studio es el camino de menor resistencia. Instalalo, busca Gemma 4, elige una cuantizacion que quepa en tu GPU y empieza a chatear. Todo el proceso toma unos 15 minutos desde la instalacion hasta la primera conversacion.

Si te sientes comodo con la terminal y solo quieres ejecutar el modelo, Ollama te lleva alli con dos comandos. Y si necesitas acceso programatico o estas construyendo algo sobre el modelo, HuggingFace Transformers con cuantizacion 4-bit te da la API completa de Python.

En resumen

Ejecutar Gemma 4 31B en local se ha vuelto sorprendentemente practico. Hace un ano, un modelo de 30B a este nivel de calidad habria sido un proyecto de investigacion. Ahora es un proceso de configuracion de 15 minutos con Unsloth u Ollama, y se ejecuta en hardware de consumo que puedes comprar hoy.

El modelo por si solo aguanta el tipo frente a alternativas privativas en razonamiento, programacion y tareas multimodales. Contexto de 256K, modo de pensamiento integrado, comprension de imagenes y llamadas a funciones lo hacen genuinamente util para trabajo real, no solo para experimentacion.

Para alojar el modelo en una GPU remota, LightNode ofrece instancias VPS GPU con facturacion por horas, para que puedas iniciar una cuando la necesites y apagarla cuando no.

La ficha del modelo Gemma 4 en HuggingFace tiene todos los detalles tecnicos, y el repositorio GGUF de Unsloth tiene todas las variantes cuantizadas listas para descargar.