# 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](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/vllm) - Déploiement en production
* [composant Ollama](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/ollama) - Installation locale facile
* [DeepSeek-V3](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/deepseek-v3) - Modèle de raisonnement plus grand
* [DeepSeek-R1](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/deepseek-r1) - Modèle de raisonnement open-source
* [Affiner un LLM](https://docs.clore.ai/guides/guides_v2-fr/entrainement/finetune-llm) - Entraînement personnalisé