> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-vision/qwen-vl.md).

# 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](https://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

{% hint style="warning" %}
**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](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement.
{% endhint %}

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

```bash
# 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

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

```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": "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

```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": "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

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

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-vision/qwen-vl.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.