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 CLORE.AI Marketplace.

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 :

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:

Aller à la Mes commandes page
Cliquez sur votre commande
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

# 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 encore en cours de téléchargement depuis HuggingFace.

Mode de raisonnement Qwen3

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.

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

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

Pour utiliser Qwen3 avec 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

2Go

32K

Edge/test

Qwen2.5-1.5B

1,5B

4 Go

32K

Très léger

Qwen2.5-3B

8 Go

32K

Économique

Qwen2.5-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

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

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

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="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

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

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)

# 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

# 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

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

# 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

# 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

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)

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

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

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

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 :

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

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

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

# 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

# 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

100

130

150

Qwen2.5-7B Q4

110

140

180

200

Qwen2.5-14B

Qwen2.5-32B

Qwen2.5-72B

20 (2x)

40 (2x)

Qwen2.5-72B Q4

55 (2x)

Qwen2.5-Coder-32B

Temps jusqu'au premier token (TTFT)

Modèle

RTX 4090

A100 40GB

A100 80GB

60ms

40ms

35ms

14B

120ms

80 ms

60ms

32B

200ms

140ms

72B

400ms (2x)

280ms (2x)

Longueur de contexte vs VRAM (7B)

Contexte

FP16

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

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

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

# Assurer 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 vs autres

Fonction

Qwen2.5-7B

Qwen2.5-72B

Llama 3.1 70B

GPT-4o

Contexte

128K

Multilingue

Excellent

Bon

Excellent

Code

Excellent

Bon

Excellent

Mathématiques

Excellent

Bon

Excellent

Chinois

Excellent

Faible

Bon

Licence

Apache 2.0

Llama 3.1

Propriétaire

Coût

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 - Déploiement en production
composant Ollama - Installation locale facile
DeepSeek-V3 - Modèle de raisonnement plus grand
DeepSeek-R1 - Modèle de raisonnement open-source
Affiner un LLM - Entraînement personnalisé

PrécédentModèle de raisonnement DeepSeek-R1 SuivantCodeLlama

Mis à jour il y a 1 jour

Ce contenu vous a-t-il été utile ?

hashtagPourquoi Qwen2.5 ?

hashtagDéploiement rapide sur CLORE.AI

hashtagAccéder à votre service

hashtagVérifiez que cela fonctionne

hashtagMode de raisonnement Qwen3

hashtagVariantes de modèle

hashtagModèles de base

hashtagVariantes spécialisées

hashtagExigences matérielles

hashtagInstallation

hashtagUtilisation de vLLM (recommandé)

hashtagUtilisation d'Ollama

hashtagUtilisation de Transformers

hashtagUtilisation de l'API

hashtagAPI compatible OpenAI

hashtagStreaming

hashtagcURL

hashtagQwen2.5-72B-Instruct

hashtagExécution via vLLM (Multi-GPU)

hashtagExécution via Ollama

hashtagExemple Python

hashtagQwen2.5-Coder-32B-Instruct

hashtagExécution via vLLM

hashtagExécution via Ollama

hashtagExemples de génération de code

hashtagQwen2.5-Coder

hashtagQwen2.5-Math

hashtagSupport multilingue

hashtagContexte long (128K)

hashtagQuantification

hashtagGGUF avec Ollama

hashtagAWQ avec vLLM

hashtagGGUF avec llama.cpp

hashtagConfiguration Multi-GPU

hashtagParallélisme tensoriel

hashtagPerformances

hashtagDébit (tokens/sec)

hashtagTemps jusqu'au premier token (TTFT)

hashtagLongueur de contexte vs VRAM (7B)

hashtagBenchmarks

hashtagDocker Compose

hashtagEstimation des coûts

hashtagDépannage

hashtagMémoire insuffisante

hashtagGénération lente

hashtagAffichage des caractères chinois

hashtagModèle introuvable

hashtagQwen2.5 vs autres

hashtagProchaines étapes

Pourquoi Qwen2.5 ?

Déploiement rapide sur CLORE.AI

Accéder à votre service

Vérifiez que cela fonctionne

Mode de raisonnement Qwen3

Variantes de modèle

Modèles de base

Variantes spécialisées

Exigences matérielles

Installation

Utilisation de vLLM (recommandé)

Utilisation d'Ollama

Utilisation de Transformers

Utilisation de l'API

API compatible OpenAI

Streaming

cURL

Qwen2.5-72B-Instruct

Exécution via vLLM (Multi-GPU)

Exécution via Ollama

Exemple Python

Qwen2.5-Coder-32B-Instruct

Exécution via vLLM

Exécution via Ollama

Exemples de génération de code

Qwen2.5-Coder

Qwen2.5-Math

Support multilingue

Contexte long (128K)

Quantification

GGUF avec Ollama

AWQ avec vLLM

GGUF avec llama.cpp

Configuration Multi-GPU

Parallélisme tensoriel

Performances

Débit (tokens/sec)

Temps jusqu'au premier token (TTFT)

Longueur de contexte vs VRAM (7B)

Benchmarks

Docker Compose

Estimation des coûts

Dépannage

Mémoire insuffisante

Génération lente

Affichage des caractères chinois

Modèle introuvable

Qwen2.5 vs autres

Prochaines étapes