# Compatibilidad de modelos

Guía completa de qué modelos de IA se ejecutan en qué GPUs en CLORE.AI.

{% hint style="success" %}
Encuentra GPUs con la VRAM adecuada en [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Referencia rápida

### Modelos de lenguaje (LLM)

| Modelo                  | Parámetros | VRAM mínima | Recomendado            | Cuantización                    |
| ----------------------- | ---------- | ----------- | ---------------------- | ------------------------------- |
| Llama 3.2               | 1B         | 2GB         | 4GB                    | Q4, Q8, FP16                    |
| Llama 3.2               | 3B         | 4GB         | 6GB                    | Q4, Q8, FP16                    |
| Llama 3.1/3             | 8B         | 6GB         | 12GB                   | Q4, Q8, FP16                    |
| Mistral                 | 7B         | 6GB         | 12GB                   | Q4, Q8, FP16                    |
| Qwen 2.5                | 7B         | 6GB         | 12GB                   | Q4, Q8, FP16                    |
| Qwen 2.5                | 14B        | 12GB        | 16GB                   | Q4, Q8                          |
| Qwen 2.5                | 32B        | 20GB        | 24GB                   | Q4, Q8                          |
| Llama 3.1               | 70B        | 40GB        | 48GB                   | Q4, Q8                          |
| Qwen 2.5                | 72B        | 48GB        | 80GB                   | Q4, Q8                          |
| Mixtral                 | 8x7B       | 24GB        | 48GB                   | Q4                              |
| DeepSeek-V3             | 671B       | 320GB+      | 640GB                  | FP8                             |
| **DeepSeek-R1**         | **671B**   | **320GB+**  | **8x H100**            | **FP8, modelo de razonamiento** |
| **DeepSeek-R1-Distill** | **32B**    | **20GB**    | **2x A100 / RTX 5090** | **Q4/Q8**                       |

### Modelos de generación de imágenes

| Modelo               | VRAM mínima | Recomendado         | Notas                                  |
| -------------------- | ----------- | ------------------- | -------------------------------------- |
| SD 1.5               | 4GB         | 8GB                 | 512x512 nativo                         |
| SD 2.1               | 6GB         | 8GB                 | 768x768 nativo                         |
| SDXL                 | 8GB         | 12GB                | 1024x1024 nativo                       |
| SDXL Turbo           | 8GB         | 12GB                | 1-4 pasos                              |
| **SD3.5 Large (8B)** | **16GB**    | **24GB**            | **1024x1024, calidad avanzada**        |
| FLUX.1 schnell       | 12GB        | 16GB                | 4 pasos, rápido                        |
| FLUX.1 dev           | 16GB        | 24GB                | 20-50 pasos                            |
| **TRELLIS**          | **16GB**    | **24GB (RTX 4090)** | **Generación 3D a partir de imágenes** |

### Modelos de generación de video

| Modelo                 | VRAM mínima | Recomendado              | Salida                       |
| ---------------------- | ----------- | ------------------------ | ---------------------------- |
| Stable Video Diffusion | 16GB        | 24GB                     | 4 s, 576x1024                |
| AnimateDiff            | 12GB        | 16GB                     | 2-4 s                        |
| **LTX-Video**          | **16GB**    | **24GB (RTX 4090/3090)** | **5 s, 768x512, muy rápido** |
| Wan2.1                 | 24GB        | 40GB                     | 5 s, 480p-720p               |
| Hunyuan Video          | 40GB        | 80GB                     | 5 s, 720p                    |
| OpenSora               | 24GB        | 40GB                     | Variable                     |

### Modelos de audio

| Modelo           | VRAM mínima | Recomendado | Tarea                |
| ---------------- | ----------- | ----------- | -------------------- |
| Whisper tiny     | 1GB         | 2GB         | Transcripción        |
| Whisper base     | 1GB         | 2GB         | Transcripción        |
| Whisper small    | 2GB         | 4GB         | Transcripción        |
| Whisper medium   | 4GB         | 6GB         | Transcripción        |
| Whisper large-v3 | 6GB         | 10GB        | Transcripción        |
| Bark             | 8GB         | 12GB        | Texto a voz          |
| Stable Audio     | 8GB         | 12GB        | Generación de música |

### Modelos de visión y visión-lenguaje

| Modelo               | VRAM mínima | Recomendado         | Tarea                                |
| -------------------- | ----------- | ------------------- | ------------------------------------ |
| Llama 3.2 Vision 11B | 12GB        | 16GB                | Comprensión de imágenes              |
| Llama 3.2 Vision 90B | 48GB        | 80GB                | Comprensión de imágenes              |
| LLaVA 7B             | 8GB         | 12GB                | QA visual                            |
| LLaVA 13B            | 16GB        | 24GB                | QA visual                            |
| **Qwen2.5-VL 7B**    | **16GB**    | **24GB (RTX 4090)** | **OCR de imágenes/video/documentos** |
| **Qwen2.5-VL 72B**   | **48GB**    | **2x A100 80GB**    | **Máxima capacidad VL**              |

### Herramientas de ajuste fino y entrenamiento

| Herramienta / Método    | VRAM mínima | GPU recomendada   | Tarea                               |
| ----------------------- | ----------- | ----------------- | ----------------------------------- |
| **Unsloth QLoRA 7B**    | **12GB**    | **RTX 3090 24GB** | **QLoRA 2x más rápido, baja VRAM**  |
| Unsloth QLoRA 13B       | 16GB        | RTX 4090 24GB     | Ajuste fino rápido                  |
| LoRA (estándar)         | 12GB        | RTX 3090          | Ajuste fino eficiente en parámetros |
| Ajuste fino completo 7B | 40GB        | A100 40GB         | Entrenamiento de máxima calidad     |

***

## Tablas detalladas de compatibilidad

### LLM por GPU

| GPU              | Máx. modelo (Q4) | Máx. modelo (Q8) | Máx. modelo (FP16) |
| ---------------- | ---------------- | ---------------- | ------------------ |
| RTX 3060 12GB    | 13B              | 7B               | 3B                 |
| RTX 3070 8GB     | 7B               | 3B               | 1B                 |
| RTX 3080 10GB    | 7B               | 7B               | 3B                 |
| RTX 3090 24GB    | 30B              | 13B              | 7B                 |
| RTX 4070 Ti 12GB | 13B              | 7B               | 3B                 |
| RTX 4080 16GB    | 14B              | 7B               | 7B                 |
| RTX 4090 24GB    | 30B              | 13B              | 7B                 |
| RTX 5090 32GB    | 70B              | 14B              | 13B                |
| A100 40GB        | 70B              | 30B              | 14B                |
| A100 80GB        | 70B              | 70B              | 30B                |
| H100 80GB        | 70B              | 70B              | 30B                |

### Generación de imágenes por GPU

| GPU              | SD 1.5 | SDXL   | FLUX schnell | FLUX dev |
| ---------------- | ------ | ------ | ------------ | -------- |
| RTX 3060 12GB    | ✅ 512  | ✅ 768  | ⚠️ 512\*     | ❌        |
| RTX 3070 8GB     | ✅ 512  | ⚠️ 512 | ❌            | ❌        |
| RTX 3080 10GB    | ✅ 512  | ✅ 768  | ⚠️ 512\*     | ❌        |
| RTX 3090 24GB    | ✅ 768  | ✅ 1024 | ✅ 1024       | ⚠️ 768\* |
| RTX 4070 Ti 12GB | ✅ 512  | ✅ 768  | ⚠️ 512\*     | ❌        |
| RTX 4080 16GB    | ✅ 768  | ✅ 1024 | ✅ 768        | ⚠️ 512\* |
| RTX 4090 24GB    | ✅ 1024 | ✅ 1024 | ✅ 1024       | ✅ 1024   |
| RTX 5090 32GB    | ✅ 1024 | ✅ 1024 | ✅ 1536       | ✅ 1536   |
| A100 40GB        | ✅ 1024 | ✅ 1024 | ✅ 1024       | ✅ 1024   |
| A100 80GB        | ✅ 2048 | ✅ 2048 | ✅ 1536       | ✅ 1536   |

\*Con descarga a CPU o tamaño de batch reducido

### Generación de video por GPU

| GPU           | SVD     | AnimateDiff | Wan2.1  | Hunyuan  |
| ------------- | ------- | ----------- | ------- | -------- |
| RTX 3060 12GB | ❌       | ⚠️ corto    | ❌       | ❌        |
| RTX 3090 24GB | ✅ 2-4 s | ✅           | ⚠️ 480p | ❌        |
| RTX 4090 24GB | ✅ 4 s   | ✅           | ✅ 480p  | ⚠️ corto |
| RTX 5090 32GB | ✅ 6 s   | ✅           | ✅ 720p  | ✅ 5 s    |
| A100 40GB     | ✅ 4 s   | ✅           | ✅ 720p  | ✅ 5 s    |
| A100 80GB     | ✅ 8 s   | ✅           | ✅ 720p  | ✅ 10 s   |

***

## Guía de cuantización

### ¿Qué es la cuantización?

La cuantización reduce la precisión del modelo para caber en menos VRAM:

| Formato  | Bits | Reducción de VRAM | Pérdida de calidad |
| -------- | ---- | ----------------- | ------------------ |
| FP32     | 32   | Línea base        | Ninguna            |
| FP16     | 16   | 50%               | Mínima             |
| BF16     | 16   | 50%               | Mínima             |
| FP8      | 8    | 75%               | Pequeña            |
| Q8       | 8    | 75%               | Pequeña            |
| Q6\_K    | 6    | 81%               | Pequeña            |
| Q5\_K\_M | 5    | 84%               | Moderada           |
| Q4\_K\_M | 4    | 87%               | Moderada           |
| Q3\_K\_M | 3    | 91%               | Notable            |
| Q2\_K    | 2    | 94%               | Significativa      |

### Calculadora de VRAM

**Fórmula:** `VRAM (GB) ≈ Parámetros (B) × Bytes por parámetro`

| Tamaño del modelo | FP16   | Q8    | Q4     |
| ----------------- | ------ | ----- | ------ |
| 1B                | 2 GB   | 1 GB  | 0.5 GB |
| 3B                | 6 GB   | 3 GB  | 1.5 GB |
| 7B                | 14 GB  | 7 GB  | 3.5 GB |
| 8B                | 16 GB  | 8 GB  | 4 GB   |
| 13B               | 26 GB  | 13 GB | 6.5 GB |
| 14B               | 28 GB  | 14 GB | 7 GB   |
| 30B               | 60 GB  | 30 GB | 15 GB  |
| 32B               | 64 GB  | 32 GB | 16 GB  |
| 70B               | 140 GB | 70 GB | 35 GB  |
| 72B               | 144 GB | 72 GB | 36 GB  |

\*Añadir \~20% para caché KV y sobrecarga

### Cuantización recomendada por caso de uso

| Caso de uso        | Recomendado | Por qué                                   |
| ------------------ | ----------- | ----------------------------------------- |
| Chat/General       | Q4\_K\_M    | Buen equilibrio entre velocidad y calidad |
| Programación       | Q5\_K\_M+   | Mejor precisión para código               |
| Escritura creativa | Q4\_K\_M    | La velocidad importa más                  |
| Análisis           | Q6\_K+      | Se necesita mayor precisión               |
| Producción         | FP16/BF16   | Calidad máxima                            |

***

## Longitud de contexto vs VRAM

### Cómo el contexto afecta la VRAM

Cada modelo tiene una ventana de contexto (máx. tokens). Contexto más largo = más VRAM:

| Modelo       | Contexto por defecto | Contexto máximo | VRAM por 1K tokens |
| ------------ | -------------------- | --------------- | ------------------ |
| Llama 3 8B   | 8K                   | 128K            | \~0.3 GB           |
| Llama 3 70B  | 8K                   | 128K            | \~0.5 GB           |
| Qwen 2.5 7B  | 8K                   | 128K            | \~0.25 GB          |
| Mistral 7B   | 8K                   | 32K             | \~0.25 GB          |
| Mixtral 8x7B | 32K                  | 32K             | \~0.4 GB           |

### Contexto por GPU (Llama 3 8B Q4)

| GPU           | Contexto cómodo | Contexto máximo |
| ------------- | --------------- | --------------- |
| RTX 3060 12GB | 16K             | 32K             |
| RTX 3090 24GB | 64K             | 96K             |
| RTX 4090 24GB | 64K             | 96K             |
| RTX 5090 32GB | 96K             | 128K            |
| A100 40GB     | 96K             | 128K            |
| A100 80GB     | 128K            | 128K            |

***

## Configuraciones multi-GPU

### Paralelismo tensorial

Divide un modelo entre múltiples GPUs:

| Configuración | VRAM total | Máx. modelo (FP16) |
| ------------- | ---------- | ------------------ |
| 2x RTX 3090   | 48GB       | 30B                |
| 2x RTX 4090   | 48GB       | 30B                |
| 2x RTX 5090   | 64GB       | 32B                |
| 4x RTX 5090   | 128GB      | 70B                |
| 2x A100 40GB  | 80GB       | 70B                |
| 4x A100 40GB  | 160GB      | 100B+              |
| 8x A100 80GB  | 640GB      | DeepSeek-V3        |

### vLLM Multi-GPU

```bash
# 2 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 2

# 4 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 4
```

***

## Guías específicas de modelos

### Familia Llama 3.1

| Variante       | Parámetros | GPU mínima    | Configuración recomendada |
| -------------- | ---------- | ------------- | ------------------------- |
| Llama 3.2 1B   | 1B         | Cualquier 4GB | RTX 3060                  |
| Llama 3.2 3B   | 3B         | Cualquier 6GB | RTX 3060                  |
| Llama 3.1 8B   | 8B         | RTX 3060      | RTX 3090                  |
| Llama 3.1 70B  | 70B        | A100 40GB     | 2x A100 40GB              |
| Llama 3.1 405B | 405B       | 8x A100 80GB  | 8x H100                   |

### Familia Mistral/Mixtral

| Variante      | Parámetros | GPU mínima   | Configuración recomendada |
| ------------- | ---------- | ------------ | ------------------------- |
| Mistral 7B    | 7B         | RTX 3060     | RTX 3090                  |
| Mixtral 8x7B  | 46.7B      | RTX 3090     | A100 40GB                 |
| Mixtral 8x22B | 141B       | 2x A100 80GB | 4x A100 80GB              |

### Familia Qwen 2.5

| Variante      | Parámetros | GPU mínima    | Configuración recomendada |
| ------------- | ---------- | ------------- | ------------------------- |
| Qwen 2.5 0.5B | 0.5B       | Cualquier 2GB | Cualquier 4GB             |
| Qwen 2.5 1.5B | 1.5B       | Cualquier 4GB | RTX 3060                  |
| Qwen 2.5 3B   | 3B         | Cualquier 6GB | RTX 3060                  |
| Qwen 2.5 7B   | 7B         | RTX 3060      | RTX 3090                  |
| Qwen 2.5 14B  | 14B        | RTX 3090      | RTX 4090                  |
| Qwen 2.5 32B  | 32B        | RTX 4090      | A100 40GB                 |
| Qwen 2.5 72B  | 72B        | A100 40GB     | A100 80GB                 |

### Modelos DeepSeek

| Variante                         | Parámetros | GPU mínima        | Configuración recomendada |
| -------------------------------- | ---------- | ----------------- | ------------------------- |
| DeepSeek-Coder 6.7B              | 6.7B       | RTX 3060          | RTX 3090                  |
| DeepSeek-Coder 33B               | 33B        | RTX 4090          | A100 40GB                 |
| DeepSeek-V2-Lite                 | 15.7B      | RTX 3090          | A100 40GB                 |
| DeepSeek-V3                      | 671B       | 8x A100 80GB      | 8x H100                   |
| **DeepSeek-R1**                  | **671B**   | **8x A100 80GB**  | **8x H100 (FP8)**         |
| **DeepSeek-R1-Distill-Qwen-32B** | **32B**    | **RTX 5090 32GB** | **2x A100 40GB**          |
| **DeepSeek-R1-Distill-Qwen-7B**  | **7B**     | **RTX 3090 24GB** | **RTX 4090**              |

***

## Solución de problemas

### "CUDA out of memory"

1. **Reducir cuantización:** Q8 → Q4
2. **Reducir la longitud del contexto:** Reducir max\_tokens
3. **Habilitar descarga a CPU:** `--cpu-offload` o `enable_model_cpu_offload()`
4. **Usar batch más pequeño:** batch\_size=1
5. **Probar otra GPU:** Necesita más VRAM

### "Modelo demasiado grande"

1. **Usar versión cuantizada:** modelos GGUF Q4
2. **Usar múltiples GPUs:** Paralelismo tensorial
3. **Descargar a la CPU:** Más lento pero funciona
4. **Elegir modelo más pequeño:** 7B en lugar de 13B

### "Generación lenta"

1. **Actualizar GPU:** Más VRAM = menos descarga
2. **Usar cuantización más rápida:** Q4 es más rápido que Q8
3. **Reducir contexto:** Más corto = más rápido
4. **Habilitar flash attention:** `--flash-attn`

## Próximos pasos

* [Guía de comparación de GPUs](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) - Especificaciones detalladas de GPUs
* [Catálogo de imágenes Docker](/guides/guides_v2-es/primeros-pasos/docker-images.md) - Imágenes listas para desplegar
* [Guía de inicio rápido](/guides/guides_v2-es/quickstart.md) - Comienza en 5 minutos


---

# 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/primeros-pasos/model-compatibility.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.