Modèle vision-langage Qwen2.5-VL

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

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

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

Principales caractéristiques

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

• Trois tailles — 3B (edge/mobile), 7B (point idéal pour la production), 72B (qualité SOTA).

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

• Compréhension vidéo — accepte des vidéos multi-images avec raisonnement temporel.

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

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

• Support Ollama — exécutez localement avec ollama run qwen2.5vl:7b pour un déploiement sans code.

• Intégration Transformers — Qwen2_5_VLForConditionalGeneration dans HuggingFace transformers.

Exigences

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.1+	12.1+	12.1+

Recommandation GPU Clore.ai : Pour le modèle 7B, un RTX 4090 (24 Go, ~0,5–2 $/jour) ou RTX 3090 (24 Go, ~0,3–1 $/jour) 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 (la 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 : /chemin/vers/photo.jpg

Option B : Python / Transformers

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124
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": "Quelle est l'espèce de cet insecte ? Décrivez ses principales caractéristiques distinctives."},
        ],
    }
]

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. Énumérez 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": "Extrait tous les articles, quantités et prix de ce reçu. Retourner au format JSON."},
        ],
    }
]

# Traiter en utilisant la même configuration modèle/processor 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 le chemin le plus rapide vers un VLM opérationnel. Aucun code Python requis pour une utilisation interactive.

2. 7B est le point idéal — la variante 7B Instruct tient dans 16 Go de VRAM avec quantification 4 bits et offre une qualité concurrente de modèles beaucoup plus grands.

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

4. Paramètre fps vidéo — pour l'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 ~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 « Retourner au format JSON » et vous obtiendrez une sortie analysable la plupart du temps.

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 a l'air le plus premium ? »).

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

Dépannage

Problème	Corriger
OutOfMemoryError avec 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 le bon tag
Traitement vidéo lent	Réduire 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 basse 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 la quantification AWQ
Chemin de l'image introuvable	Pour les fichiers locaux dans les messages, utilisez file:///chemin/absolu format
Chinois dans la sortie lors d'un prompt en anglais	Ajoutez « Répondez uniquement en anglais. » à votre prompt