Qwen2.5-VL Vision-Language-Modell

Führe Qwen2.5-VL, das führende offene Vision-Language-Modell, für Bild-/Video-/Dokumentenverständnis auf Clore.ai-GPUs aus.

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

Auf Clore.ai Sie können 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.

Hauptfunktionen

• Multimodale Eingabe — Bilder, Video, PDFs, Screenshots, Diagramme und Schaubilder in einem einzigen Modell.

• Drei Größen — 3B (Edge/Mobil), 7B (Produktions-Sweet-Spot), 72B (SOTA-Qualität).

• Dynamische Auflösung — verarbeitet Bilder in ihrer nativen Auflösung; keine erzwungene Größenänderung auf 224×224.

• Videoverständnis — akzeptiert Videoeingaben mit mehreren Frames und zeitlichem Schlussfolgern.

• Dokument-OCR — extrahiert Text aus gescannten Dokumenten, Belegen 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 Bereitstellung ohne Code.

• Transformers-Integration — Qwen2_5_VLForConditionalGeneration in HuggingFace transformers.

Anforderungen

Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet. Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als Bare Metal auf Anfrage verkauft. Prüfe GPU-Preise & Verfügbarkeit bevor du eine Bereitstellung dimensionierst.

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.8+	12.8+	12.8+

Clore.ai-GPU-Empfehlung: Für das 7B-Modellist ein RTX 4090 (24 GB, 0,14–0,42 $/Std.) oder RTX 3090 (24 GB, 0,07–0,21 $/Std.) ideal. Für 72Bfiltern Sie den Marktplatz nach A100 80 GB oder Multi-GPU-Setups.

Schnellstart

Option A: Ollama (am einfachsten)

# Ollama installieren
curl -fsSL https://ollama.ai/install.sh | sh

# Das 7B-Vision-Modell herunterladen und ausführen
ollama run qwen2.5vl:7b

Dann im Ollama-Prompt:

>>> Beschreibe dieses Bild: /pfad/zu/foto.jpg

Option B: Python / Transformers

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

Anwendungsbeispiele

Bildverständnis mit Transformers

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": "Um welche Art Insekt handelt es sich? Beschreiben Sie seine wichtigsten identifizierenden Merkmale."},
        ],
    }
]

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

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": "Fassen Sie zusammen, was in diesem Video passiert. Listen Sie die wichtigsten Ereignisse in der richtigen 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

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "file:///workspace/receipt.jpg"},
            Extrahieren Sie alle Positionen, Mengen und Preise aus diesem Beleg. Als JSON zurückgeben.
        ],
    }
]

# Verarbeitung mit demselben Modell-/Prozessor-Setup wie oben
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

import ollama
import base64
from pathlib import Path

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

# Einen Ordner mit Bildern im Batch verarbeiten
from pathlib import Path
for img in sorted(Path("./photos").glob("*.jpg")):
    result = analyze_image(str(img), "Beschreiben Sie 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. Für die interaktive Nutzung ist kein Python-Code erforderlich.

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 konkurrieren kann.

3. Dynamische Auflösung ist wichtig — Qwen2.5-VL verarbeitet Bilder in nativer Auflösung. Bei großen Bildern (>4K) auf eine maximale Breite von 1920 px skalieren, um übermäßigen VRAM-Verbrauch zu vermeiden.

4. Video-FPS-Einstellung — für Videoeingaben setzen Sie fps=1.0 auf 1 Frame pro Sekunde. Höhere Werte verbrauchen VRAM schnell; 1 fps reicht für die meisten Analyseaufgaben aus.

5. Persistenter Speicher — setzen Sie HF_HOME=/workspace/hf_cache; das 7B-Modell ist ~15 GB groß. Bei ollama landen Modelle unter ~/.ollama/models/.

6. Strukturierte Ausgabe — Qwen2.5-VL befolgt Anweisungen zur JSON-Formatierung gut. Fordern Sie „Als JSON zurückgeben“ an, und Sie erhalten die meiste Zeit parsebare Ausgaben.

7. Vergleich mehrerer Bilder — Sie können mehrere Bilder in einer einzigen Nachricht für Vergleichsaufgaben übergeben (z. B. „Welches dieser beiden Produkte wirkt hochwertiger?“).

8. tmux — immer innerhalb von tmux bei Clore.ai-Mietinstanzen ausführen.

Fehlerbehebung

Problem	Fix
OutOfMemoryError mit 7B	Verwende load_in_4bit=True in from_pretrained() mit bitsandbytes; oder verwenden Sie die 3B-Variante
Ollama-Modell nicht gefunden	ollama pull qwen2.5vl:7b — stellen Sie sicher, dass Sie das richtige Tag haben
Langsame Videoverarbeitung	Reduziere fps auf 0,5 und max_pixels auf 256 * 256; weniger Frames = schnellere Inferenz
Verwaschene oder leere Ausgabe	Erhöhen Sie max_new_tokens; der Standardwert ist für detaillierte Beschreibungen möglicherweise zu niedrig
ImportError: qwen_vl_utils	pip install qwen-vl-utils — erforderlich für process_vision_info()
72B-Modell passt nicht hinein	Verwenden Sie 2× A100 80 GB mit device_map="auto" oder wenden Sie AWQ-Quantisierung an
Bildpfad nicht gefunden	Für lokale Dateien in Nachrichten verwenden Sie file:///absoluter/pfad Format
Chinesisch in der Ausgabe, wenn auf Englisch gepromptet wird	Fügen Sie Ihrem Prompt „Antworten Sie nur auf Englisch.“ hinzu