Qwen2.5

Exécutez les LLM multilingues Qwen2.5 d'Alibaba sur les GPU Clore.ai

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.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Pourquoi Qwen2.5 ?

• Tailles polyvalentes - De 0,5B à 72B de paramètres

• Multilingue - 29 langues, dont le chinois

• Contexte long - Jusqu'à 128K tokens

• Variantes spécialisées - Éditions Coder, Math

• Code source ouvert - Licence Apache 2.0

Déploiement rapide sur CLORE.AI

Image Docker :

vllm/vllm-openai:latest

Ports :

22/tcp
8000/http

Commande :

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. Accédez à Mes commandes la page

2. Cliquez sur votre commande

3. Trouvez le http_pub URL (par ex., abc123.clorecloud.net)

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

Vérifier que cela fonctionne

# 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

Si vous obtenez HTTP 502, attendez 5 à 15 minutes - le modèle est toujours en cours de téléchargement depuis HuggingFace.

Mode de raisonnement Qwen3

Nouveauté dans Qwen3 : Certains modèles Qwen3 prennent en charge un mode de raisonnement qui affiche le processus de pensée du modèle dans <think> des balises avant la réponse finale.

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

{
  "content": "<think>\nLaissez-moi y réfléchir pas à pas...\n</think>\n\nLa réponse est..."
}

Pour utiliser Qwen3 avec le raisonnement :

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	2GB	32K	Périphérie/test
Qwen2.5-1.5B	1,5B	4 Go	32K	Très léger
Qwen2.5-3B	3B	8 Go	32K	Petit budget
Qwen2.5-7B	7B	16 Go	128K	Équilibré
Qwen2.5-14B	14B	32 Go	128K	Haute qualité
Qwen2.5-32B	32B	70GB	128K	Très haute qualité
Qwen2.5-72B	72B	150GB	128K	Meilleure qualité
Qwen2.5-72B-Instruct	72B	150GB	128K	Optimisé pour le chat / les instructions

Variantes spécialisées

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

Configuration matérielle requise

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.

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

Installation

Utilisation de vLLM (recommandé)

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

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

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

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

Utilisation de Transformers

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

from openai import OpenAI

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

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

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

Flux continu

stream = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "Écrivez 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

curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "Qwen/Qwen2.5-7B-Instruct",
        "messages": [
            {"role": "user", "content": "Qu'est-ce que 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)

# Configuration 4x A100 80 Go
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 80 Go
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

# Télécharger le modèle 72B (nécessite plus de 48 Go de VRAM pour Q4)
ollama pull qwen2.5:72b

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

# Accès à l'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

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 d'analyse 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 les transformeurs et 
            les modèles d'espace d'état (SSM) pour la modélisation de séquences. Incluez les compromis en matière d'efficacité."""
        }
    ],
    temperature=0.7,
    max_tokens=2000
)

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

Qwen2.5-Coder-32B-Instruct

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

Exécution via vLLM

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

# Deux RTX 4090 (24 Go chacune = 48 Go au total, avec 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

# Télécharger Coder-32B (nécessite environ 22 Go de 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 scraper Web asynchrone en Python utilisant aiohttp"

Exemples de génération de code

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 un code propre, prêt pour la production, avec une gestion des erreurs appropriée et de la documentation."
        },
        {
            "role": "user",
            "content": """Écrivez un service FastAPI Python qui :
1. Accepte POST /summarize avec un corps JSON {"text": "...", "max_length": 150}
2. Utilise une instance Ollama locale pour résumer le texte
3. Renvoie {"summary": "...", "original_length": N, "summary_length": N}
4. Inclut une gestion appropriée des erreurs, une validation des entrées avec Pydantic et une prise en charge asynchrone"""
        }
    ],
    temperature=0.1,  # Température basse pour le code
    max_tokens=3000
)

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

# Relecture et débogage du code
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"Relisez ce code Python pour détecter les 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 :

# 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

prompt = """Écrivez une fonction Python qui :
1. Prend une liste de nombres
2. Renvoie la valeur médiane
3. Gère gracieusement les listes vides
Incluez 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é dans le raisonnement mathématique :

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

prompt = """Résolvez é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)

Prise en charge multilingue

Qwen2.5 prend en charge 29 langues :

# Chinois
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "用中文解释什么是人工智能"}]
)

# Japonais
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "人工知能について日本語で説明してください"}]
)

# Coréen
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "인공지능에 대해 한국어로 설명해주세요"}]
)

Contexte long (128K)

# 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

# Quantifié en 4 bits
ollama pull qwen2.5:7b-instruct-q4_K_M
ollama pull qwen2.5:72b-instruct-q4_K_M   # 72B en 4 bits (~48 Go)

# 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

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

GGUF avec llama.cpp

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

# Lancer 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 de tenseur

# 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 (jetons/sec)

Modèle	RTX 3090	RTX 4090	A100 40 Go	A100 80 Go
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 jeton (TTFT)

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

Longueur de contexte vs VRAM (7B)

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

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

version: '3.8'

services:
  qwen:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    command: >
      --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 habituels de la place de marché CLORE.AI :

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

Les prix varient selon le fournisseur. Consultez la place de marché CLORE.AI les tarifs actuels.

Économisez de l'argent :

• Utilisez Spot le marché pour les charges de travail flexibles

• Payez avec CLORE jetons

• Commencez avec des modèles plus petits (7B) pour les tests

Dépannage

Mémoire insuffisante

# 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

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

# S'assurer de l'encodage UTF-8
import sys
sys.stdout.reconfigure(encoding='utf-8')

Modèle introuvable

# 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 contre les autres

Fonctionnalité	Qwen2.5-7B	Qwen2.5-72B	Llama 3.1 70B	GPT-4o
Contexte	128K	128K	128K	128K
Multilingue	Excellente	Excellente	Bon	Excellente
Code	Excellente	Excellente	Bon	Excellente
Maths	Excellente	Excellente	Bon	Excellente
Chinois	Excellente	Excellente	Mauvais	Bon
Licence	Apache 2.0	Apache 2.0	Llama 3.1	Propriétaire
Coût	Gratuit	Gratuit	Gratuit	API payante

Utilisez Qwen2.5 lorsque :

• La prise en charge du chinois est nécessaire

• Les tâches de mathématiques/de code sont prioritaires

• Un long contexte est requis

• Vous voulez la licence Apache 2.0

• Vous avez besoin du meilleur modèle de code open source (Coder-32B)

Étapes suivantes

• vLLM - Déploiement en production

• Ollama - Configuration locale facile

• DeepSeek-V3 - Modèle de raisonnement plus grand

• DeepSeek-R1 - Modèle de raisonnement open source

• Ajustement fin de LLM - Entraînement personnalisé