🌠Qwen3 - comment l'exécuter et le fine-tuner

Apprenez à exécuter et fine-tuner Qwen3 localement avec Unsloth + nos quantifications dynamiques 2.0

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.

NOUVEAU ! Qwen3 a reçu une mise à jour en juillet 2025. Exécutez et affinez le dernier modèle : Qwen-2507

Tous les téléversements utilisent Unsloth Dynamic 2.0 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 prend désormais aussi en charge le fine-tuning et Apprentissage par renforcement (RL) 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.

Tutoriel pour exécuter Qwen3 Fine-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)
0.6B 1.7B 4B 8B 14B 30B-A3B 32B 235B-A22B	4B 8B 14B 30B-A3B 32B 235B-A22B	0.6B 1.7B 4B 8B 14B 30B-A3B 32B

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

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

<|im_start|>user\nQue vaut 2+2 ?<|im_end|>\n<|im_start|>assistant\n

Pour le mode NON-réflexion, nous encadrons volontairement <think> et </think> avec rien :

<|im_start|>user\nQue vaut 2+2 ?<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n

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.

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

<think>

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

<think>
D’accord, voyons voir. L’utilisateur demande combien de fois la lettre « r » apparaît dans le mot « strawberries ». [...]
</think>

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.

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

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

apt-get update
apt-get install pciutils -y
curl -fsSL https://ollama.com/install.sh | sh

1. Exécutez le modèle ! Notez que vous pouvez appeler ollama servedans 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 !

ollama run hf.co/unsloth/Qwen3-8B-GGUF:UD-Q4_K_XL

1. Pour désactiver la réflexion, utilisez (ou vous pouvez le définir dans le prompt système) :

>>> Écrivez votre prompt ici /nothink

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.

📖 Llama.cpp : Tutoriel pour exécuter Qwen3

1. Obtenez la dernière version llama.cpp sur GitHub ici. 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.

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

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

# !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*"],
)

1. Exécutez le modèle et essayez n’importe quel prompt.

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

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

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.

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

🦥 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 (recommandé)

• Qwen3 (4B) - LoRA GRPO avancé

• Notebook Qwen3 (14B) Alpaca (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 : 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.

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 etc., consultez notre guide complet ici:

🧬Fine-tuning Guide📈Guide des jeux de données

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) 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. <start_working_out></end_working_out>

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