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

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

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

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

```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 toujours en cours de téléchargement depuis HuggingFace.
{% endhint %}

## Mode de raisonnement Qwen3

{% hint style="info" %}
**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.
{% endhint %}

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

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

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

{% 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 %}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# 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

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

```yaml
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*](https://clore.ai/marketplace) *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

```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 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
# S'assurer de 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 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](/guides/guides_v2-fr/modeles-de-langage/vllm.md) - Déploiement en production
* [Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) - Configuration 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
* [Ajustement fin de 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/qwen25.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.