# Qwen2.5-VL Vision-Language-Modell

Qwen2.5-VL von Alibaba (Dezember 2024) ist das leistungsstärkste offene Vision-Language-Modell (VLM) in seiner Gewichtsklasse. Erhältlich in 3B-, 7B- und 72B-Parametergrößen, versteht es Bilder, Videoframes, PDFs, Diagramme und komplexe visuelle Layouts. Die 7B-Variante trifft den Sweet Spot — sie übertrifft viele größere Modelle in Benchmarks und läuft bequem auf einer einzelnen 24-GB-GPU.

An [Clore.ai](https://clore.ai/) können Sie genau die GPU mieten, die Sie benötigen — von einer RTX 3090 für das 7B-Modell bis hin zu Multi-GPU-Setups für die 72B-Variante — und in wenigen Minuten mit der Analyse visueller Inhalte beginnen.

## Hauptmerkmale

* **Multimodale Eingabe** — Bilder, Videos, PDFs, Screenshots, Diagramme und Schaubilder in einem einzigen Modell.
* **Drei Skalen** — 3B (Edge/Mobil), 7B (Produktions-Sweet-Spot), 72B (SOTA-Qualität).
* **Dynamische Auflösung** — verarbeitet Bilder in ihrer nativen Auflösung; kein erzwungenes Skalieren auf 224×224.
* **Videoverstehen** — akzeptiert mehrbildige Videoeingaben mit zeitlicher Argumentation.
* **Dokumenten-OCR** — extrahiert Text aus gescannten Dokumenten, Quittungen und handschriftlichen Notizen.
* **Mehrsprachig** — starke Leistung in Englisch, Chinesisch und über 20 weiteren Sprachen.
* **Ollama-Unterstützung** — lokal ausführen mit `ollama run qwen2.5vl:7b` für eine bereitzustellung ohne Code.
* **Transformers-Integration** — `Qwen2_5_VLForConditionalGeneration` in HuggingFace `transformers`.

## Anforderungen

| Komponente | 3B    | 7B       | 72B                |
| ---------- | ----- | -------- | ------------------ |
| GPU-VRAM   | 8 GB  | 16–24 GB | 80+ GB (Multi-GPU) |
| System-RAM | 16 GB | 32 GB    | 128 GB             |
| Festplatte | 10 GB | 20 GB    | 150 GB             |
| Python     | 3.10+ | 3.10+    | 3.10+              |
| CUDA       | 12.1+ | 12.1+    | 12.1+              |

**Clore.ai GPU-Empfehlung:** Für das **7B-Modell**, ein **RTX 4090** (24 GB, \~0,5–2 $/Tag) oder **RTX 3090** (24 GB, \~0,3–1 $/Tag) ist ideal. Für **72B**, filtern Sie den Marktplatz nach **A100 80 GB** oder Multi-GPU-Setups.

## Schnellstart

### Option A: Ollama (Einfachste)

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

# Ziehe und starte das 7B-Vision-Modell
ollama run qwen2.5vl:7b
```

Dann im ollama-Prompt:

```
>>> Beschreibe dieses Bild: /path/to/photo.jpg
```

### Option B: Python / Transformers

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

## Beispielanwendungen

### Bildverständnis mit 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": "Welche Art ist dieses Insekt? Beschreibe seine wichtigsten Erkennungsmerkmale."},
        ],
    }
]

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)
```

### Videoanalyse

```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": "Fasse zusammen, was in diesem Video passiert. Liste die wichtigsten Ereignisse in der Reihenfolge auf."},
        ],
    }
]

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])
```

### Dokumenten-OCR und Extraktion

```python
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "file:///workspace/receipt.jpg"},
            {"type": "text", "text": "Extrahiere alle Artikel, Mengen und Preise aus dieser Quittung. Gib das Ergebnis als JSON zurück."},
        ],
    }
]

# Verarbeitung mit dem oben verwendeten Modell/Processor
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])
```

### Ollama-API für Batch-Verarbeitung

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

def analyze_image(image_path: str, question: str) -> str:
    """Sende ein Bild an Qwen2.5-VL über die Ollama-API."""
    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"]

# Verarbeite einen Ordner mit Bildern im Batch
from pathlib import Path
for img in sorted(Path("./photos").glob("*.jpg")):
    result = analyze_image(str(img), "Beschreibe dieses Bild in einem Satz.")
    print(f"{img.name}: {result}")
```

## Tipps für Clore.ai-Nutzer

1. **Ollama für schnelle Bereitstellung** — `ollama run qwen2.5vl:7b` ist der schnellste Weg zu einem funktionierenden VLM. Keine Python-Code nötig für interaktive Nutzung.
2. **7B ist der Sweet Spot** — die 7B Instruct-Variante passt mit 4-Bit-Quantisierung in 16 GB VRAM und liefert eine Qualität, die mit deutlich größeren Modellen konkurriert.
3. **Dynamische Auflösung ist wichtig** — Qwen2.5-VL verarbeitet Bilder in nativer Auflösung. Bei großen Bildern (>4K) auf maximal 1920px Breite verkleinern, um übermäßigen VRAM-Verbrauch zu vermeiden.
4. **Video-fps-Einstellung** — für Videoeingaben setze `fps=1.0` um 1 Frame pro Sekunde zu sampeln. Höhere Werte verbrauchen schnell VRAM; 1 fps reicht für die meisten Analyseaufgaben aus.
5. **Persistenter Speicher** — setze `HF_HOME=/workspace/hf_cache`; das 7B-Modell ist \~15 GB. Bei ollama landen Modelle in `~/.ollama/models/`.
6. **Strukturierte Ausgabe** — Qwen2.5-VL befolgt JSON-Formatierungsanweisungen gut. Fordere "Als JSON zurückgeben" an und du erhältst die meiste Zeit parsefähige Ausgaben.
7. **Mehrfachbild-Vergleich** — du kannst mehrere Bilder in einer einzigen Nachricht übergeben für Vergleichsaufgaben (z. B. "Welches dieser beiden Produkte wirkt hochwertiger?").
8. **tmux** — führe es immer innerhalb von `tmux` bei Clore.ai-Mietinstanzen aus.

## Fehlerbehebung

| Problem                                                 | Behebe                                                                                                     |
| ------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` mit 7B                               | Verwenden Sie `load_in_4bit=True` in `from_pretrained()` mit `bitsandbytes`; oder verwende die 3B-Variante |
| Ollama-Modell nicht gefunden                            | `ollama pull qwen2.5vl:7b` — stelle sicher, dass du das richtige Tag hast                                  |
| Langsame Videoverarbeitung                              | Reduzieren `fps` auf 0,5 und `max_pixels` auf `256 * 256`; weniger Frames = schnellere Inferenz            |
| Wirre oder leere Ausgabe                                | Erhöhe `max_new_tokens`; der Standardwert kann für detaillierte Beschreibungen zu niedrig sein             |
| `ImportError: qwen_vl_utils`                            | `pip install qwen-vl-utils` — erforderlich für `process_vision_info()`                                     |
| 72B-Modell passt nicht                                  | Verwende 2× A100 80 GB mit `device_map="auto"` oder wende AWQ-Quantisierung an                             |
| Bildpfad nicht gefunden                                 | Für lokale Dateien in Nachrichten verwende `file:///absolute/path` Format                                  |
| Chinesisch in der Ausgabe bei Aufforderung auf Englisch | Füge "Nur auf Englisch antworten." zu deinem Prompt hinzu                                                  |