# Gemma 3

Gemma 3, lanzado en marzo de 2025 por Google DeepMind, está construido sobre la misma tecnología que Gemini 2.0. Su logro destacado: **el modelo de 27B supera a Llama 3.1 405B** en los benchmarks de LMArena — un modelo 15 veces su tamaño. Es nativamente multimodal (texto + imágenes + video), admite contexto de 128K y se ejecuta en una sola RTX 4090 con cuantización.

## Características clave

* **Rinde muy por encima de su peso**: 27B supera a modelos de clase 405B en los principales benchmarks
* **Nativamente multimodal**: Comprensión de texto, imagen y video integrada
* **Ventana de contexto de 128K**: Procesa documentos largos, bases de código, conversaciones
* **Cuatro tamaños**: 1B, 4B, 12B, 27B — algo para cada presupuesto de GPU
* **Versiones QAT**: Variantes de Entrenamiento Consciente de Cuantización permiten ejecutar 27B en GPUs de consumo
* **Amplio soporte de frameworks**: Ollama, vLLM, Transformers, Keras, JAX, PyTorch

## Variantes de modelo

| Modelo          | Parámetros | VRAM (Q4) | VRAM (FP16) | Mejor para                            |
| --------------- | ---------- | --------- | ----------- | ------------------------------------- |
| Gemma 3 1B      | 1B         | 1.5GB     | 3GB         | Edge, móvil, pruebas                  |
| Gemma 3 4B      | 4B         | 4GB       | 9GB         | GPUs para presupuesto, tareas rápidas |
| Gemma 3 12B     | 12B        | 10GB      | 25GB        | Equilibrio calidad/velocidad          |
| Gemma 3 27B     | 27B        | 18GB      | 54GB        | Mejor calidad, producción             |
| Gemma 3 27B QAT | 27B        | 14GB      | —           | Optimizado para GPUs de consumo       |

## Requisitos

| Componente | Gemma 3 4B | Gemma 3 27B (Q4) | Gemma 3 27B (FP16) |
| ---------- | ---------- | ---------------- | ------------------ |
| GPU        | RTX 3060   | RTX 4090         | 2× RTX 4090 / A100 |
| VRAM       | 6GB        | 24GB             | 48GB+              |
| RAM        | 16GB       | 32GB             | 64GB               |
| Disco      | 10GB       | 25GB             | 55GB               |
| CUDA       | 11.8+      | 11.8+            | 12.0+              |

**GPU recomendada de Clore.ai**: RTX 4090 24GB (\~$0.5–2/día) para 27B cuantizado — el punto óptimo

## Inicio rápido con Ollama

```bash
# Instalar Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Ejecutar distintos tamaños
ollama run gemma3:1b     # Minúsculo — 1.5GB VRAM
ollama run gemma3:4b     # Pequeño — 4GB VRAM
ollama run gemma3:12b    # Mediano — 10GB VRAM
ollama run gemma3:27b    # Grande — 18-20GB VRAM (cuantizado)

# Versión QAT (cuantización optimizada)
ollama run gemma3:27b-qat
```

### Servidor API de Ollama

```bash
ollama serve &

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma3:27b",
    "messages": [{"role": "user", "content": "Compara REST vs GraphQL para una nueva API"}]
  }'
```

### Visión con Ollama

```bash
# Analizar una imagen
ollama run gemma3:27b "Describe esta imagen en detalle" --images ./photo.jpg
```

## Configuración de vLLM (Producción)

```bash
pip install vllm

# Servir modelo 27B
vllm serve google/gemma-3-27b-it \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.90

# Servir con contexto más largo en 2 GPUs
vllm serve google/gemma-3-27b-it \
  --tensor-parallel-size 2 \
  --max-model-len 65536

# Servir 4B para configuraciones económicas
vllm serve google/gemma-3-4b-it \
  --max-model-len 32768
```

## HuggingFace Transformers

### Generación de texto

```python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "google/gemma-3-27b-it"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True  # Entra en GPU de 24GB
)

messages = [
    {"role": "user", "content": "Escribe una clase de Python para un árbol binario de búsqueda con métodos insert, search y delete"}
]

input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
output = model.generate(input_ids, max_new_tokens=2048, temperature=0.7, do_sample=True)
print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True))
```

### Visión (Comprensión de Imágenes)

```python
import torch
from transformers import AutoProcessor, Gemma3ForConditionalGeneration
from PIL import Image

model_name = "google/gemma-3-27b-it"
processor = AutoProcessor.from_pretrained(model_name)
model = Gemma3ForConditionalGeneration.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

# Cargar imagen
image = Image.open("screenshot.png")

messages = [
    {"role": "user", "content": [
        {"type": "image", "image": image},
        {"type": "text", "text": "¿Qué muestra esta captura de pantalla? Enumera todos los elementos de la interfaz."}
    ]}
]

inputs = processor.apply_chat_template(messages, return_tensors="pt").to(model.device)
output = model.generate(**inputs, max_new_tokens=1024)
print(processor.decode(output[0], skip_special_tokens=True))
```

## Inicio rápido con Docker

```bash
docker run --gpus all -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:latest \
  --model google/gemma-3-27b-it \
  --max-model-len 8192
```

## Aspectos destacados del benchmark

| Benchmark          | Gemma 3 27B    | Llama 3.1 70B | Llama 3.1 405B |
| ------------------ | -------------- | ------------- | -------------- |
| LMArena ELO        | 1354           | 1298          | 1337           |
| MMLU               | 75.6           | 79.3          | 85.2           |
| HumanEval          | 72.0           | 72.6          | 80.5           |
| VRAM (Q4)          | 18GB           | 40GB          | 200GB+         |
| **Costo en Clore** | **$0.5–2/día** | **$3–6/día**  | **$12–24/día** |

El 27B ofrece calidad conversacional de clase 405B a 1/10 del coste de VRAM.

## Consejos para usuarios de Clore.ai

* **27B QAT es el punto óptimo**: El Entrenamiento Consciente de Cuantización implica menos pérdida de calidad que la cuantización post-entrenamiento — ejecútalo en una sola RTX 4090
* **La visión es gratis**: No se necesita configuración extra — Gemma 3 entiende imágenes de forma nativa. Ideal para análisis de documentos, capturas de pantalla y lectura de gráficos
* **Comienza con contexto corto**: Usa `--max-model-len 8192` inicialmente; aumenta solo cuando sea necesario para ahorrar VRAM
* **4B para ejecuciones económicas**: Si usas RTX 3060/3070 ($0.15–0.3/día), el modelo 4B todavía supera a los modelos 27B de la generación anterior
* **No se requiere autenticación de Google**: A diferencia de algunos modelos, Gemma 3 se descarga sin restricciones (solo acepta la licencia en HuggingFace)

## Solución de problemas

| Problema                        | Solución                                                                               |
| ------------------------------- | -------------------------------------------------------------------------------------- |
| `OutOfMemoryError` en 27B       | Usa la versión QAT o reduce `--max-model-len` a 4096                                   |
| La visión no funciona en Ollama | Actualiza Ollama a la última versión: `curl -fsSL https://ollama.com/install.sh \| sh` |
| Velocidad de generación lenta   | Comprueba que estés usando bfloat16, no float32. Usa `--dtype bfloat16`                |
| El modelo genera basura         | Asegúrate de estar usando la `-it` variante (tuned-instruct), no el modelo base        |
| Error 403 al descargar          | Acepta la licencia de Gemma en <https://huggingface.co/google/gemma-3-27b-it>          |

## Lecturas adicionales

* [Informe técnico de Gemma 3](https://ai.google.dev/gemma)
* [Ficha del modelo en HuggingFace](https://huggingface.co/google/gemma-3-27b-it)
* [Biblioteca Ollama](https://ollama.com/library/gemma3)
* [Google AI Studio](https://aistudio.google.com/) — prueba Gemma 3 en línea antes de alquilar una GPU