# Qwen3-Coder : Comment l'exécuter localement Qwen3-Coder est la nouvelle série de modèles agents de codage de Qwen, disponible en 30B (**Qwen3-Coder-Flash**) et 480B paramètres. **Qwen3-480B-A35B-Instruct** atteint des performances SOTA en codage rivalisant avec Claude Sonnet-4, GPT-4.1, et [Kimi K2](https://unsloth.ai/docs/fr/modeles/tutorials/kimi-k2-thinking-how-to-run-locally), avec 61,8% sur Aider Polyglot et prise en charge d’un contexte de 256K (extensible à 1M) tokens. Nous avons également téléchargé Qwen3-Coder avec nativement **longueur de contexte 1M** étendue par YaRN et des versions en pleine précision 8bit et 16bit. [Unsloth](https://github.com/unslothai/unsloth) prend désormais également en charge le fine-tuning et [RL](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide) de Qwen3-Coder. {% hint style="success" %} [**MISE À JOUR :** Nous avons corrigé l’appel d’outils pour Qwen3-Coder ! ](#tool-calling-fixes)Vous pouvez désormais utiliser l’appel d’outils de manière transparente dans llama.cpp, Ollama, LMStudio, Open WebUI, Jan, etc. Ce problème était universel et affectait tous les uploads (pas seulement Unsloth), et nous avons communiqué avec l’équipe Qwen au sujet de nos corrections ! [En savoir plus](#tool-calling-fixes) {% endhint %} Exécuter 30B-A3BExécuter 480B-A35B {% hint style="success" %} **Est-ce que** [**Unsloth Dynamic Quants**](https://unsloth.ai/docs/fr/bases/unsloth-dynamic-2.0-ggufs) **fonctionne ?** Oui, et très bien. Dans des tests tiers sur le benchmark Aider Polyglot, le **UD-Q4\_K\_XL (276GB)** quant dynamique a presque égalé le **bf16 complet (960GB)** modèle Qwen3-coder, obtenant 60,9% contre 61,8%. [Plus de détails ici.](https://huggingface.co/unsloth/Qwen3-Coder-480B-A35B-Instruct-GGUF/discussions/8) {% endhint %} #### **Qwen3 Coder - Unsloth Dynamic 2.0 GGUFs**: | GGUF Dynamic 2.0 (pour exécuter) | GGUF Dynamic 2.0 Contexte 1M | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | | ## 🖥️ **Exécution de Qwen3-Coder** Ci-dessous figurent des guides pour les [**30B-A3B**](#run-qwen3-coder-30b-a3b-instruct) et [**480B-A35B**](#run-qwen3-coder-480b-a35b-instruct) variantes du modèle. ### :gear: Paramètres recommandés Qwen recommande ces paramètres d’inférence pour les deux modèles : `temperature=0.7`, `top_p=0.8`, `top_k=20`, `repetition_penalty=1.05` * **Température de 0,7** * Top\_K de 20 * Min\_P de 0,00 (optionnel, mais 0,01 fonctionne bien, la valeur par défaut de llama.cpp est 0,1) * Top\_P de 0,8 * **Pénalité de répétition de 1,05** * Modèle de chat : ``` <|im_start|>user Salut !<|im_end|> <|im_start|>assistant Quelle est la valeur de 1+1 ?<|im_end|> <|im_start|>user 2<|im_end|> <|im_start|>assistant ``` * Sortie de contexte recommandée : 65 536 tokens (peut être augmentée). Détails ici. **Modèle de chat/format de prompt avec retours à la ligne non rendus** {% code overflow="wrap" %} ``` <|im_start|>user\nSalut !<|im_end|>\n<|im_start|>assistant\nQuel est 1+1 ?<|im_end|>\n<|im_start|>user\n2<|im_end|>\n<|im_start|>assistant\n ``` {% endcode %} **Modèle de chat pour appel d’outils** (Récupérer la température actuelle pour San Francisco). Plus de détails ici sur la façon de formater les appels d’outils. ``` <|im_start|>user Quelle est la température à San Francisco maintenant ? Et demain ?<|im_end|> <|im_start|>assistant \n\n\nSan Francisco, CA, USA \n\n<|im_end|> <|im_start|>user {"temperature": 26.1, "location": "San Francisco, CA, USA", "unit": "celsius"} \n<|im_end|> ``` {% hint style="info" %} Rappel : ce modèle prend en charge uniquement le mode non-pensant et ne génère pas `` de blocs dans sa sortie. Pendant ce temps, la spécification de `enable_thinking=False` n’est plus requise. {% endhint %} ### Exécuter Qwen3-Coder-30B-A3B-Instruct : Pour atteindre des vitesses d’inférence de plus de 6 tokens par seconde pour notre quant 4 bits Dynamic, disposez d’au moins **18GB de mémoire unifiée** (VRAM et RAM combinées) ou **18GB de RAM système** seule. En règle générale, votre mémoire disponible doit correspondre ou dépasser la taille du modèle que vous utilisez. Par exemple, le quant UD\_Q8\_K\_XL (pleine précision), qui fait 32,5GB, nécessitera au moins **33GB de mémoire unifiée** (VRAM + RAM) ou **33GB de RAM** pour des performances optimales. **REMARQUE :** Le modèle peut fonctionner avec moins de mémoire que sa taille totale, mais cela ralenti l’inférence. La mémoire maximale n’est nécessaire que pour les vitesses les plus rapides. Étant donné qu'il s'agit d'un modèle non thinking, il n'est pas nécessaire de définir `thinking=False` et le modèle ne génère pas ` ` blocs. {% hint style="info" %} Suivez les [**bonnes pratiques ci-dessus**](#recommended-settings). Elles sont les mêmes que pour le modèle 480B. {% endhint %} #### 🦙 Ollama : Tutoriel Exécuter Qwen3-Coder-30B-A3B-Instruct 1. Installer `ollama` si vous ne l'avez pas déjà fait ! Vous ne pouvez exécuter que des modèles jusqu'à 32B. ```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 s'il échoue ! Nous incluons toutes nos corrections et paramètres suggérés (température etc.) dans `params` dans notre upload Hugging Face ! ```bash ollama run hf.co/unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF:UD-Q4_K_XL ``` #### :sparkles: Llama.cpp : Tutoriel Exécuter Qwen3-Coder-30B-A3B-Instruct 1. Obtenez la dernière `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). Vous pouvez aussi suivre les instructions de compilation ci-dessous. Changez `-DGGML_CUDA=ON` en `-DGGML_CUDA=OFF` si vous n'avez pas de GPU ou si vous voulez simplement de l'inférence CPU. **Pour les appareils Apple Mac / Metal**, définissez `-DGGML_CUDA=OFF` puis continuez comme d'habitude - le support Metal est activé 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. Vous pouvez directement récupérer depuis HuggingFace via : ```bash ./llama.cpp/llama-cli \ -hf unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF:Q4_K_XL \ --jinja -ngl 99 --ctx-size 32768 \ --temp 0.7 --min-p 0.0 --top-p 0.80 --top-k 20 --repeat-penalty 1.05 ``` 3. Téléchargez le modèle via (après avoir installé `pip install huggingface_hub hf_transfer` ). Vous pouvez choisir UD\_Q4\_K\_XL ou d’autres versions quantifiées. Si les téléchargements se bloquent, voir [hugging-face-hub-xet-debugging](https://unsloth.ai/docs/fr/bases/troubleshooting-and-faqs/hugging-face-hub-xet-debugging "mention") ```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-Coder-30B-A3B-Instruct-GGUF", local_dir = "unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF", allow_patterns = ["*UD-Q4_K_XL*"], ) ``` ### Exécuter Qwen3-Coder-480B-A35B-Instruct : Pour atteindre des vitesses d’inférence de plus de 6 tokens par seconde pour notre quant 1-bit, nous recommandons au moins **150GB de mémoire unifiée** (VRAM et RAM combinées) ou **150GB de RAM système** seule. En règle générale, votre mémoire disponible doit correspondre ou dépasser la taille du modèle que vous utilisez. Par exemple, le quant Q2\_K\_XL, qui fait 180GB, nécessitera au moins **180GB de mémoire unifiée** (VRAM + RAM) ou **180GB de RAM** pour des performances optimales. **REMARQUE :** Le modèle peut fonctionner avec moins de mémoire que sa taille totale, mais cela ralenti l’inférence. La mémoire maximale n’est nécessaire que pour les vitesses les plus rapides. {% hint style="info" %} Suivez les [**bonnes pratiques ci-dessus**](#recommended-settings). Elles sont les mêmes que pour le modèle 30B. {% endhint %} #### 📖 Llama.cpp : Tutoriel Exécuter Qwen3-Coder-480B-A35B-Instruct Pour Coder-480B-A35B, nous utiliserons spécifiquement Llama.cpp pour une inférence optimisée et une pléthore d’options. {% hint style="success" %} Si vous voulez une **version non quantifiée en pleine précision**, utilisez notre `Q8_K_XL, Q8_0` ou `BF16` versions ! {% endhint %} 1. Obtenez la dernière `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). Vous pouvez aussi suivre les instructions de compilation ci-dessous. Changez `-DGGML_CUDA=ON` en `-DGGML_CUDA=OFF` si vous n'avez pas de GPU ou si vous voulez simplement de l'inférence CPU. ```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. Vous pouvez utiliser directement llama.cpp pour télécharger le modèle, mais je suggère normalement d'utiliser `huggingface_hub` Pour utiliser llama.cpp directement, faites : ```bash ./llama.cpp/llama-cli \ -hf unsloth/Qwen3-Coder-480B-A35B-Instruct-GGUF:Q2_K_XL \ --ctx-size 16384 \ --n-gpu-layers 99 \ -ot ".ffn_.*_exps.=CPU" \ --temp 0.7 \ --min-p 0.0 \ --top-p 0.8 \ --top-k 20 \ --repeat-penalty 1.05 ``` 3. Ou, téléchargez le modèle via (après installation de `pip install huggingface_hub hf_transfer` Nous suivons des étapes similaires à celles ci‑dessus, cependant cette fois nous devrons également effectuer des étapes supplémentaires car le modèle est si volumineux. ```python # !pip install huggingface_hub hf_transfer import os os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Peut parfois limiter le débit, donc mettez à 0 pour désactiver from huggingface_hub import snapshot_download snapshot_download( repo_id = "unsloth/Qwen3-Coder-480B-A35B-Instruct-GGUF", local_dir = "unsloth/Qwen3-Coder-480B-A35B-Instruct-GGUF", local_dir = "unsloth/Qwen3-VL-235B-A22B-Instruct-GGUF", ) ``` 4. Exécutez le modèle en mode conversation et essayez n’importe quel prompt. 5. Modifier `--threads -1` pour le nombre de threads CPU, `--ctx-size` 262114 pour la longueur de contexte, `--n-gpu-layers 99` pour le déchargement sur GPU du nombre de couches. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le également si vous avez uniquement une inférence CPU. {% hint style="success" %} Utilisez `-ot ".ffn_.*_exps.=CPU"` pour décharger toutes les couches MoE vers le CPU ! Cela vous permet effectivement d’ajuster toutes les couches non-MoE sur 1 GPU, améliorant les vitesses de génération. Vous pouvez personnaliser l’expression regex pour ajuster plus de couches si vous avez plus de capacité GPU. Plus d’options discutées [ici](#improving-generation-speed). {% endhint %} {% code overflow="wrap" %} ```bash ./llama.cpp/llama-cli \ --model unsloth/Qwen3-Coder-480B-A35B-Instruct-GGUF/UD-Q2_K_XL/Qwen3-Coder-480B-A35B-Instruct-UD-Q2_K_XL-00001-of-00004.gguf \ --ctx-size 16384 \ --n-gpu-layers 99 \ -ot ".ffn_.*_exps.=CPU" \ --temp 0.7 \ --min-p 0.0 \ --top-p 0.8 \ --top-k 20 \ --repeat-penalty 1.05 ``` {% endcode %} {% hint style="success" %} N’oubliez pas non plus la nouvelle mise à jour Qwen3. Exécutez [**Qwen3-235B-A22B-Instruct-2507**](https://unsloth.ai/docs/fr/modeles/tutorials/qwen3-next) localement avec llama.cpp. {% endhint %} #### :tools: Amélioration de la vitesse de génération Si vous avez plus de VRAM, vous pouvez essayer de décharger plus de couches MoE, ou de décharger des couches entières elles-mêmes. Normalement, `-ot ".ffn_.*_exps.=CPU"` décharge toutes les couches MoE sur le CPU ! Cela vous permet effectivement de placer toutes les couches non-MoE sur 1 GPU, améliorant les vitesses de génération. Vous pouvez personnaliser l'expression regex pour décharger plus de couches si vous avez plus de capacité GPU. Si vous avez un peu plus de mémoire GPU, essayez `-ot ".ffn_(up|down)_exps.=CPU"` Cela décharge les couches MoE de projection up et down. Essayez `-ot ".ffn_(up)_exps.=CPU"` si vous avez encore plus de mémoire GPU. Cela ne décharge que les couches MoE de projection up. Vous pouvez aussi personnaliser la regex, par exemple `-ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU"` signifie décharger les couches MoE gate, up et down mais uniquement à partir de la 6e couche. La [dernière version de llama.cpp](https://github.com/ggml-org/llama.cpp/pull/14363) introduit aussi un mode haut débit. Utilisez `llama-parallel`. Lisez-en plus à ce sujet [ici](https://github.com/ggml-org/llama.cpp/tree/master/examples/parallel). Vous pouvez aussi **quantifier le cache KV en 4 bits** par exemple pour réduire les mouvements VRAM / RAM, ce qui peut aussi accélérer le processus de génération. #### :triangular\_ruler:Comment gérer un long contexte (256K à 1M) Pour adapter un contexte plus long, vous pouvez utiliser **quantification du cache KV** pour quantifier les caches K et V en bits plus faibles. Cela peut également augmenter la vitesse de génération en réduisant les mouvements de données RAM / VRAM. Les options autorisées pour la quantification de K (par défaut est `f16`) incluent ci-dessous. `--cache-type-k f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1` Vous devriez utiliser les `_1` variantes pour une précision quelque peu accrue, bien que ce soit légèrement plus lent. Par ex `q4_1, q5_1` Vous pouvez aussi quantifier le cache V, mais vous devrez **compiler llama.cpp avec le support Flash Attention** via `-DGGML_CUDA_FA_ALL_QUANTS=ON`, et utiliser `--flash-attn` pour l’activer. Nous avons également téléchargé des GGUFs à longueur de contexte d’un million via le scaling YaRN [ici](https://app.gitbook.com/o/HpyELzcNe0topgVLGCZY/s/xhOjnexMCB3dmuQFQ2Zq/). ## :toolbox: Corrections des appels d’outils Nous avons réussi à corriger l’appel d’outils via `llama.cpp --jinja` spécifiquement pour le service via `llama-server`! Si vous téléchargez nos quants 30B-A3B, pas d’inquiétude car ceux-ci incluent déjà nos corrections. Pour le modèle 480B-A35B, veuillez : 1. Téléchargez le premier fichier à pour UD-Q2\_K\_XL, et remplacez votre fichier actuel 2. Utilisez `snapshot_download` comme d’habitude comme dans ce qui remplacera automatiquement les anciens fichiers 3. Utilisez le nouveau modèle de chat via `--chat-template-file`. Voir [modèle de chat GGUF](https://huggingface.co/unsloth/Qwen3-Coder-480B-A35B-Instruct-GGUF?chat_template=default) ou [chat\_template.jinja](https://huggingface.co/unsloth/Qwen3-Coder-480B-A35B-Instruct/raw/main/chat_template.jinja) 4. En plus, nous avons également fabriqué un seul fichier UD-IQ1\_M de 150GB (afin qu’Ollama fonctionne) à Cela devrait résoudre des problèmes comme : ### Utilisation des appels d’outils Pour formater les prompts pour l’appel d’outils, illustrons-le par un exemple. J’ai créé une fonction Python appelée `get_current_temperature` qui est une fonction qui devrait obtenir la température actuelle pour un lieu. Pour l’instant nous avons créé une fonction de placeholder qui retournera toujours 21,6 degrés Celsius. Vous devriez changer ceci en une vraie fonction !! {% code overflow="wrap" %} ```python def get_current_temperature(location: str, unit: str = "celsius") : """Obtenir la température actuelle à un endroit. Args : location : Le lieu pour lequel obtenir la température, au format "Ville, État, Pays". unit : L’unité dans laquelle retourner la température. Par défaut "celsius". (choix : ["celsius", "fahrenheit"]) Retourne : la température, le lieu et l’unité dans un dict """ return { "temperature": 26.1, # PRÉ_CONFIGURÉ -> vous modifiez ceci ! "location": location, "unit": unit, } ``` {% endcode %} Puis utilisez le tokenizer pour créer le prompt entier : {% code overflow="wrap" %} ```python from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("unsloth/Qwen3-Coder-480B-A35B-Instruct") messages = [ {'role': 'user', 'content': "Quelle est la température à San Francisco maintenant ? Et demain ?"}, {'content': "", 'role': 'assistant', 'function_call': None, 'tool_calls': [ {'id': 'ID', 'function': {'arguments': {"location": "San Francisco, CA, USA"}, 'name': 'get_current_temperature'}, 'type': 'function'}, ]}, {'role': 'tool', 'content': '{"temperature": 26.1, "location": "San Francisco, CA, USA", "unit": "celsius"}', 'tool_call_id': 'ID'}, ] prompt = tokenizer.apply_chat_template(messages, tokenize = False) ``` {% endcode %} ## :bulb:Benchmarks de performance {% hint style="info" %} Ces benchmarks officiels concernent le checkpoint BF16 complet. Pour l’utiliser, employez simplement les `Q8_K_XL, Q8_0, BF16` checkpoints que nous avons téléchargés - vous pouvez toujours utiliser des astuces comme le déchargement MoE pour ces versions aussi ! {% endhint %} Voici les benchmarks pour le modèle 480B : #### Codage agentique
BenchmarkQwen3‑Coder 480B‑A35B‑InstructKimi‑K2DeepSeek‑V3-0324Claude 4 SonnetGPT‑4.1
Terminal‑Bench37.530.02.535.525.3
SWE‑bench Vérifié avec OpenHands (500 tours)69.6––70.4–
SWE‑bench Vérifié avec OpenHands (100 tours)67.065.438.868.048.6
SWE‑bench Vérifié avec Private Scaffolding–65.8–72.763.8
SWE‑bench En direct26.322.313.027.7–
SWE‑bench Multilingue54.747.313.053.331.5
Multi‑SWE‑bench mini25.819.87.524.8–
Multi‑SWE‑bench flash27.020.7–25.0–
Aider‑Polyglot61.860.056.956.452.4
Spider231.125.212.831.116.5
#### Utilisation agentique du navigateur
BenchmarkQwen3‑Coder 480B‑A35B‑InstructKimi‑K2DeepSeek‑V3 0324Claude Sonnet‑4GPT‑4.1
WebArena49.947.440.051.144.3
Mind2Web55.842.736.047.449.6
#### Utilisation d’outil agentique
BenchmarkQwen3‑Coder 480B‑A35B‑InstructKimi‑K2DeepSeek‑V3 0324Claude Sonnet‑4GPT‑4.1
BFCL‑v368.765.256.973.362.9
TAU‑Bench Retail77.570.759.180.5–
TAU‑Bench Airline60.053.540.060.0–