> 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-langage/qwen25.md).

# Qwen2.5

Exécutez la famille de modèles Qwen2.5 d'Alibaba - de puissants LLM multilingues avec d'excellentes capacités en code et en mathématiques sur les GPU CLORE.AI.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Pourquoi Qwen2.5 ?

* **Tailles polyvalentes** - 0,5B à 72B paramètres
* **Multilingue** - 29 langues dont le chinois
* **Contexte long** - Jusqu'à 128K tokens
* **Variantes spécialisées** - Éditions Coder, Math
* **Open source** - Licence Apache 2.0

## Déploiement rapide sur CLORE.AI

**Image Docker :**

```
vllm/vllm-openai:latest
```

**Ports :**

```
22/tcp
8000/http
```

**Commande :**

```bash
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --host 0.0.0.0 \
    --port 8000
```

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://VOTRE_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

### Vérifiez que cela fonctionne

```bash
# Vérifier si le service est prêt
curl https://your-http-pub.clorecloud.net/health

# Lister les modèles disponibles
curl https://your-http-pub.clorecloud.net/v1/models
```

{% hint style="warning" %}
Si vous obtenez HTTP 502, attendez 5-15 minutes - le modèle est encore en cours de téléchargement depuis HuggingFace.
{% endhint %}

## Mode de raisonnement Qwen3

{% hint style="info" %}
**Nouveau dans Qwen3 :** Certains modèles Qwen3 prennent en charge un mode de raisonnement qui montre le processus de réflexion du modèle dans `<think>` des balises avant la réponse finale.
{% endhint %}

Lors de l'utilisation des modèles Qwen3 via vLLM, les réponses peuvent inclure le raisonnement :

```json
{
  "content": "<think>\nLaissez-moi réfléchir étape par étape...\n</think>\n\nLa réponse est..."
}
```

Pour utiliser Qwen3 avec raisonnement :

```bash
vllm serve Qwen/Qwen3-0.6B --host 0.0.0.0 --port 8000
```

## Variantes de modèle

### Modèles de base

| Modèle               | Paramètres | VRAM (FP16) | Contexte | Remarques                     |
| -------------------- | ---------- | ----------- | -------- | ----------------------------- |
| Qwen2.5-0.5B         | 0,5B       | 2Go         | 32K      | Edge/test                     |
| Qwen2.5-1.5B         | 1,5B       | 4 Go        | 32K      | Très léger                    |
| Qwen2.5-3B           | 3B         | 8 Go        | 32K      | Économique                    |
| Qwen2.5-7B           | 7B         | 16Go        | 128K     | Équilibré                     |
| Qwen2.5-14B          | 14B        | 32Go        | 128K     | Haute qualité                 |
| Qwen2.5-32B          | 32B        | 70Go        | 128K     | Très haute qualité            |
| Qwen2.5-72B          | 72B        | 150Go       | 128K     | **Meilleure qualité**         |
| Qwen2.5-72B-Instruct | 72B        | 150Go       | 128K     | Ajusté pour chat/instructions |

### Variantes spécialisées

| Modèle                     | Concentration | Idéal pour                        | VRAM (FP16) |
| -------------------------- | ------------- | --------------------------------- | ----------- |
| Qwen2.5-Coder-7B-Instruct  | Code          | Programmation, débogage           | 16Go        |
| Qwen2.5-Coder-14B-Instruct | Code          | Tâches de code complexes          | 32Go        |
| Qwen2.5-Coder-32B-Instruct | Code          | **Meilleur modèle pour le code**  | 70Go        |
| Qwen2.5-Math-7B-Instruct   | Mathématiques | Calculs, démonstrations           | 16Go        |
| Qwen2.5-Math-72B-Instruct  | Mathématiques | Mathématiques de niveau recherche | 150Go       |
| Qwen2.5-Instruct           | Chat          | Assistant général                 | varie       |

## Exigences matérielles

| Modèle    | GPU minimum   | Recommandé   | VRAM (Q4) |
| --------- | ------------- | ------------ | --------- |
| 0,5B-3B   | RTX 3060 12GB | RTX 3080     | 2-6Go     |
| 7B        | RTX 3090 24GB | RTX 4090     | 6 Go      |
| 14B       | A100 40GB     | A100 80GB    | 12Go      |
| 32B       | A100 80GB     | 2x A100 40Go | 22Go      |
| 72B       | 2x A100 80Go  | 4x A100 80GB | 48Go      |
| Coder-32B | A100 80GB     | 2x A100 40Go | 22Go      |

## Installation

### Utilisation de vLLM (recommandé)

```bash
pip install vllm==0.7.3

python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --host 0.0.0.0 \
    --port 8000
```

### Utilisation d'Ollama

```bash
# Modèles standard
ollama pull qwen2.5:7b
ollama pull qwen2.5:14b
ollama pull qwen2.5:32b
ollama pull qwen2.5:72b       # Nouveau : plus grand Qwen2.5

# Spécialisés
ollama pull qwen2.5-coder:7b
ollama pull qwen2.5-coder:32b  # Nouveau : meilleur modèle pour le code

# Lancer le chat
ollama run qwen2.5:7b
```

### Utilisation de Transformers

```python
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "Qwen/Qwen2.5-7B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

messages = [{"role": "user", "content": "Bonjour !"}]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer([text], return_tensors="pt").to(model.device)

outputs = model.generate(**inputs, max_new_tokens=512)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

## Utilisation de l'API

### API compatible OpenAI

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="non-nécessaire"
)

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant serviable."},
        {"role": "user", "content": "Expliquez l'apprentissage automatique en termes simples."}
    ],
    temperature=0.7,
    max_tokens=500
)

print(response.choices[0].message.content)
```

### Streaming

```python
stream = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "Écris un poème sur l'IA"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
```

### cURL

```bash
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "Qwen/Qwen2.5-7B-Instruct",
        "messages": [
            {"role": "user", "content": "What is Python?"}
        ]
    }'
```

## Qwen2.5-72B-Instruct

Le modèle phare Qwen2.5 — le plus grand et le plus performant de la famille. Il rivalise avec GPT-4 sur de nombreux benchmarks et est entièrement open-source sous licence Apache 2.0.

### Exécution via vLLM (Multi-GPU)

```bash
# Configuration 4x A100 80GB
vllm serve Qwen/Qwen2.5-72B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 4 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.9

# Quantifié AWQ — fonctionne sur 2x A100 80GB
vllm serve Qwen/Qwen2.5-72B-Instruct-AWQ \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2 \
    --quantization awq \
    --max-model-len 32768
```

### Exécution via Ollama

```bash
# Récupérer le modèle 72B (nécessite 48GB+ VRAM pour Q4)
ollama pull qwen2.5:72b

# Lancer une session interactive
ollama run qwen2.5:72b

# Accès API
curl http://localhost:11434/api/chat -d '{
  "model": "qwen2.5:72b",
  "messages": [{"role": "user", "content": "Analysez ce scénario complexe..."}],
  "stream": false
}'
```

### Exemple Python

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

# Le modèle 72B excelle dans les tâches analytiques complexes
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-72B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Vous êtes un analyste expert. Fournissez des réponses détaillées et nuancées."
        },
        {
            "role": "user",
            "content": """Comparez les différences architecturales entre le transformer et 
            les modèles d'espace d'état (SSM) pour la modélisation de séquences. Incluez les compromis d'efficacité."""
        }
    ],
    temperature=0.7,
    max_tokens=2000
)

print(response.choices[0].message.content)
```

## Qwen2.5-Coder-32B-Instruct

Le meilleur modèle open-source pour le code disponible. Qwen2.5-Coder-32B-Instruct égalise ou dépasse GPT-4o sur de nombreux benchmarks de codage, prenant en charge plus de 40 langages de programmation.

### Exécution via vLLM

```bash
# A100 80GB unique
vllm serve Qwen/Qwen2.5-Coder-32B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --max-model-len 16384 \
    --gpu-memory-utilization 0.9

# Double RTX 4090 (24GB chacun = 48GB au total, en utilisant la quantification Q4)
vllm serve Qwen/Qwen2.5-Coder-32B-Instruct-AWQ \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2 \
    --quantization awq
```

### Exécution via Ollama

```bash
# Récupérer Coder-32B (nécessite ~22GB VRAM pour Q4)
ollama pull qwen2.5-coder:32b

# Exécuter
ollama run qwen2.5-coder:32b

# Tester avec une invite de codage
ollama run qwen2.5-coder:32b "Écrivez un scrapeur web Python asynchrone utilisant aiohttp"
```

### Exemples de génération de code

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

# Génération de code full-stack
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-32B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Vous êtes un ingénieur logiciel expert. Écrivez du code propre, prêt pour la production avec une gestion d'erreurs appropriée et une documentation."
        },
        {
            "role": "user",
            "content": """Écrivez un service Python FastAPI qui :
1. Accepte POST /summarize avec un corps JSON {"text": "...", "max_length": 150}
2. Utilise une instance locale Ollama pour résumer le texte
3. Retourne {"summary": "...", "original_length": N, "summary_length": N}
4. Inclut une gestion d'erreurs adéquate, la validation des entrées avec Pydantic, et le support async"""
        }
    ],
    temperature=0.1,  # Faible température pour le code
    max_tokens=3000
)

print(response.choices[0].message.content)
```

````python
# Revue de code et débogage
code_to_review = """
def find_duplicates(lst):
    seen = []
    duplicates = []
    for item in lst:
        if item in seen:
            duplicates.append(item)
        seen.append(item)
    return duplicates
"""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-32B-Instruct",
    messages=[
        {
            "role": "user",
            "content": f"Examinez ce code Python pour des problèmes de performance et suggérez des améliorations:\n\n```python\n{code_to_review}\n```"
        }
    ],
    temperature=0.3
)

print(response.choices[0].message.content)
````

## Qwen2.5-Coder

Optimisé pour la génération de code :

```bash
# Utilisation de vLLM
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Coder-7B-Instruct \
    --host 0.0.0.0

# Utilisation d'Ollama
ollama run qwen2.5-coder:7b
```

```python
prompt = """Écrivez une fonction Python qui :
1. Prend une liste de nombres
2. Renvoie la valeur médiane
3. Gère les listes vides de manière élégante
Inclure des annotations de type et des docstrings."""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-7B-Instruct",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.2
)

print(response.choices[0].message.content)
```

## Qwen2.5-Math

Spécialisé pour le raisonnement mathématique :

```bash
# Utilisation de vLLM
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Math-7B-Instruct \
    --host 0.0.0.0
```

```python
prompt = """Résoudre étape par étape :
Trouvez toutes les valeurs de x telles que : x^3 - 6x^2 + 11x - 6 = 0"""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Math-7B-Instruct",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1
)

print(response.choices[0].message.content)
```

## Support multilingue

Qwen2.5 prend en charge 29 langues :

```python
# Chinese
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "Expliquez en chinois ce qu'est l'intelligence artificielle"}]
)

# Japonais
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "Veuillez expliquer l'intelligence artificielle en japonais"}]
)

# Coréen
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "Veuillez expliquer l'intelligence artificielle en coréen"}]
)
```

## Contexte long (128K)

```python
# Lire un long document
with open("long_document.txt", "r") as f:
    document = f.read()

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "user", "content": f"Résumez ce document:\n\n{document}"}
    ],
    max_tokens=2000
)
```

## Quantification

### GGUF avec Ollama

```bash
# Quantifié 4-bit
ollama pull qwen2.5:7b-instruct-q4_K_M
ollama pull qwen2.5:72b-instruct-q4_K_M   # 72B en 4-bit (~48GB)

# Quantifié en 8 bits
ollama pull qwen2.5:7b-instruct-q8_0

# Variantes Coder
ollama pull qwen2.5-coder:32b-instruct-q4_K_M
```

### AWQ avec vLLM

```bash
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-72B-Instruct-AWQ \
    --quantization awq \
    --tensor-parallel-size 2
```

### GGUF avec llama.cpp

```bash
# Télécharger GGUF
wget https://huggingface.co/Qwen/Qwen2.5-7B-Instruct-GGUF/resolve/main/qwen2.5-7b-instruct-q4_k_m.gguf

# Démarrer le serveur
./llama-server -m qwen2.5-7b-instruct-q4_k_m.gguf \
    --host 0.0.0.0 \
    --port 8080 \
    -ngl 35
```

## Configuration Multi-GPU

### Parallélisme tensoriel

```bash
# 72B sur 4 GPU
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-72B-Instruct \
    --tensor-parallel-size 4 \
    --max-model-len 32768

# 32B sur 2 GPU
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-32B-Instruct \
    --tensor-parallel-size 2

# Coder-32B sur 2 GPU
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Coder-32B-Instruct \
    --tensor-parallel-size 2 \
    --max-model-len 16384
```

## Performances

### Débit (tokens/sec)

| Modèle            | RTX 3090 | RTX 4090 | A100 40GB | A100 80GB |
| ----------------- | -------- | -------- | --------- | --------- |
| Qwen2.5-0.5B      | 250      | 320      | 380       | 400       |
| Qwen2.5-3B        | 150      | 200      | 250       | 280       |
| Qwen2.5-7B        | 75       | 100      | 130       | 150       |
| Qwen2.5-7B Q4     | 110      | 140      | 180       | 200       |
| Qwen2.5-14B       | -        | 55       | 70        | 85        |
| Qwen2.5-32B       | -        | -        | 35        | 50        |
| Qwen2.5-72B       | -        | -        | 20 (2x)   | 40 (2x)   |
| Qwen2.5-72B Q4    | -        | -        | -         | 55 (2x)   |
| Qwen2.5-Coder-32B | -        | -        | 32        | 48        |

### Temps jusqu'au premier token (TTFT)

| Modèle | RTX 4090 | A100 40GB  | A100 80GB  |
| ------ | -------- | ---------- | ---------- |
| 7B     | 60ms     | 40ms       | 35ms       |
| 14B    | 120ms    | 80 ms      | 60ms       |
| 32B    | -        | 200ms      | 140ms      |
| 72B    | -        | 400ms (2x) | 280ms (2x) |

### Longueur de contexte vs VRAM (7B)

| Contexte | FP16  | Q8    | Q4    |
| -------- | ----- | ----- | ----- |
| 8K       | 16Go  | 10Go  | 6 Go  |
| 32K      | 24 Go | 16Go  | 10Go  |
| 64K      | 40Go  | 26 Go | 16Go  |
| 128K     | 72Go  | 48Go  | 28 Go |

## Benchmarks

| Modèle            | MMLU  | HumanEval | GSM8K | MATH  | LiveCodeBench |
| ----------------- | ----- | --------- | ----- | ----- | ------------- |
| Qwen2.5-7B        | 74.2% | 75.6%     | 85.4% | 55.2% | 42.1%         |
| Qwen2.5-14B       | 79.7% | 81.1%     | 89.5% | 65.8% | 51.3%         |
| Qwen2.5-32B       | 83.3% | 84.2%     | 91.2% | 72.1% | 60.7%         |
| Qwen2.5-72B       | 86.1% | 86.2%     | 93.2% | 79.5% | 67.4%         |
| Qwen2.5-Coder-7B  | 72.8% | 88.4%     | 86.1% | 58.4% | 64.2%         |
| Qwen2.5-Coder-32B | 83.1% | **92.7%** | 92.3% | 76.8% | **78.5%**     |

## Docker Compose

```yaml
version : '3.8'

services :
  qwen :
    image : vllm/vllm-openai:latest
    ports :
      - "8000:8000"
    volumes :
      - ~/.cache/huggingface:/root/.cache/huggingface
    commande : >
      --model Qwen/Qwen2.5-7B-Instruct
      --host 0.0.0.0
      --port 8000
      --gpu-memory-utilization 0.9
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
```

## Estimation des coûts

Tarifs typiques du marketplace CLORE.AI :

| GPU           | Tarif horaire | Idéal pour             |
| ------------- | ------------- | ---------------------- |
| RTX 3090 24GB | \~$0.06       | modèles 7B             |
| RTX 4090 24GB | \~$0.10       | Modèles 7B-14B         |
| A100 40GB     | \~$0.17       | Modèles 14B-32B        |
| A100 80GB     | \~$0.25       | Modèles 32B, Coder-32B |
| 2x A100 80Go  | \~$0.50       | Modèles 72B            |
| 4x A100 80GB  | \~$1.00       | Contexte max 72B       |

*Les prix varient selon le fournisseur. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez **Spot** marché pour charges de travail flexibles
* Payer avec **CLORE** jetons
* Commencez par des modèles plus petits (7B) pour les tests

## Dépannage

### Mémoire insuffisante

```bash
# Réduire le contexte
--max-model-len 8192

# Activer l'optimisation de la mémoire
--gpu-memory-utilization 0.85

# Utiliser un modèle quantifié
ollama pull qwen2.5:7b-instruct-q4_K_M
```

### Génération lente

```bash
# Activer la flash attention
pip install flash-attn

# Utiliser vLLM pour un meilleur débit
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --enable-prefix-caching
```

### Affichage des caractères chinois

```python
# Assurer l'encodage UTF-8
import sys
sys.stdout.reconfigure(encoding='utf-8')
```

### Modèle introuvable

```bash
# Vérifier le nom du modèle
huggingface-cli search Qwen/Qwen2.5

# Noms courants :
# Qwen/Qwen2.5-7B-Instruct
# Qwen/Qwen2.5-72B-Instruct       ← Nouveau
# Qwen/Qwen2.5-Coder-7B-Instruct
# Qwen/Qwen2.5-Coder-32B-Instruct ← Nouveau
# Qwen/Qwen2.5-Math-7B-Instruct
```

## Qwen2.5 vs autres

| Fonction      | Qwen2.5-7B | Qwen2.5-72B | Llama 3.1 70B | GPT-4o       |
| ------------- | ---------- | ----------- | ------------- | ------------ |
| Contexte      | 128K       | 128K        | 128K          | 128K         |
| Multilingue   | Excellent  | Excellent   | Bon           | Excellent    |
| Code          | Excellent  | Excellent   | Bon           | Excellent    |
| Mathématiques | Excellent  | Excellent   | Bon           | Excellent    |
| Chinois       | Excellent  | Excellent   | Faible        | Bon          |
| Licence       | Apache 2.0 | Apache 2.0  | Llama 3.1     | Propriétaire |
| Coût          | Gratuit    | Gratuit     | Gratuit       | API payante  |

**Utilisez Qwen2.5 lorsque :**

* Un support du chinois est nécessaire
* Les tâches de mathématiques/code sont prioritaires
* Un long contexte est requis
* Vous voulez la licence Apache 2.0
* Besoin du meilleur modèle open-source pour le code (Coder-32B)

## Prochaines étapes

* [vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md) - Déploiement en production
* [composant Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) - Installation locale facile
* [DeepSeek-V3](/guides/guides_v2-fr/modeles-de-langage/deepseek-v3.md) - Modèle de raisonnement plus grand
* [DeepSeek-R1](/guides/guides_v2-fr/modeles-de-langage/deepseek-r1.md) - Modèle de raisonnement open-source
* [Affiner un LLM](/guides/guides_v2-fr/entrainement/finetune-llm.md) - Entraînement personnalisé


---

# 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/qwen25.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.