Modèle vision-langage Qwen2.5-VL

Exécutez Qwen2.5-VL, le principal modèle vision-langage open source, pour la compréhension d'images, de vidéos et de documents sur les GPU Clore.ai.

Qwen2.5-VL d’Alibaba (décembre 2024) est le modèle vision-langage à poids ouverts (VLM) le plus performant. Disponible en tailles de paramètres 3B, 7B et 72B, il comprend les images, les images vidéo, les PDF, les graphiques et les mises en page visuelles complexes. La variante 7B atteint le juste milieu — elle surpasse de nombreux modèles plus grands dans les benchmarks tout en fonctionnant confortablement sur un seul GPU de 24 Go.

Sur Clore.ai vous pouvez louer exactement le GPU dont vous avez besoin — d’une RTX 3090 pour le modèle 7B à des configurations multi-GPU pour la variante 72B — et commencer à analyser du contenu visuel en quelques minutes.

Caractéristiques clés

• Entrée multimodale — images, vidéo, PDF, captures d’écran, graphiques et diagrammes dans un seul modèle.

• Trois tailles — 3B (edge/mobile), 7B (juste milieu en production), 72B (qualité SOTA).

• Résolution dynamique — traite les images à leur résolution native ; aucun redimensionnement forcé en 224×224.

• Compréhension vidéo — accepte une entrée vidéo multi-images avec raisonnement temporel.

• OCR de documents — extrait le texte de documents numérisés, de reçus et de notes manuscrites.

• Multilingue — bonnes performances en anglais, en chinois et dans plus de 20 autres langues.

• Prise en charge d’Ollama — exécutez-le localement avec ollama run qwen2.5vl:7b pour un déploiement sans code.

• Intégration à Transformers — Qwen2_5_VLForConditionalGeneration dans HuggingFace transformers.

Exigences

Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai. Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez bare metal sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

Composant	3B	7B	72B
VRAM GPU	8 Go	16–24 Go	80+ Go (multi-GPU)
RAM système	16 Go	32 Go	128 Go
Disque	10 Go	20 Go	150 Go
Python	3.10+	3.10+	3.10+
CUDA	12.8+	12.8+	12.8+

Recommandation de GPU Clore.ai : Pour le modèle 7B, un RTX 4090 (24 Go, 0,14–0,42 $/h) ou RTX 3090 (24 Go, 0,07–0,21 $/h) est idéal. Pour 72B, filtrez la place de marché pour A100 80 Go ou des configurations multi-GPU.

Démarrage rapide

Option A : Ollama (le plus simple)

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

# Télécharger et exécuter le modèle vision 7B
ollama run qwen2.5vl:7b

Puis dans l’invite ollama :

>>> Décrivez cette image : /path/to/photo.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

Exemples d'utilisation

Compréhension d’image avec 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": "De quelle espèce est cet insecte ? Décrivez ses principales caractéristiques d’identification."},
        ],
    }
]

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)

Analyse vidéo

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": "Résumez ce qui se passe dans cette vidéo. Listez les événements clés dans l’ordre."},
        ],
    }
]

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 et extraction de documents

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "file:///workspace/receipt.jpg"},
            {"type": "text", "text": "Extrayez tous les articles, quantités et prix de ce reçu. Renvoyez le tout en JSON."},
        ],
    }
]

# Traiter avec la même configuration modèle/processeur que ci-dessus
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 Ollama pour le traitement par lots

import ollama
import base64
from pathlib import Path

def analyze_image(image_path: str, question: str) -> str:
    """Envoyer une image à Qwen2.5-VL via l’API 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"]

# Traiter par lots un dossier d’images
from pathlib import Path
for img in sorted(Path("./photos").glob("*.jpg")):
    result = analyze_image(str(img), "Décrivez cette image en une phrase.")
    print(f"{img.name}: {result}")

Conseils pour les utilisateurs de Clore.ai

1. Ollama pour un déploiement rapide — ollama run qwen2.5vl:7b est la voie la plus rapide vers un VLM opérationnel. Aucun code Python n’est nécessaire pour une utilisation interactive.

2. Le 7B est le juste milieu — la variante Instruct 7B tient dans 16 Go de VRAM avec une quantification 4 bits et offre une qualité compétitive avec des modèles bien plus grands.

3. La résolution dynamique compte — Qwen2.5-VL traite les images à leur résolution native. Pour les grandes images (>4K), redimensionnez-les à une largeur maximale de 1920 px pour éviter une consommation excessive de VRAM.

4. Réglage des FPS vidéo — pour une entrée vidéo, définissez fps=1.0 pour échantillonner 1 image par seconde. Des valeurs plus élevées consomment rapidement la VRAM ; 1 fps suffit pour la plupart des tâches d’analyse.

5. Stockage persistant — définissez HF_HOME=/workspace/hf_cache; le modèle 7B fait environ 15 Go. Pour ollama, les modèles vont dans ~/.ollama/models/.

6. Sortie structurée — Qwen2.5-VL suit bien les instructions de formatage JSON. Demandez « Renvoyez le tout en JSON » et vous obtiendrez la plupart du temps une sortie analysable.

7. Comparaison multi-images — vous pouvez passer plusieurs images dans un seul message pour des tâches de comparaison (par ex., « Lequel de ces deux produits paraît plus haut de gamme ? »).

8. tmux — exécutez toujours à l’intérieur de tmux sur les locations Clore.ai.

Dépannage

Problème	Correctif
OutOfMemoryError avec le 7B	Utilisez load_in_4bit=True dans from_pretrained() avec bitsandbytes; ou utilisez la variante 3B
Modèle Ollama introuvable	ollama pull qwen2.5vl:7b — assurez-vous d’avoir la bonne balise
Traitement vidéo lent	Réduisez fps à 0,5 et max_pixels à 256 * 256; moins d’images = inférence plus rapide
Sortie brouillée ou vide	Augmentez max_new_tokens; la valeur par défaut peut être trop faible pour des descriptions détaillées
ImportError: qwen_vl_utils	pip install qwen-vl-utils — requis pour process_vision_info()
Le modèle 72B ne tient pas	Utilisez 2× A100 80 Go avec device_map="auto" ou appliquez une quantification AWQ
Chemin d’image introuvable	Pour les fichiers locaux dans les messages, utilisez file:///absolute/path format
Chinois dans la sortie lors d’un prompt en anglais	Ajoutez « Répondez uniquement en anglais. » à votre prompt