# Qwen3 - Comment exécuter et fine-tuner
Les nouveaux modèles Qwen3 de Qwen offrent des avancées de pointe en raisonnement, suivi d’instructions, capacités agentiques et prise en charge multilingue.
{% hint style="success" %}
**NOUVEAU !** Qwen3 a reçu une mise à jour en juillet 2025. Exécutez et affinez le dernier modèle : [**Qwen-2507**](https://unsloth.ai/docs/fr/modeles/tutorials/qwen3-next)
{% endhint %}
Tous les téléversements utilisent Unsloth [Dynamic 2.0](https://unsloth.ai/docs/fr/bases/unsloth-dynamic-2.0-ggufs) pour des performances SOTA en MMLU 5-shot et en divergence KL, ce qui signifie que vous pouvez exécuter et affiner des LLM Qwen quantifiés avec une perte de précision minimale.
Nous avons également téléversé Qwen3 avec une longueur de contexte native de 128K. Qwen y parvient en utilisant YaRN pour étendre sa fenêtre d’origine de 40K à 128K.
[Unsloth](https://github.com/unslothai/unsloth) prend désormais aussi en charge le fine-tuning et [Apprentissage par renforcement (RL)](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide) des modèles Qwen3 et Qwen3 MOE — 2x plus rapide, avec 70 % de VRAM en moins et des longueurs de contexte 8x plus longues. Affinez Qwen3 (14B) gratuitement en utilisant notre [notebook Colab.](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(14B\)-Reasoning-Conversational.ipynb)
Tutoriel pour exécuter Qwen3Fine-tuning de Qwen3
#### **Qwen3 - Unsloth Dynamic 2.0** avec des configurations optimales :
| Dynamic 2.0 GGUF (pour exécuter) | GGUF contexte 128K | Safetensor dynamique 4 bits (pour fine-tuner/déployer) |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
## 🖥️ **Exécuter Qwen3**
Pour atteindre des vitesses d’inférence de 6 tokens par seconde ou plus, nous recommandons que la mémoire disponible corresponde au moins à la taille du modèle que vous utilisez, ou la dépasse. Par exemple, un modèle quantifié en 1 bit de 30 Go nécessite au moins 150 Go de mémoire. La quantification Q2\_K\_XL, qui fait 180 Go, nécessitera au moins **180 Go de mémoire unifiée** (VRAM + RAM) ou **180 Go de RAM** pour des performances optimales.
**REMARQUE :** Il est possible d’exécuter le modèle avec **moins de mémoire totale** que sa taille (c.-à-d. moins de VRAM, moins de RAM, ou un total combiné inférieur). Cependant, cela entraînera des vitesses d’inférence plus lentes. Une mémoire suffisante n’est nécessaire que si vous souhaitez maximiser le débit et obtenir les temps d’inférence les plus rapides.
### :gear: Paramètres officiels recommandés
Selon Qwen, voici les paramètres recommandés pour l’inférence :
| Paramètres du mode non-réflexion : | Paramètres du mode réflexion : |
| ----------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
| **Température = 0.7** | **Température = 0.6** |
| Min\_P = 0.0 (facultatif, mais 0.01 fonctionne bien, la valeur par défaut de llama.cpp est 0.1) | Min\_P = 0.0 |
| Top\_P = 0.8 | Top\_P = 0.95 |
| TopK = 20 | TopK = 20 |
**Modèle de chat/format de prompt :**
{% code overflow="wrap" %}
```
<|im_start|>user\nQue vaut 2+2 ?<|im_end|>\n<|im_start|>assistant\n
```
{% endcode %}
{% hint style="success" %}
Pour le mode NON-réflexion, nous encadrons volontairement \ et \ avec rien :
{% endhint %}
{% code overflow="wrap" %}
```
<|im_start|>user\nQue vaut 2+2 ?<|im_end|>\n<|im_start|>assistant\n\n\n\n\n
```
{% endcode %}
{% hint style="warning" %}
**Pour le mode réflexion, N’UTILISEZ PAS le décodage gourmand**, car cela peut entraîner une dégradation des performances et des répétitions sans fin.
{% endhint %}
### Passer du mode réflexion au mode non-réflexion
Les modèles Qwen3 intègrent un « mode réflexion » pour améliorer le raisonnement et la qualité des réponses - similaire à la façon dont [QwQ-32B](https://unsloth.ai/docs/fr/modeles/tutorials/qwq-32b-how-to-run-effectively) fonctionnait. Les instructions de bascule différeront selon le moteur d’inférence utilisé, assurez-vous donc d’employer les bonnes instructions.
#### Instructions pour llama.cpp et Ollama :
Vous pouvez ajouter `/think` et `/no_think` aux prompts utilisateur ou aux messages système pour changer le mode réflexion du modèle d’un tour à l’autre. Le modèle suivra l’instruction la plus récente dans les conversations à plusieurs tours.
Voici un exemple de conversation à plusieurs tours :
```
> Qui es-tu /no_think
Je suis Qwen, un modèle de langage à grande échelle développé par Alibaba Cloud. [...]
> Combien y a-t-il de « r » dans « strawberries » ? /think
D’accord, voyons voir. L’utilisateur demande combien de fois la lettre « r » apparaît dans le mot « strawberries ». [...]
Le mot strawberries contient 3 occurrences de la lettre r. [...]
```
#### Instructions pour transformers et vLLM :
**Mode réflexion :**
`enable_thinking=True`
Par défaut, la réflexion est activée dans Qwen3. Lorsque vous appelez `tokenizer.apply_chat_template`, vous **n’avez rien à définir manuellement.**
```python
text = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True,
enable_thinking=True # La valeur par défaut est True
)
```
En mode réflexion, le modèle générera un bloc supplémentaire `...` avant la réponse finale — cela lui permet de « planifier » et d’affiner ses réponses.
**Mode non-réflexion :**
`enable_thinking=False`
Activer le mode non-réflexion fera en sorte que Qwen3 ignore toutes les étapes de réflexion et se comporte comme un LLM normal.
```python
text = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True,
enable_thinking=False # Désactive le mode réflexion
)
```
Ce mode fournira directement les réponses finales — aucun `` bloc, aucune chaîne de pensée.
### 🦙 Ollama : Tutoriel pour exécuter Qwen3
1. Installer `ollama` si ce n’est pas déjà fait ! Vous ne pouvez exécuter que des modèles jusqu’à 32B. Pour exécuter le modèle complet 235B-A22B, [voir ici](#running-qwen3-235b-a22b).
```bash
apt-get update
apt-get install pciutils -y
curl -fsSL https://ollama.com/install.sh | sh
```
2. Exécutez le modèle ! Notez que vous pouvez appeler `ollama serve`dans un autre terminal si cela échoue ! Nous incluons tous nos correctifs et paramètres suggérés (température, etc.) dans `params` dans notre téléversement Hugging Face !
```bash
ollama run hf.co/unsloth/Qwen3-8B-GGUF:UD-Q4_K_XL
```
3. Pour désactiver la réflexion, utilisez (ou vous pouvez le définir dans le prompt système) :
```
>>> Écrivez votre prompt ici /nothink
```
{% hint style="warning" %}
Si vous observez des boucles, Ollama a peut-être défini la fenêtre de longueur de contexte à 2 048 environ. Si c’est le cas, augmentez-la à 32 000 et voyez si le problème persiste.
{% endhint %}
### 📖 Llama.cpp : Tutoriel pour exécuter Qwen3
1. Obtenez la dernière version `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). Vous pouvez aussi suivre les instructions de compilation ci-dessous. Remplacez `-DGGML_CUDA=ON` à `-DGGML_CUDA=OFF` si vous n’avez pas de GPU ou si vous souhaitez simplement une inférence CPU. **Pour les appareils Apple Mac / Metal**, définissez `-DGGML_CUDA=OFF` puis continuez comme d’habitude - la prise en charge Metal est activée par défaut.
```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
-DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```
2. Téléchargez le modèle via (après avoir installé `pip install huggingface_hub hf_transfer` ). Vous pouvez choisir Q4\_K\_M, ou d’autres versions quantifiées.
```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
from huggingface_hub import snapshot_download
snapshot_download(
repo_id = "unsloth/Qwen3-14B-GGUF",
local_dir = "unsloth/Qwen3-14B-GGUF",
allow_patterns = ["*UD-Q4_K_XL*"],
)
```
3. Exécutez le modèle et essayez n’importe quel prompt.
```bash
./llama.cpp/llama-cli \
--model unsloth/Qwen3-14B-GGUF/Qwen3-14B-UD-Q2_K_XL.gguf \
--ctx-size 16384 \
--n-gpu-layers 99 \
-ot ".ffn_.*_exps.=CPU" \
--seed 3407 \
--prio 3 \
--temp 0.6 \
--min-p 0.0 \
--top-p 0.95 \
--top-k 20 \
-no-cnv
```
Pour désactiver la réflexion, utilisez (ou vous pouvez le définir dans le prompt système) :
```
>>> Écrivez votre prompt ici /nothink
```
### Exécution de Qwen3-235B-A22B
Pour Qwen3-235B-A22B, nous utiliserons spécifiquement Llama.cpp pour une inférence optimisée et une multitude d’options.
1. Nous suivons des étapes similaires à celles ci-dessus, mais cette fois il faudra aussi effectuer des étapes supplémentaires, car le modèle est si volumineux.
2. Téléchargez le modèle via (après avoir installé `pip install huggingface_hub hf_transfer` ). Vous pouvez choisir UD-Q2\_K\_XL, ou d’autres versions quantifiées..
```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
from huggingface_hub import snapshot_download
snapshot_download(
repo_id = "unsloth/Qwen3-235B-A22B-GGUF",
local_dir = "unsloth/Qwen3-235B-A22B-GGUF",
allow_patterns = ["*UD-Q2_K_XL*"],
)
```
3. Exécutez le modèle et essayez n’importe quel prompt.
4. Modifier `--threads 32` pour le nombre de threads CPU, `--ctx-size 16384` pour la longueur de contexte, `--n-gpu-layers 99` pour l’offloading GPU, selon le nombre de couches. Essayez de l’ajuster si votre GPU manque de mémoire. Supprimez-le également si vous n’avez qu’une inférence CPU.
{% hint style="success" %}
Utilisez `-ot ".ffn_.*_exps.=CPU"` pour décharger toutes les couches MoE vers le CPU ! Cela permet en pratique de faire tenir toutes les couches non MoE sur 1 GPU, améliorant ainsi les vitesses de génération. Vous pouvez personnaliser l’expression regex pour faire tenir davantage de couches si vous avez plus de capacité GPU.
{% endhint %}
{% code overflow="wrap" %}
```bash
./llama.cpp/llama-cli \
--model unsloth/Qwen3-235B-A22B-GGUF/Qwen3-235B-A22B-UD-Q2_K_XL.gguf \
--ctx-size 16384 \
--n-gpu-layers 99 \
-ot ".ffn_.*_exps.=CPU" \
--seed 3407 \
--prio 3 \
--temp 0.6 \
--min-p 0.0 \
--top-p 0.95 \
--top-k 20 \
-no-cnv \
--prompt "<|im_start|>user\nCréez un jeu Flappy Bird en Python. Vous devez inclure ces éléments :\n1. Vous devez utiliser pygame.\n2. La couleur de fond doit être choisie aléatoirement et être une teinte claire. Commencez avec une couleur bleu clair.\n3. Appuyer plusieurs fois sur ESPACE accélérera l’oiseau.\n4. La forme de l’oiseau doit être choisie aléatoirement parmi un carré, un cercle ou un triangle. La couleur doit être choisie aléatoirement parmi des couleurs sombres.\n5. Placez en bas un sol coloré en marron foncé ou en jaune, choisi aléatoirement.\n6. Affichez un score en haut à droite. Incrémentez-le si vous passez les tuyaux sans les toucher.\n7. Créez des tuyaux espacés aléatoirement avec suffisamment d’espace. Coloriez-les aléatoirement en vert foncé, marron clair ou gris foncé.\n8. Quand vous perdez, affichez le meilleur score. Mettez le texte à l’intérieur de l’écran. Appuyer sur q ou Échap quittera le jeu. Redémarrer se fait en appuyant à nouveau sur ESPACE.\nLe jeu final doit se trouver dans une section Markdown en Python. Vérifiez votre code pour détecter les erreurs et corrigez-les avant la section Markdown finale.<|im_end|>\n<|im_start|>assistant\n"
```
{% endcode %}
## 🦥 Fine-tuning de Qwen3 avec Unsloth
Unsloth rend le fine-tuning de Qwen3 2x plus rapide, utilise 70 % de VRAM en moins et prend en charge des longueurs de contexte 8x plus longues. Qwen3 (14B) tient confortablement dans un GPU Tesla T4 de 16 Go de VRAM sur Google Colab.
Comme Qwen3 prend en charge à la fois le raisonnement et le non-raisonnement, vous pouvez l’affiner avec un jeu de données non-réflexif, mais cela peut affecter ses capacités de raisonnement. Si vous souhaitez conserver ses capacités de raisonnement (facultatif), vous pouvez utiliser un mélange de réponses directes et d’exemples de chaîne de pensée. Utilisez 75 % de raisonnement et 25 % de non-raisonnement dans votre jeu de données pour que le modèle conserve ses capacités de raisonnement.
Notre notebook conversationnel utilise une combinaison de 75 % du jeu de données open-math-reasoning de NVIDIA et de 25 % du jeu de données FineTome de Maxime (non-réflexif). Voici des notebooks Colab Unsloth gratuits pour affiner Qwen3 :
* [Notebook Qwen3 (14B) Raisonnement + Conversation](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(14B\)-Reasoning-Conversational.ipynb) (recommandé)
* [**Qwen3 (4B)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(4B\)-GRPO.ipynb) **- LoRA GRPO avancé**
* [Notebook Qwen3 (14B) Alpaca](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(14B\)-Alpaca.ipynb) (pour les modèles de base)
Si vous avez une ancienne version d’Unsloth et/ou que vous effectuez le fine-tuning localement, installez la dernière version d’Unsloth :
```
pip install --upgrade --force-reinstall --no-cache-dir unsloth unsloth_zoo
```
### Fine-tuning des modèles Qwen3 MOE
La prise en charge du fine-tuning inclut notre nouvelle mise à jour 2026 [Faster MOE ](https://unsloth.ai/docs/fr/bases/faster-moe): 30B-A3B et 235B-A22B. Qwen3-30B-A3B fonctionne avec seulement 17.5 Go de VRAM avec Unsloth. Lors du fine-tuning des MoE, ce n’est probablement pas une bonne idée d’entraîner la couche routeur, donc nous l’avons désactivée par défaut.
Le 30B-A3B tient dans 17.5 Go de VRAM, mais vous pouvez manquer de RAM ou d’espace disque, car le modèle 16 bits complet doit être téléchargé et converti à la volée en 4 bits pour le fine-tuning QLoRA. Cela est dû à des problèmes d’importation directe des modèles MOE BnB 4 bits. Cela n’affecte que les modèles MOE.
```python
from unsloth import FastModel
import torch
model, tokenizer = FastModel.from_pretrained(
model_name = "unsloth/Qwen3-30B-A3B",
max_seq_length = 2048, # Choisissez n’importe quelle valeur pour un long contexte !
load_in_4bit = True, # Quantification 4 bits pour réduire la mémoire
load_in_8bit = False, # [NOUVEAU !] Un peu plus précis, utilise 2x plus de mémoire
full_finetuning = False, # [NOUVEAU !] Nous avons maintenant le full finetuning !
# token = "hf_...", # utilisez-en un si vous utilisez des modèles protégés
)
```
### Guide du notebook :
Pour utiliser les notebooks, cliquez simplement sur Runtime, puis sur Run all. Vous pouvez modifier les paramètres du notebook selon vos besoins. Nous les avons définis automatiquement par défaut. Changez le nom du modèle comme vous le souhaitez en l’associant au nom du modèle sur Hugging Face, par exemple 'unsloth/Qwen3-8B' ou 'unsloth/Qwen3-0.6B-unsloth-bnb-4bit'.
Il existe d’autres paramètres que vous pouvez activer ou désactiver :
* **`max_seq_length = 2048`** – Contrôle la longueur du contexte. Bien que Qwen3 prenne en charge 40960, nous recommandons 2048 pour les tests. Unsloth permet un fine-tuning avec un contexte 8× plus long.
* **`load_in_4bit = True`** – Active la quantification 4 bits, réduisant l’utilisation de mémoire de 4× pour le fine-tuning sur des GPU de 16 Go.
* Pour **full-finetuning** - définissez `full_finetuning = True` et **fine-tuning 8 bits** - définissez `load_in_8bit = True`
Si vous souhaitez lire un guide complet de bout en bout sur l’utilisation des notebooks Unsloth pour le fine-tuning ou simplement en apprendre davantage sur le fine-tuning, la création [de jeux de données](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/datasets-guide) etc., consultez notre [guide complet ici](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide):
{% content-ref url="../../commencer/fine-tuning-llms-guide" %}
[fine-tuning-llms-guide](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide)
{% endcontent-ref %}
{% content-ref url="../../commencer/fine-tuning-llms-guide/datasets-guide" %}
[datasets-guide](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/datasets-guide)
{% endcontent-ref %}
### GRPO avec Qwen3
Nous avons créé un nouveau notebook GRPO avancé pour le fine-tuning de Qwen3. Apprenez à utiliser notre nouvelle fonction de récompense basée sur la proximité (réponses plus proches = récompensées) et le jeu de données mathématique Open-R1 de Hugging Face.\nUnsloth dispose désormais aussi de meilleures évaluations et utilise la dernière version de vLLM.
[**Qwen3 (4B)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(4B\)-GRPO.ipynb) **notebook - GRPO LoRA avancé**
Apprenez à propos de :
* Activation du raisonnement dans Qwen3 (Base) + guidage pour effectuer une tâche spécifique
* Pré-fine-tuning pour contourner la tendance de GRPO à apprendre le formatage
* Précision d’évaluation améliorée grâce à une nouvelle correspondance par expressions régulières
* Modèles GRPO personnalisés au-delà de simplement « think », par ex. \\
* Évaluation basée sur la proximité : les meilleures réponses gagnent plus de points (par ex., prédire 9 lorsque la réponse est 10) et les valeurs aberrantes sont pénalisées
---
# Agent Instructions: 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://unsloth.ai/docs/fr/modeles/tutorials/qwen3-how-to-run-and-fine-tune.md?ask=
```
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.
