Wichtige Highlights
Multimodal + Lange Videoanalyse
Unterstützt Bilder, Dokumente und lange Videos
Geeignet für Bildung, Medien, Überwachung
Präzise Lokalisierung + Strukturierte Ausgabe
Erkennt Objekte genau
Extrahiert strukturierte Daten aus Rechnungen, Formularen, Diagrammen
Nützlich in Finanzen, Recht, Logistik
Du kannst einen kostenlosen Test bei der Novita AI API starten – ganz bequem!
Qwen2.5-VL-72B-Instruct ist ein leistungsstarkes großes Vision-Language-Modell (LVLM) mit 72B Parametern, das für instruktionsbefolgende Aufgaben optimiert wurde. Es unterstützt sowohl textuelle als auch visuelle Eingaben (Bilder und Videos) und eignet sich daher ideal für multimodales Denken, Dokumentenverständnis, Videoanalyse und agentische Interaktion.
Was ist Qwen2.5-VL-72B?
Ein Beispiel, das die Fähigkeiten von Qwen2.5-VL-72B zeigt
**Eingabe:**Gib die Abfrage: ’der Benutzer nutzt die Bildgenerierungsfunktion’, wann tritt der beschriebene Inhalt im Video auf? Verwende Sekunden als Zeitformat.
Ausgabe: Der beschriebene Inhalt tritt von Sekunde 28 bis Sekunde 50 im Video auf. In diesem Abschnitt interagiert der Benutzer mit der Bildgenerierungsfunktion, fordert ein künstlerisches Doppelszenengemälde eines Berges bei Tag und Nacht an und erhält es. Anschließend fügt der Benutzer einen Vogel zum generierten Bild hinzu, was die Funktionalität des Bildgenerierungswerkzeugs demonstriert.
Qwen2.5-VL-72B Übersicht
| Kategorie | Element | Details |
|---|---|---|
| Basisinfo | Veröffentlichungsdatum | 28. Januar 2025 |
| Modellgröße | 73,4 Milliarden Parameter | |
| Open Source | Ja (veröffentlicht von Qwen) | |
| Architektur | Kernkomponenten | Dynamische Auflösung und Bildrate-Training\SwiGLU + RMSNorm + Window Attention\Dynamisches FPS-Sampling |
| Sprachunterstützung | Unterstützte Sprachen | Hervorragend in mehrsprachigen Dokumenten und Szenentexterkennung |
| Multimodal | Fähigkeit | Visuelle (Bilder und Videos) und Text-Eingaben |
| Kontext | Kontextfenster | Konfigurierbar bis zu 64.000 Tokens für lange Videos |
| Präzision | Tensor-Typ | BF16 |
| Benchmarks | MMMU (Bild) | 70,2 (Qwen2.5-VL-72B) vs 70,3 (GPT-4o) |
| MVBench (Video) | 70,4 (Qwen2.5-VL-72B) vs 64,6 (GPT-4o) | |
| AITZ_EM (Agent) | 83,2 (Qwen2.5-VL-72B) vs 35,3 (GPT-4o) |
Wie greife ich lokal auf Qwen2.5-VL-72B zu?
Qwen2.5-VL-72B Hardwareanforderungen
| Kategorie | Element | Details |
|---|---|---|
| Hardware | Nvidia A100 (80 GB) | 8 GPUs × 80 GB = 640 GB Gesamt-VRAM |
| Nvidia H100 (80 GB) | 8 GPUs × 80 GB = 640 GB Gesamt-VRAM | |
| RTX 4090 (24 GB) | 24 GPUs × 24 GB = 576 GB Gesamt-VRAM | |
| Nvidia L40S (48 GB) | 8 GPUs × 48 GB = 384 GB Gesamt-VRAM |
Qwen2.5-VL-72B lokal installieren
1. Abhängigkeiten installieren
bashCopyEdit<code># Installiere die neueste Hugging Face Transformers aus der Quelle (erforderlich für Qwen2.5-VL)<br>pip install git+https://github.com/huggingface/transformers accelerate<br><br># Installiere das Vision-Utility-Toolkit (empfohlen mit decord für schnelles Laden von Videos)<br>pip install 'qwen-vl-utils[decord]==0.0.8'</code>
2. Qwen2.5-VL für visuelle Fragebeantwortung verwenden
import torch
from transformers import AutoTokenizer, AutoModelForVision2Seq
from qwen_vl_utils import load_image, load_video, build_multimodal_inputs
# 🔧 Modellname (kann auch ein lokaler Pfad sein)
model_name = "Qwen/Qwen2.5-VL-7B-Instruct"
# Tokenizer und Modell laden
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForVision2Seq.from_pretrained(model_name, trust_remote_code=True).eval()
# Ein Bild laden (kann lokaler Pfad, URL oder base64 sein)
image = load_image("https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-VL/assets/demo.jpeg")
# Die Abfrage definieren
query = "Was passiert in dem Bild?"
# Eingaben für das Modell erstellen
inputs = build_multimodal_inputs(tokenizer, query=query, images=[image])
# Inferenz
with torch.no_grad():
outputs = model.generate(**inputs, max_new_tokens=128)
# Antwort decodieren und ausgeben
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("Antwort:", response)
3. Beispiel für Videoeingabe
video = load_video("path_or_url_to_video.mp4")
query = "Fasse den Videoinhalt zusammen."
inputs = build_multimodal_inputs(tokenizer, query=query, videos=[video])
with torch.no_grad():
outputs = model.generate(**inputs, max_new_tokens=128)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("Antwort:", response)
Wie greife ich über die Novita-API auf Qwen2.5-VL-72B zu?
Schritt 1: Einloggen und auf die Modellbibliothek zugreifen
Melde dich in deinem Konto an und klicke auf die Schaltfläche Modellbibliothek.
Jetzt Qwen2-VL-72B-Instruct Demo testen!
Schritt 2: Kostenlosen Test starten
Starte deinen kostenlosen Test, um die Fähigkeiten des ausgewählten Modells zu erkunden.
Schritt 3: Deinen API-Schlüssel abrufen
Zur Authentifizierung mit der API stellen wir dir einen neuen API-Schlüssel zur Verfügung. Rufe die Seite „Einstellungen“ auf und kopiere den API-Schlüssel wie im Bild gezeigt.
Schritt 4: Die API installieren
Installiere die API mit dem für deine Programmiersprache spezifischen Paketmanager.
Nach der Installation importierst du die erforderlichen Bibliotheken in deine Entwicklungsumgebung. Initialisiere die API mit deinem API-Schlüssel, um mit dem Novita AI LLM zu interagieren. Dies ist ein Beispiel für die Verwendung der Chat-Completion-API für Python-Benutzer.
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/v3/openai",
api_key="<DEIN Novita AI API-Schlüssel>",
)
model = "qwen/qwen2.5-vl-72b-instruct"
stream = True # oder False
max_tokens = 2048
system_content = """Sei ein hilfreicher Assistent"""
temperature = 1
top_p = 1
min_p = 0
top_k = 50
presence_penalty = 0
frequency_penalty = 0
repetition_penalty = 1
response_format = { "type": "text" }
chat_completion_res = client.chat.completions.create(
model=model,
messages=[
{
"role": "system",
"content": system_content,
},
{
"role": "user",
"content": "Hallo!",
}
],
stream=stream,
max_tokens=max_tokens,
temperature=temperature,
top_p=top_p,
presence_penalty=presence_penalty,
frequency_penalty=frequency_penalty,
response_format=response_format,
extra_body={
"top_k": top_k,
"repetition_penalty": repetition_penalty,
"min_p": min_p
}
)
if stream:
for chunk in chat_completion_res:
print(chunk.choices[0].delta.content or "", end="")
else:
print(chat_completion_res.choices[0].message.content)
Qwen2.5-VL-72B über Cloud-GPU verwenden
Schritt 1: Ein Konto registrieren
Wenn du neu bei Novita AI bist, erstelle zunächst ein Konto auf unserer Website. Gehe nach der Registrierung zum Tab „GPUs“, um verfügbare Ressourcen zu erkunden und deine Reise zu beginnen.
Schritt 2:Vorlagen und GPU-Server erkunden
Wähle zunächst eine Vorlage, die zu deinen Projektanforderungen passt, z. B. PyTorch, TensorFlow oder CUDA. Wähle die Version, die deinen Anforderungen entspricht, z. B. PyTorch 2.2.1 oder CUDA 11.8.0. Wähle dann die A100 GPU-Serverkonfiguration, die eine leistungsstarke Performance bietet, um anspruchsvolle Arbeitslasten mit ausreichend VRAM, RAM und Speicherkapazität zu bewältigen.
Teste Novita AIs Hochleistungs-GPUs
Schritt 3:Passe dein Deployment an
Nachdem du eine Vorlage und eine GPU ausgewählt hast, passe deine Deployment-Einstellungen an, indem du Parameter wie die Betriebssystemversion (z. B. CUDA 11.8) änderst. Du kannst auch andere Konfigurationen anpassen, um die Umgebung an die spezifischen Anforderungen deines Projekts anzupassen.
Schritt 4:Starte eine Instanz
Sobald du die Vorlage und die Deployment-Einstellungen finalisiert hast, klicke auf „Instanz starten“, um deine GPU-Instanz einzurichten. Dadurch wird die Umgebungseinrichtung gestartet, sodass du die GPU-Ressourcen für deine KI-Aufgaben nutzen kannst.
Qwen2.5-VL-72B-Instruct bietet hochmoderne Leistung für eine breite Palette von Vision-Language-Aufgaben. Egal, ob du Arbeitsabläufe im Finanzwesen automatisierst oder Videos in Echtzeit analysierst – es vereint Tiefe, Skalierbarkeit und Flexibilität. Mit Open-Source-Zugang und mehreren Bereitstellungspfaden – lokale GPU, Cloud-Instanzen oder API – befähigt Qwen2.5-VL Entwickler und Unternehmen, intelligentere und leistungsfähigere KI-Systeme zu bauen.
Häufig gestellte Fragen
Kann ich Qwen2.5-VL-72B-Instruct lokal bereitstellen?
Ja. Du kannst es auf Maschinen mit ausreichend VRAM ausführen (z. B. 8×A100 oder 24×4090 GPUs).
Wie verwende ich Qwen2.5-VL-72B-Instruct über die API?
Du kannst auf Qwen2.5-VL-72B-Instruct über die Novita AI Modellbibliothek zugreifen, einen kostenlosen Test starten und einen API-Schlüssel für die schnelle Integration erhalten.
Was ist der Unterschied zwischen Qwen2.5-VL-72B und Qwen2.5-VL-72B-Instruct?
Das Basismodell bewältigt allgemeine visuell-sprachliche Aufgaben; die „Instruct“-Version ist darauf optimiert, Benutzeranweisungen genauer zu befolgen.
Novita AI ist eine KI-Cloud-Plattform, die Entwicklern eine einfache Möglichkeit bietet, KI-Modelle über unsere unkomplizierte API bereitzustellen, und gleichzeitig eine erschwingliche und zuverlässige GPU-Cloud zum Erstellen und Skalieren bereitstellt.
Empfohlene Lektüre
- Qwen2.5-VL: Leistungsstarkes, aber RAM-hungriges Vision-Language-Modell
- Qwen 2.5 72b vs. Llama 3.3 70b: Welches Modell passt zu deinen Anforderungen?
- Qwen 2.5 vs. Llama 3.2 90B: Eine vergleichende Analyse der Code- und Bilddenkfähigkeiten
Einfache APIs und skalierbare GPUs
Novita AI ist eine KI-Cloud-Plattform, die Entwicklern eine einfache Möglichkeit bietet, KI-Modelle über unsere unkomplizierte API bereitzustellen, und gleichzeitig eine erschwingliche und zuverlässige GPU-Cloud zum Erstellen und Skalieren bereitstellt.
