# Qwen3-Next : guide d'exécution locale

Qwen a publié Qwen3-Next en sept. 2025, qui sont des MoE de 80B avec des variantes de modèle Thinking et Instruct de [Qwen3](https://unsloth.ai/docs/fr/modeles/tutorials/qwen3-how-to-run-and-fine-tune). Avec un contexte de 256K, Qwen3-Next a été conçu avec une toute nouvelle architecture (hybride de MoEs & Gated DeltaNet + Gated Attention) qui optimise spécifiquement les inférences rapides sur de plus longues longueurs de contexte. Qwen3-Next a une inférence 10x plus rapide que Qwen3-32B.

<a href="#run-qwen3-next-tutorials" class="button secondary">Lancer Qwen3-Next Instruct</a><a href="#thinking-qwen3-next-80b-a3b-thinking" class="button secondary">Lancer Qwen3-Next Thinking</a>

GGUF dynamiques Qwen3-Next-80B-A3B : [**Instruct**](https://huggingface.co/unsloth/Qwen3-Next-80B-A3B-Instruct-GGUF) **•** [**Thinking**](https://huggingface.co/unsloth/Qwen3-Next-80B-A3B-Thinking-GGUF)

### ⚙️ Guide d'utilisation

{% hint style="success" %}
NOUVEAU au 6 déc. 2025 : Unsloth Qwen3-Next mis à jour avec iMatrix pour de meilleures performances.

Le modèle thinking utilise `température = 0,6`, mais le modèle instruct utilise `température = 0,7`\
Le modèle thinking utilise `top_p = 0,95`, mais le modèle instruct utilise `top_p = 0,8`
{% endhint %}

Pour obtenir des performances optimales, Qwen recommande ces réglages :

| Instruct :                                                                                                                                 | Thinking :                                                                                                                                 |
| ------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ |
| <mark style="background-color:blue;">`Température = 0,7`</mark>                                                                            | <mark style="background-color:blue;">`Température = 0,6`</mark>                                                                            |
| `Min_P = 0,00` (la valeur par défaut de llama.cpp est 0,1)                                                                                 | `Min_P = 0,00` (la valeur par défaut de llama.cpp est 0,1)                                                                                 |
| `Top_P = 0,80`                                                                                                                             | `Top_P = 0,95`                                                                                                                             |
| `TopK = 20`                                                                                                                                | `TopK = 20`                                                                                                                                |
| `presence_penalty = 0.0 à 2.0` (la valeur par défaut de llama.cpp le désactive, mais pour réduire les répétitions, vous pouvez l'utiliser) | `presence_penalty = 0.0 à 2.0` (la valeur par défaut de llama.cpp le désactive, mais pour réduire les répétitions, vous pouvez l'utiliser) |

**Longueur de sortie adéquate** : Utilisez une longueur de sortie de `32,768` tokens pour la plupart des requêtes pour la variante thinking, et `16,384` pour la variante instruct. Vous pouvez augmenter la taille maximale de sortie pour le modèle thinking si nécessaire.

Le modèle de conversation pour les deux Thinking (thinking a `<think></think>`) et Instruct est ci-dessous :

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

## 📖 Lancer les tutoriels Qwen3-Next

Ci-dessous figurent des guides pour les [Thinking](#thinking-qwen3-next-80b-a3b-thinking) et [Instruct](#instruct-qwen3-next-80b-a3b-instruct) versions du modèle.

### Instruct : Qwen3-Next-80B-A3B-Instruct

Étant donné qu'il s'agit d'un modèle non-thinking, le modèle ne génère pas `<think> </think>` blocs.

#### ⚙️ Bonnes pratiques

Pour obtenir des performances optimales, Qwen recommande les réglages suivants :

* Nous suggérons d'utiliser `temperature=0.7, top_p=0.8, top_k=20, et min_p=0.0` `presence_penalty` entre 0 et 2 si le framework le prend en charge afin de réduire les répétitions sans fin.
* **`température = 0,7`**
* `top_k = 20`
* `min_p = 0.00` (la valeur par défaut de llama.cpp est 0,1)
* **`top_p = 0.80`**
* `presence_penalty = 0.0 à 2.0` (la valeur par défaut de llama.cpp le désactive, mais pour réduire les répétitions, vous pouvez l'utiliser) Essayez 1.0 par exemple.
* Prend en charge jusqu'à `262,144` contexte nativement mais vous pouvez le régler sur `32,768` tokens pour une utilisation de RAM réduite

#### :sparkles: Llama.cpp : Lancer le tutoriel Qwen3-Next-80B-A3B-Instruct

1. Obtenez la dernière `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). Vous pouvez suivre les instructions de compilation ci-dessous également. Changez `-DGGML_CUDA=ON` en `-DGGML_CUDA=OFF` si vous n’avez pas de GPU ou si vous voulez simplement 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 le récupérer directement depuis HuggingFace via :

   ```bash
   ./llama.cpp/llama-cli \
       -hf unsloth/Qwen3-Next-80B-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 --presence-penalty 1.0
   ```
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.

```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-Next-80B-A3B-Instruct-GGUF",
    local_dir = "Qwen3-Next-80B-A3B-Instruct-GGUF",
    allow_patterns = ["*UD-Q4_K_XL*"],
)
```

### Thinking : Qwen3-Next-80B-A3B-Thinking

Ce modèle prend en charge uniquement le mode thinking et une fenêtre de contexte de 256K nativement. Le modèle de conversation par défaut ajoute `<think>` automatiquement, donc vous pouvez voir seulement une balise de fermeture `</think>` dans la sortie.

#### ⚙️ Bonnes pratiques

Pour obtenir des performances optimales, Qwen recommande les réglages suivants :

* Nous suggérons d'utiliser `temperature=0.6, top_p=0.95, top_k=20, et min_p=0.0` `presence_penalty` entre 0 et 2 si le framework le prend en charge afin de réduire les répétitions sans fin.
* **`température = 0,6`**
* `top_k = 20`
* `min_p = 0.00` (la valeur par défaut de llama.cpp est 0,1)
* **`top_p = 0,95`**
* `presence_penalty = 0.0 à 2.0` (la valeur par défaut de llama.cpp le désactive, mais pour réduire les répétitions, vous pouvez l'utiliser) Essayez 1.0 par exemple.
* Prend en charge jusqu'à `262,144` contexte nativement mais vous pouvez le régler sur `32,768` tokens pour une utilisation de RAM réduite

#### :sparkles: Llama.cpp : Lancer le tutoriel Qwen3-Next-80B-A3B-Thinking

1. Obtenez la dernière `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). Vous pouvez suivre les instructions de compilation ci-dessous également. Changez `-DGGML_CUDA=ON` en `-DGGML_CUDA=OFF` si vous n’avez pas de GPU ou si vous voulez simplement 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 le récupérer directement depuis Hugging Face via :

   ```bash
   ./llama.cpp/llama-cli \
       -hf unsloth/Qwen3-Next-80B-A3B-Thinking-GGUF:Q4_K_XL \
       --jinja -ngl 99 --ctx-size 32768 \
       --temp 0.6 --min-p 0.0 --top-p 0.95 --top-k 20 --presence-penalty 1.0
   ```
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.

```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-Next-80B-A3B-Thinking-GGUF",
    local_dir = "Qwen3-Next-80B-A3B-Thinking-GGUF",
    allow_patterns = ["*UD-Q4_K_XL*"],
)
```

### 🛠️ Améliorer la vitesse de génération <a href="#improving-generation-speed" id="improving-generation-speed"></a>

Si vous avez plus de VRAM, vous pouvez essayer de décharger davantage 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 vers 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 disposez de 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 décharge uniquement 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 seulement à 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`. En savoir 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. La [section suivante](#how-to-fit-long-context-256k-to-1m) parle de la quantification du cache KV.

### 📐Comment adapter un long contexte <a href="#how-to-fit-long-context-256k-to-1m" id="how-to-fit-long-context-256k-to-1m"></a>

Pour adapter un contexte plus long, vous pouvez utiliser **la quantification du cache KV** pour quantifier les caches K et V en moins de bits. Cela peut aussi augmenter la vitesse de génération en raison d'une réduction des transferts de données RAM / VRAM. Les options autorisées pour la quantification de K (la valeur 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` Donc essayez `--cache-type-k q4_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. Après avoir installé Flash Attention, vous pouvez alors utiliser `--cache-type-v q4_1`

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-be34c101c627020c7a6cfb6cd249f2462587d235%2Fqwen33%20mascot.png?alt=media" alt=""><figcaption></figcaption></figure>


---

# 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-next.md?ask=<question>
```

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.