> 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-vision/qwen-vl.md).

# Modelo de visión y lenguaje Qwen2.5-VL

Ejecuta Qwen2.5-VL, el principal modelo abierto de visión y lenguaje, para comprender imágenes, videos y documentos en GPUs de Clore.ai.

Qwen2.5-VL de Alibaba (diciembre de 2024) es el modelo visión-lenguaje de pesos abiertos con mejor rendimiento (VLM). Disponible en tamaños de parámetros de 3B, 7B y 72B, entiende imágenes, fotogramas de vídeo, PDF, gráficos y diseños visuales complejos. La variante 7B da en el punto óptimo: supera a muchos modelos más grandes en los benchmarks mientras funciona cómodamente en una sola GPU de 24 GB.

En [Clore.ai](https://clore.ai/) puedes alquilar exactamente la GPU que necesitas — desde una RTX 3090 para el modelo 7B hasta configuraciones multi-GPU para la variante 72B — y empezar a analizar contenido visual en minutos.

## Características clave

* **Entrada multimodal** — imágenes, vídeo, PDF, capturas de pantalla, gráficos y diagramas en un solo modelo.
* **Tres escalas** — 3B (edge/móvil), 7B (punto óptimo para producción), 72B (calidad SOTA).
* **Resolución dinámica** — procesa imágenes en su resolución nativa; sin redimensionado forzado a 224×224.
* **Comprensión de vídeo** — acepta entrada de vídeo de múltiples fotogramas con razonamiento temporal.
* **OCR de documentos** — extrae texto de documentos escaneados, recibos y notas manuscritas.
* **Multilingüe** — gran rendimiento en inglés, chino y más de 20 otros idiomas.
* **Compatibilidad con Ollama** — ejecútalo localmente con `ollama run qwen2.5vl:7b` para una implementación sin código.
* **Integración con Transformers** — `Qwen2_5_VLForConditionalGeneration` en Hugging Face `transformers`.

## Requisitos

{% hint style="warning" %}
**Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai.** Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como [bare metal](https://clore.ai/bare-metal) bajo pedido. Consulta [Precios y disponibilidad de GPU](/guides/guides_v2-es/primeros-pasos/pricing.md) antes de dimensionar un despliegue.
{% endhint %}

| Componente      | 3B    | 7B       | 72B                |
| --------------- | ----- | -------- | ------------------ |
| VRAM de GPU     | 8 GB  | 16–24 GB | 80+ GB (multi-GPU) |
| RAM del sistema | 16 GB | 32 GB    | 128 GB             |
| Disco           | 10 GB | 20 GB    | 150 GB             |
| Python          | 3.10+ | 3.10+    | 3.10+              |
| CUDA            | 12.8+ | 12.8+    | 12.8+              |

**Recomendación de GPU de Clore.ai:** Para el **modelo 7B**, una **RTX 4090** (24 GB, $0.14–0.42/h) o **RTX 3090** (24 GB, $0.07–0.21/h) es ideal. Para **72B**, filtra el marketplace por **A100 80 GB** o configuraciones multi-GPU.

## Inicio rápido

### Opción A: Ollama (la más sencilla)

```bash
# Instala ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Descarga y ejecuta el modelo de visión 7B
ollama run qwen2.5vl:7b
```

Luego, en el prompt de Ollama:

```
>>> Describe esta imagen: /path/to/photo.jpg
```

### Opción B: Python / Transformers

```bash
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128
pip install transformers accelerate qwen-vl-utils pillow
```

## Ejemplos de uso

### Comprensión de imágenes con Transformers

```python
import torch
from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
from qwen_vl_utils import process_vision_info

model_name = "Qwen/Qwen2.5-VL-7B-Instruct"

model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
processor = AutoProcessor.from_pretrained(model_name)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"},
            {"type": "text", "text": "¿Qué especie es este insecto? Describe sus principales características de identificación."},
        ],
    }
]

text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
image_inputs, video_inputs = process_vision_info(messages)

inputs = processor(
    text=[text],
    images=image_inputs,
    videos=video_inputs,
    padding=True,
    return_tensors="pt",
).to(model.device)

output_ids = model.generate(**inputs, max_new_tokens=512)
response = processor.batch_decode(
    output_ids[:, inputs.input_ids.shape[1]:],
    skip_special_tokens=True,
)[0]

print(response)
```

### Análisis de vídeo

```python
import torch
from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
from qwen_vl_utils import process_vision_info

model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
    "Qwen/Qwen2.5-VL-7B-Instruct",
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-7B-Instruct")

messages = [
    {
        "role": "user",
        "content": [
            {"type": "video", "video": "file:///workspace/clip.mp4", "max_pixels": 360 * 420, "fps": 1.0},
            {"type": "text", "text": "Resume lo que ocurre en este vídeo. Enumera los eventos clave en orden."},
        ],
    }
]

text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
image_inputs, video_inputs = process_vision_info(messages)

inputs = processor(
    text=[text],
    images=image_inputs,
    videos=video_inputs,
    padding=True,
    return_tensors="pt",
).to(model.device)

output_ids = model.generate(**inputs, max_new_tokens=1024)
print(processor.batch_decode(output_ids[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)[0])
```

### OCR y extracción de documentos

```python
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "file:///workspace/receipt.jpg"},
            {"type": "text", "text": "Extrae todos los artículos, cantidades y precios de este recibo. Devuélvelo como JSON."},
        ],
    }
]

# Procesa usando la misma configuración de modelo/procesador de arriba
text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
image_inputs, video_inputs = process_vision_info(messages)
inputs = processor(text=[text], images=image_inputs, videos=video_inputs, padding=True, return_tensors="pt").to(model.device)
output_ids = model.generate(**inputs, max_new_tokens=2048)
print(processor.batch_decode(output_ids[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)[0])
```

### API de Ollama para procesamiento por lotes

```python
import ollama
import base64
from pathlib import Path

def analyze_image(image_path: str, question: str) -> str:
    """Envía una imagen a Qwen2.5-VL a través de la API de Ollama."""
    image_data = base64.b64encode(Path(image_path).read_bytes()).decode()
    response = ollama.chat(
        model="qwen2.5vl:7b",
        messages=[{
            "role": "user",
            "content": question,
            "images": [image_data],
        }],
    )
    return response["message"]["content"]

# Procesa por lotes una carpeta de imágenes
from pathlib import Path
for img in sorted(Path("./photos").glob("*.jpg")):
    result = analyze_image(str(img), "Describe esta imagen en una sola frase.")
    print(f"{img.name}: {result}")
```

## Consejos para usuarios de Clore.ai

1. **Ollama para una implementación rápida** — `ollama run qwen2.5vl:7b` es la forma más rápida de conseguir un VLM funcional. No hace falta código Python para el uso interactivo.
2. **7B es el punto óptimo** — la variante Instruct de 7B cabe en 16 GB de VRAM con cuantización de 4 bits y ofrece una calidad competitiva con modelos mucho más grandes.
3. **La resolución dinámica importa** — Qwen2.5-VL procesa las imágenes en resolución nativa. Para imágenes grandes (>4K), redimensiónalas a un ancho máximo de 1920 px para evitar un uso excesivo de VRAM.
4. **Configuración de fps del vídeo** — para entrada de vídeo, establece `fps=1.0` para muestrear 1 fotograma por segundo. Valores más altos consumen VRAM rápidamente; 1 fps es suficiente para la mayoría de las tareas de análisis.
5. **Almacenamiento persistente** — establece `HF_HOME=/workspace/hf_cache`; el modelo 7B ocupa \~15 GB. Para ollama, los modelos van a `~/.ollama/models/`.
6. **Salida estructurada** — Qwen2.5-VL sigue muy bien las instrucciones de formato JSON. Pide "Devuélvelo como JSON" y obtendrás una salida analizable la mayor parte del tiempo.
7. **Comparación de múltiples imágenes** — puedes pasar varias imágenes en un solo mensaje para tareas de comparación (por ejemplo, "¿Cuál de estos dos productos parece más premium?").
8. **tmux** — ejecútalo siempre dentro de `tmux` en alquileres de Clore.ai.

## Solución de problemas

| Problema                              | Solución                                                                                                 |
| ------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` con 7B             | Usa `load_in_4bit=True` en `from_pretrained()` con `bitsandbytes`; o usa la variante 3B                  |
| No se encuentra el modelo de Ollama   | `ollama pull qwen2.5vl:7b` — asegúrate de tener la etiqueta correcta                                     |
| Procesamiento de vídeo lento          | Reduce `fps` a 0.5 y `max_pixels` a `256 * 256`; menos fotogramas = inferencia más rápida                |
| Salida ilegible o vacía               | Aumenta `max_new_tokens`; el valor predeterminado puede ser demasiado bajo para descripciones detalladas |
| `ImportError: qwen_vl_utils`          | `pip install qwen-vl-utils` — necesario para `process_vision_info()`                                     |
| El modelo 72B no cabe                 | Usa 2× A100 de 80 GB con `device_map="auto"` o aplica cuantización AWQ                                   |
| Ruta de la imagen no encontrada       | Para archivos locales en los mensajes, usa `file:///absolute/path` formato                               |
| Chino en la salida al pedir en inglés | Añade "Responde solo en inglés." a tu prompt                                                             |


---

# 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-vision/qwen-vl.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.