> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/gemma3.md).

# Gemma 3

Ejecuta los modelos multimodales Google Gemma 3 en Clore.ai: supera a Llama-405B siendo 15 veces más pequeño

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

## Características clave

* **Rinde muy por encima de su categoría**: 27B supera a modelos de clase 405B en benchmarks principales
* **Nativamente multimodal**: comprensión integrada de texto, imagen y video
* **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**: las variantes de Entrenamiento con Conciencia de Cuantización permiten que 27B funcione en GPU de consumo
* **Amplio soporte de frameworks**: Ollama, vLLM, Transformers, Keras, JAX, PyTorch

## Variantes del modelo

| Modelo          | Parámetros | VRAM (Q4) | VRAM (FP16) | Ideal para                         |
| --------------- | ---------- | --------- | ----------- | ---------------------------------- |
| Gemma 3 1B      | 1B         | 1.5GB     | 3GB         | Edge, móvil, pruebas               |
| Gemma 3 4B      | 4B         | 4GB       | 9GB         | GPU de presupuesto, tareas rápidas |
| Gemma 3 12B     | 12B        | 10GB      | 25GB        | Calidad/velocidad equilibradas     |
| Gemma 3 27B     | 27B        | 18GB      | 54GB        | Mejor calidad, producción          |
| Gemma 3 27B QAT | 27B        | 14GB      | —           | Optimizado para GPU 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       | 12.8+      | 12.8+            | 12.8+              |

**GPU recomendada de Clore.ai**: RTX 4090 de 24GB ($0.14–0.42/h) para 27B cuantizado — el punto óptimo

## Inicio rápido con Ollama

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

# Ejecuta diferentes tamaños
ollama run gemma3:1b     # Pequeño — 1.5GB de VRAM
ollama run gemma3:4b     # Pequeño — 4GB de VRAM
ollama run gemma3:12b    # Mediano — 10GB de VRAM
ollama run gemma3:27b    # Grande — 18-20GB de 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 frente a GraphQL para una nueva API"}]
  }'
```

### Visión con Ollama

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

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

```bash
pip install vllm

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

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

# Sirve 4B para configuraciones de bajo presupuesto
vllm serve google/gemma-3-4b-it \
  --max-model-len 32768
```

## Transformers de HuggingFace

### 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  # Cabe en una 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                      |
| ------------------ | -------------------------- | -------------------------- | ----------------------------------- |
| ELO de LMArena     | 1354                       | 1298                       | 1337                                |
| MMLU               | 75.6                       | 79.3                       | 85.2                                |
| HumanEval          | 72.0                       | 72.6                       | 80.5                                |
| VRAM (Q4)          | 18GB                       | 40 GB                      | 200GB+                              |
| **Costo en Clore** | **$0.14–0.42/h** (1× 4090) | **$0.28–0.84/h** (2× 4090) | **no disponible en el marketplace** |

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

## Consejos para usuarios de Clore.ai

* **27B QAT es el punto óptimo**: el Entrenamiento con Conciencia de Cuantización significa menos pérdida de calidad que la cuantización posterior al entrenamiento — ejecútalo en una sola RTX 4090
* **La visión es gratis**: no se necesita configuración adicional — Gemma 3 entiende imágenes de forma nativa. Ideal para análisis de documentos, análisis de capturas de pantalla, lectura de gráficos
* **Empieza con un contexto corto**: Usa `--max-model-len 8192` al principio; aumenta solo cuando sea necesario para ahorrar VRAM
* **4B para ejecuciones de bajo presupuesto**: si usas una RTX 3060/3070 ($0.03–0.07/h), el modelo 4B aún supera a 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`                |
| Los resultados del modelo son basura | Asegúrate de que estás usando la `-it` (ajustada para instrucción), 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)
* [Tarjeta del modelo en HuggingFace](https://huggingface.co/google/gemma-3-27b-it)
* [Biblioteca de 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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/gemma3.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.