# 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


---

# 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/gemma3.md?ask=<question>
```

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.