# Qwen3.6 - Comment l'exécuter localement

Qwen3.6 est la nouvelle famille de modèles hybrides multimodaux d’Alibaba, comprenant : **Qwen3.6-27B** et **35B-A3B**. Il offre des performances de premier plan pour sa taille, prend en charge un contexte de 256K sur 201 langues. Il excelle dans le codage agentique, la vision et les tâches de chat. Qwen3.6-27B fonctionne sur des configurations de **18 Go de RAM** et 35B-A3B fonctionne sur **22 Go**. Vous pouvez désormais exécuter et entraîner les modèles dans [Unsloth Studio](#unsloth-studio-guide).

{% hint style="success" %}
**NOUVEAU :** [**Qwen3.6 MTP est là**](#mtp-guide)**! MTP permet une inférence 1,4 à 2 fois plus rapide sans perte de précision**

Nous avons réalisé [des benchmarks GGUF de Qwen3.6](#unsloth-gguf-benchmarks) pour vous aider à choisir la meilleure quantification.
{% endhint %}

<a href="/pages/4a2b83ac4bf0233da80a1e3b6ab9fb218108742c#qwen3.6-inference-tutorials" class="button primary">Tutoriels pour exécuter Qwen3.6</a><a href="/pages/4a2b83ac4bf0233da80a1e3b6ab9fb218108742c#mtp-guide" class="button primary">Guide MTP</a>

{% columns %}
{% column %}
Les GGUF de Qwen3.6 utilisent Unsloth [Dynamic 2.0](/docs/fr/bases/unsloth-dynamic-2.0-ggufs.md) pour des performances de quantification SOTA - les quantifications sont donc calibrées sur des jeux de données d’utilisation réelle et les couches importantes sont remises en précision supérieure. *Merci à Qwen pour l’accès dès le premier jour.*

* **Prise en charge du rôle développeur** pour Codex, OpenCode et plus :\
  Nos envois prennent désormais en charge le `rôle développeur` pour les outils de codage agentique.
* **Appel d’outils :** Comme [Qwen3.5](/docs/fr/modeles/qwen3.5.md), nous avons amélioré l’analyse des objets imbriqués pour améliorer la réussite de l’appel d’outils.
  {% endcolumn %}

{% column %}

<div data-with-frame="true"><figure><img src="/files/acbddf2b13951f7e83eb5a222093fd827a4b5258" alt=""><figcaption><p>Qwen3.6 en cours d’exécution dans <a href="#unsloth-studio-guide">Unsloth Studio</a>.</p></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

### :gear: Guide d’utilisation

**Tableau : Exigences matérielles pour l’inférence** (unités = mémoire totale : RAM + VRAM, ou mémoire unifiée)

<table><thead><tr><th>Qwen3.6</th><th>3 bits</th><th>4 bits</th><th width="128">6 bits</th><th>8 bits</th><th>BF16</th></tr></thead><tbody><tr><td><strong>27B</strong></td><td>15 Go</td><td>18 Go</td><td>24 Go</td><td>30 Go</td><td>55 Go</td></tr><tr><td><strong>35B-A3B</strong></td><td>17 Go</td><td>23 Go</td><td>30 Go</td><td>38 Go</td><td>70 Go</td></tr></tbody></table>

{% hint style="success" %}
Pour de meilleures performances, assurez-vous que votre mémoire totale disponible (VRAM + RAM système) dépasse la taille du fichier du modèle quantifié que vous téléchargez. Si ce n’est pas le cas, llama.cpp peut toujours fonctionner via le déchargement sur SSD/HDD, mais l’inférence sera plus lente.
{% endhint %}

{% hint style="warning" %}
N’utilisez PAS CUDA 13.2, car vous pourriez obtenir des sorties incohérentes. NVIDIA travaille sur un correctif.
{% endhint %}

**Pour entraîner Qwen3.6, vous pouvez vous référer à notre précédent** [**guide de fine-tuning Qwen3.5**](/docs/fr/modeles/qwen3.5/fine-tune.md)**.**

### Paramètres recommandés

* **Fenêtre de contexte maximale :** `262,144` (peut être étendue à 1M via YaRN)
* `presence_penalty = 0,0 à 2,0` par défaut, c’est désactivé, mais pour réduire les répétitions, vous pouvez utiliser ceci ; toutefois, une valeur plus élevée peut entraîner **une légère baisse des performances**
* **Longueur de sortie adéquate**: `32,768` tokens pour la plupart des requêtes

{% hint style="info" %}
Si vous obtenez du charabia, la longueur de votre contexte est peut-être trop faible. Ou essayez d’utiliser `--cache-type-k bf16 --cache-type-v bf16` ce qui peut aider.
{% endhint %}

Comme Qwen3.6 est à raisonnement hybride, les modes de réflexion et sans réflexion ont des paramètres différents :

#### Mode réflexion :

{% hint style="success" %}
Qwen3.6 dispose désormais de [Conserver la réflexion](#turn-on-off-thinking--preserve-thinking).
{% endhint %}

| Tâches générales                   | Tâches de codage précises (par ex. WebDev) |
| ---------------------------------- | ------------------------------------------ |
| temperature = 1,0                  | temperature = 0,6                          |
| top\_p = 0,95                      | top\_p = 0,95                              |
| top\_k = 20                        | top\_k = 20                                |
| min\_p = 0,0                       | min\_p = 0,0                               |
| presence\_penalty = 1,5            | presence\_penalty = 0,0                    |
| repeat\_penalty = désactivé ou 1,0 | repeat\_penalty = désactivé ou 1,0         |

{% columns %}
{% column %}
Mode réflexion pour les tâches générales :

{% code overflow="wrap" %}

```bash
temperature=1,0, top_p=0,95, top_k=20, min_p=0,0, presence_penalty=1,5, repetition_penalty=1,0
```

{% endcode %}
{% endcolumn %}

{% column %}
Mode réflexion pour les tâches de codage précises :

{% code overflow="wrap" %}

```bash
temperature=0,6, top_p=0,95, top_k=20, min_p=0,0, presence_penalty=0,0, repetition_penalty=1,0
```

{% endcode %}
{% endcolumn %}
{% endcolumns %}

#### Paramètres du mode Instruct (sans réflexion) :

| Tâches générales                   | Tâches de raisonnement             |
| ---------------------------------- | ---------------------------------- |
| temperature = 0,7                  | temperature = 1,0                  |
| top\_p = 0,8                       | top\_p = 0,95                      |
| top\_k = 20                        | top\_k = 20                        |
| min\_p = 0,0                       | min\_p = 0,0                       |
| presence\_penalty = 1,5            | presence\_penalty = 1,5            |
| repeat\_penalty = désactivé ou 1,0 | repeat\_penalty = désactivé ou 1,0 |

{% hint style="warning" %}
Pour [désactiver la réflexion / le raisonnement](#how-to-enable-or-disable-reasoning-and-thinking), utilisez `--chat-template-kwargs '{"enable_thinking":false}'`

Si vous êtes sur **Windows** PowerShell, utilisez : `--chat-template-kwargs "{\"enable_thinking\":false}"`

Utilisez 'true' et 'false' de manière interchangeable.
{% endhint %}

{% columns %}
{% column %}
Instruct (sans réflexion) pour les tâches générales :

{% code overflow="wrap" %}

```bash
temperature=0,7, top_p=0,8, top_k=20, min_p=0,0, presence_penalty=1,5, repetition_penalty=1,0
```

{% endcode %}
{% endcolumn %}

{% column %}
Instruct (sans réflexion) pour les tâches de raisonnement :

{% code overflow="wrap" %}

```bash
temperature=1,0, top_p=0,95, top_k=20, min_p=0,0, presence_penalty=1,5, repetition_penalty=1,0
```

{% endcode %}
{% endcolumn %}
{% endcolumns %}

## Tutoriels d’inférence Qwen3.6 :

Nous allons utiliser Dynamic 4-bit `UD_Q4_K_XL` variantes GGUF pour les charges de travail d’inférence. Cliquez ci-dessous pour accéder aux instructions du modèle désigné :

{% hint style="warning" %}
N’utilisez PAS CUDA 13.2, car vous pourriez obtenir des sorties incohérentes. NVIDIA travaille sur un correctif.
{% endhint %}

<a href="/pages/4a2b83ac4bf0233da80a1e3b6ab9fb218108742c#mtp-guide" class="button primary">Guide MTP</a><a href="/pages/5dc1787d57509ad87481c06d36ca9df87c35c053#unsloth-studio-guide" class="button primary">Exécuter dans Unsloth Studio</a><a href="/pages/4a2b83ac4bf0233da80a1e3b6ab9fb218108742c#llama.cpp-guides" class="button secondary">Exécuter dans llama.cpp</a>

{% hint style="info" %}
`presence_penalty = 0,0 à 2,0` par défaut, c’est désactivé, mais pour réduire les répétitions, vous pouvez utiliser ceci ; toutefois, une valeur plus élevée peut entraîner **une légère baisse des performances.**

Actuellement, aucun GGUF Qwen3.6 ne fonctionne dans Ollama en raison de fichiers vision mmproj séparés. Utilisez des backends compatibles avec llama.cpp.
{% endhint %}

### ⚡ Guide MTP

MTP (Multi Token Prediction) l’échantillonnage spéculatif permet à des modèles comme Qwen3.6 d’obtenir **une génération \~1,4 à 2 fois plus rapide avec&#x20;**<mark style="background-color:$success;">**aucun changement de précision**</mark>. Cela permet aux modèles Qwen3.6 27B et 35B-A3B d’obtenir **>1,4x d’accélération** par rapport au modèle de base original, ce qui est particulièrement utile pour les modèles locaux.

**Qwen3.6 27B peut désormais générer 140 tokens/s et Qwen3.6 35B-A3B 220 tokens/s !** Voir [#mtp-benchmarks](#mtp-benchmarks "mention") pour plus de détails

| [Qwen3.6-27B-MTP-GGUF](https://huggingface.co/unsloth/Qwen3.6-27B-MTP-GGUF) | [Qwen3.6-35B-A3B-MTP-GGUF](https://huggingface.co/unsloth/Qwen3.6-35B-A3B-MTP-GGUF) |
| --------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |

<div data-with-frame="true"><figure><img src="/files/78fa41e408e6a38bcac0ff9adf5ced95650971bb" alt=""><figcaption></figcaption></figure></div>

En pratique, MTP prédit plusieurs jetons futurs, puis le modèle principal vérifie ces jetons en parallèle. Cela réduit le nombre de passes avant nécessaires pendant la génération et rend la sortie plus rapide. Nous avons constaté que `--spec-draft-n-max 2` fonctionne le mieux !

{% stepper %}
{% step %}
Installez la branche **spécifique** `llama.cpp` PR sur [**GitHub ici**](https://github.com/ggml-org/llama.cpp/pull/22673). Vous pouvez également suivre les instructions de compilation ci-dessous. Modifiez `-DGGML_CUDA=ON` en `-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 normalement - la prise en charge de Metal est activée par défaut.

```bash
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone -b mtp-clean https://github.com/am17an/llama.cpp.git
cmake llama.cpp -B llama.cpp/build -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-server
cp llama.cpp/build/bin/llama-* llama.cpp
```

{% endstep %}

{% step %}
Si vous voulez utiliser `llama.cpp` directement pour charger des modèles, vous pouvez faire ce qui suit : (:`Q4_K_XL`) est le type de quantification. Vous pouvez également télécharger via Hugging Face (point 3). C’est similaire à `ollama run` . Utilisez `export LLAMA_CACHE="folder"` pour forcer `llama.cpp` la sauvegarde à un emplacement spécifique. Le modèle a une longueur de contexte maximale de 256K.

Suivez l’une des commandes pour les modèles spécifiques :

<a href="/pages/4a2b83ac4bf0233da80a1e3b6ab9fb218108742c#mtp-qwen3.6-27b" class="button primary">27B MTP</a><a href="/pages/4a2b83ac4bf0233da80a1e3b6ab9fb218108742c#mtp-qwen3.6-35b-a3b" class="button primary">35-A3B MTP</a>

#### MTP Qwen3.6-27B :

**Mode réflexion :**

{% hint style="info" %}
Veuillez consulter le nouveau [Raisonnement préservé](#thinking-enable-disable--preserve-thinking).
{% endhint %}

Tâches générales :

```bash
export LLAMA_CACHE="unsloth/Qwen3.6-27B-MTP-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/Qwen3.6-27B-GGUF:UD-Q4_K_XL \
    --temp 1.0 \
    --top-p 0.95 \
    --top-k 20 \
    --presence-penalty 1.5 \
    --min-p 0.00 \
    --spec-type mtp --spec-draft-n-max 2
```

Pour les tâches de codage précises, modifiez : `temperature=0,6, presence-penalty=0,0`

**Mode sans réflexion :**

Tâches générales :

```bash
export LLAMA_CACHE="unsloth/Qwen3.6-27B-MTP-GGUF"
./llama.cpp/llama-server \
    -hf unsloth/Qwen3.6-27B-MTP-GGUF:UD-Q4_K_XL \
    --temp 0.7 \
    --top-p 0.8 \
    --top-k 20 \
    --presence-penalty 1.5 \
    --min-p 0.00 \
    --spec-type mtp --spec-draft-n-max 2 \
    --chat-template-kwargs '{"enable_thinking":false}'
```

Pour les tâches de raisonnement, modifiez : `temperature=1,0, top-p=0,95`

#### MTP Qwen3.6-35B-A3B :

**Mode réflexion :**

{% hint style="info" %}
Veuillez consulter le nouveau [Raisonnement préservé](#thinking-enable-disable--preserve-thinking).
{% endhint %}

Tâches générales :

```bash
export LLAMA_CACHE="unsloth/Qwen3.6-35B-A3B-MTP-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/Qwen3.6-35B-A3B-MTP-GGUF:UD-Q4_K_XL \
    --temp 1.0 \
    --top-p 0.95 \
    --top-k 20 \
    --presence-penalty 1.5 \
    --min-p 0.00 \
    --spec-type mtp --spec-draft-n-max 2
```

Pour les tâches de codage précises, modifiez : `temperature=0,6, presence-penalty=0,0`

**Mode sans réflexion :**

Tâches générales :

```bash
export LLAMA_CACHE="unsloth/Qwen3.6-35B-A3B-MTP-GGUF"
./llama.cpp/llama-server \
    -hf unsloth/Qwen3.6-35B-A3B-MTP-GGUF:UD-Q4_K_XL \
    --temp 0.7 \
    --top-p 0.8 \
    --top-k 20 \
    --presence-penalty 1.5 \
    --min-p 0.00 \
    --spec-type mtp --spec-draft-n-max 2 \
    --chat-template-kwargs '{"enable_thinking":false}'
```

Pour les tâches de raisonnement, modifiez : `temperature=1,0, top-p=0,95`
{% endstep %}

{% step %}
Téléchargez le modèle via le code ci-dessous (après avoir installé `pip install huggingface_hub hf_transfer`). Vous pouvez choisir Q4\_K\_M ou d’autres versions quantifiées comme `UD-Q4_K_XL` . Nous recommandons d’utiliser au moins une quantification dynamique 2 bits `UD-Q2_K_XL` pour équilibrer taille et précision. Si les téléchargements se bloquent, voir : [Hugging Face Hub, débogage XET](/docs/fr/bases/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md)

```bash
hf download unsloth/Qwen3.6-35B-A3B-MTP-GGUF \
    --local-dir unsloth/Qwen3.6-35B-A3B-MTP-GGUF \
    --include "*mmproj-F16*" \
    --include "*UD-Q4_K_XL*" # Utilisez "*UD-Q2_K_XL*" pour Dynamic 2 bits
```

{% endstep %}

{% step %}
Puis exécutez le modèle en mode conversation :

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \
    --model unsloth/Qwen3.6-35B-A3B-MTP-GGUF/Qwen3.6-35B-A3B-UD-Q4_K_XL.gguf \
    --mmproj unsloth/Qwen3.6-35B-A3B-MTP-GGUF/mmproj-F16.gguf \
    --temp 1.0 \
    --top-p 0.95 \
    --min-p 0.00 \
    --presence-penalty 1.5 \
    --top-k 20
```

{% endcode %}
{% endstep %}
{% endstepper %}

### 🦥 Guide Unsloth Studio

Qwen3.6 peut être exécuté et fine-tuné dans [Unsloth Studio](/docs/fr/nouveau/studio.md), notre nouvelle interface web open source pour l’IA locale. Unsloth Studio vous permet d’exécuter des modèles localement sur **MacOS, Windows**, Linux et :

{% columns %}
{% column %}

* Rechercher, télécharger, [exécuter des GGUF](/docs/fr/nouveau/studio.md#run-models-locally) et des modèles safetensor
* [**Auto-réparation** appel d’outils](/docs/fr/nouveau/studio.md#execute-code--heal-tool-calling) + **recherche web**
* [**Exécution de code**](/docs/fr/nouveau/studio.md#run-models-locally) (Python, Bash)
* [Inférence automatique](/docs/fr/nouveau/studio.md#model-arena) réglage des paramètres (temp, top-p, etc.)
* Inférence CPU + GPU rapide via llama.cpp
* [Entraîner des LLM](/docs/fr/nouveau/studio.md#no-code-training) 2x plus rapide avec 70 % de VRAM en moins
  {% endcolumn %}

{% column %}

<div data-with-frame="true"><figure><img src="/files/31c38c07670d49aecd1964d6f1124e2d504c41ae" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

{% stepper %}
{% step %}

#### Installer Unsloth

Exécutez dans votre terminal :

**MacOS, Linux, WSL :**

```bash
curl -fsSL https://unsloth.ai/install.sh | sh
```

**Windows PowerShell :**

```bash
irm https://unsloth.ai/install.ps1 | iex
```

{% hint style="success" %}
**L’installation sera rapide et prendra environ 20 s à 1 min.**
{% endhint %}
{% endstep %}

{% step %}

#### Lancer Unsloth

**MacOS, Linux, WSL et Windows :**

```bash
unsloth studio -H 0.0.0.0 -p 8888
```

<div data-with-frame="true"><figure><img src="/files/fa3d706136ff9e7c9e614db9bb2d851ed981df1b" alt="" width="375"><figcaption></figcaption></figure></div>

Puis ouvrez `http://127.0.0.1:8888` (ou votre URL spécifique) dans votre navigateur.
{% endstep %}

{% step %}

#### Rechercher et télécharger Qwen3.6

Lors du premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte, puis vous reconnecter plus tard. Vous verrez ensuite un bref assistant d’intégration pour choisir un modèle, un jeu de données et des paramètres de base. Vous pouvez le passer à tout moment.

Puis allez à l’onglet [Studio Chat](/docs/fr/nouveau/studio/chat.md) et recherchez Qwen3.6 dans la barre de recherche, puis téléchargez le modèle et la quantification souhaités.

<div data-with-frame="true"><figure><img src="/files/140387d0bace30db6e991cb4e30037e0dbcd6ba2" alt="" width="375"><figcaption></figcaption></figure></div>
{% endstep %}

{% step %}

#### Exécuter Qwen3.6

Les paramètres d’inférence devraient être définis automatiquement lors de l’utilisation d’Unsloth Studio, mais vous pouvez toujours les modifier manuellement. Vous pouvez également modifier la longueur du contexte, le modèle de chat et d’autres paramètres.

Pour plus d’informations, vous pouvez consulter notre [guide d’inférence d’Unsloth Studio](/docs/fr/nouveau/studio/chat.md). Ci-dessous, le GGUF Qwen3.6 2 bits a effectué plus de 30 appels d’outils, recherché 20 sites et exécuté du code Python :

{% embed url="<https://cdn-uploads.huggingface.co/production/uploads/62ecdc18b72a69615d6bd857/9lqVQm1qDX3elt6Uan5Vm.mp4>" %}
{% endstep %}
{% endstepper %}

### 🦙 Guides Llama.cpp

Pour ce guide, nous allons utiliser Dynamic 4-bit, qui fonctionne très bien sur un appareil 24 Go de RAM / Mac pour une inférence rapide sur [llama.cpp](llama.cpphttps://github.com/ggml-org/llama.cpp). Comme le modèle ne pèse qu’environ 72 Go en précision F16 complète, nous n’aurons pas trop à nous soucier des performances. [Voir notre collection GGUF](https://huggingface.co/collections/unsloth/qwen36).

<a href="/pages/4a2b83ac4bf0233da80a1e3b6ab9fb218108742c#qwen3.6-27b" class="button primary">27B</a><a href="/pages/4a2b83ac4bf0233da80a1e3b6ab9fb218108742c#qwen3.6-35b-a3b" class="button primary">35-A3B</a>

{% stepper %}
{% step %}
Obtenez la dernière `llama.cpp` **sur** [**GitHub ici**](https://github.com/ggml-org/llama.cpp). Vous pouvez également suivre les instructions de compilation ci-dessous. Modifiez `-DGGML_CUDA=ON` en `-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 normalement - la prise en charge de 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
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```

{% endstep %}

{% step %}
Si vous voulez utiliser `llama.cpp` directement pour charger des modèles, vous pouvez faire ce qui suit : (:`Q4_K_XL`) est le type de quantification. Vous pouvez également télécharger via Hugging Face (point 3). C’est similaire à `ollama run` . Utilisez `export LLAMA_CACHE="folder"` pour forcer `llama.cpp` la sauvegarde à un emplacement spécifique. Le modèle a une longueur de contexte maximale de 256K.

Suivez l’une des commandes pour les modèles spécifiques :

<a href="/pages/4a2b83ac4bf0233da80a1e3b6ab9fb218108742c#qwen3.5-27b" class="button primary">27B</a><a href="/pages/4a2b83ac4bf0233da80a1e3b6ab9fb218108742c#qwen3.5-35b-a3b" class="button primary">35-A3B</a>

#### Qwen3.6-27B :

**Mode réflexion :**

{% hint style="info" %}
Veuillez consulter le nouveau [Raisonnement préservé](#thinking-enable-disable--preserve-thinking).
{% endhint %}

Tâches générales :

```bash
export LLAMA_CACHE="unsloth/Qwen3.6-27B-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/Qwen3.6-27B-GGUF:UD-Q4_K_XL \
    --temp 1.0 \
    --top-p 0.95 \
    --top-k 20 \
    --presence-penalty 1.5 \
    --min-p 0.00
```

Pour les tâches de codage précises, modifiez : `temperature=0,6, presence-penalty=0,0`

**Mode sans réflexion :**

Tâches générales :

```bash
export LLAMA_CACHE="unsloth/Qwen3.6-27B-GGUF"
./llama.cpp/llama-server \
    -hf unsloth/Qwen3.6-27B-GGUF:UD-Q4_K_XL \
    --temp 0.7 \
    --top-p 0.8 \
    --top-k 20 \
    --presence-penalty 1.5 \
    --min-p 0.00 \
    --chat-template-kwargs '{"enable_thinking":false}'
```

Pour les tâches de raisonnement, modifiez : `temperature=1,0, top-p=0,95`

#### Qwen3.6-35B-A3B :

**Mode réflexion :**

{% hint style="info" %}
Veuillez consulter le nouveau [Raisonnement préservé](#thinking-enable-disable--preserve-thinking).
{% endhint %}

Tâches générales :

```bash
export LLAMA_CACHE="unsloth/Qwen3.6-35B-A3B-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q4_K_XL \
    --temp 1.0 \
    --top-p 0.95 \
    --top-k 20 \
    --presence-penalty 1.5 \
    --min-p 0.00
```

Pour les tâches de codage précises, modifiez : `temperature=0,6, presence-penalty=0,0`

**Mode sans réflexion :**

Tâches générales :

```bash
export LLAMA_CACHE="unsloth/Qwen3.6-35B-A3B-GGUF"
./llama.cpp/llama-server \
    -hf unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q4_K_XL \
    --temp 0.7 \
    --top-p 0.8 \
    --top-k 20 \
    --presence-penalty 1.5 \
    --min-p 0.00 \
    --chat-template-kwargs '{"enable_thinking":false}'
```

Pour les tâches de raisonnement, modifiez : `temperature=1,0, top-p=0,95`
{% endstep %}

{% step %}
Téléchargez le modèle via le code ci-dessous (après avoir installé `pip install huggingface_hub hf_transfer`). Vous pouvez choisir Q4\_K\_M ou d’autres versions quantifiées comme `UD-Q4_K_XL` . Nous recommandons d’utiliser au moins une quantification dynamique 2 bits `UD-Q2_K_XL` pour équilibrer taille et précision. Si les téléchargements se bloquent, voir : [Hugging Face Hub, débogage XET](/docs/fr/bases/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md)

```bash
hf download unsloth/Qwen3.6-35B-A3B-GGUF \
    --local-dir unsloth/Qwen3.6-35B-A3B-GGUF \
    --include "*mmproj-F16*" \
    --include "*UD-Q4_K_XL*" # Utilisez "*UD-Q2_K_XL*" pour Dynamic 2 bits
```

{% endstep %}

{% step %}
Puis exécutez le modèle en mode conversation :

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \
    --model unsloth/Qwen3.6-35B-A3B-GGUF/Qwen3.6-35B-A3B-UD-Q4_K_XL.gguf \
    --mmproj unsloth/Qwen3.6-35B-A3B-GGUF/mmproj-F16.gguf \
    --temp 1.0 \
    --top-p 0.95 \
    --min-p 0.00 \
    --presence-penalty 1.5 \
    --top-k 20
```

{% endcode %}
{% endstep %}
{% endstepper %}

#### Llama-server et bibliothèque de complétion OpenAI

Pour déployer Qwen3.6 en production, nous utilisons `llama-server` Dans un nouveau terminal, par exemple via tmux, déployez le modèle avec :

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-server \
--model unsloth/Qwen3.6-35B-A3B-GGUF/Qwen3.6-35B-A3B-UD-Q4_K_XL.gguf \
    --mmproj unsloth/Qwen3.6-35B-A3B-GGUF/mmproj-F16.gguf \
    --alias "unsloth/Qwen3.6-35B-A3B" \
    --temp 0.6 \
    --top-p 0.95 \
    --ctx-size 16384 \
    --top-k 20 \
    --min-p 0.00 \
    --port 8001
```

{% endcode %}

Puis dans un nouveau terminal, après avoir fait `pip install openai`, faites :

{% code overflow="wrap" %}

```python
from openai import OpenAI
import json
openai_client = OpenAI(
    base_url = "http://127.0.0.1:8001/v1",
    api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
    model = "unsloth/Qwen3.6-35B-A3B",
    messages = [{"role": "user", "content": "Crée un jeu de Snake."},],
)
print(completion.choices[0].message.content)
```

{% endcode %}

### 🍎 Quants dynamiques MLX

Nous avons également mis en ligne des quantifications dynamiques Qwen3.6 4 bits et 8 bits pour les appareils MacOS ! Notre algorithme de quantification MLX est encore en évolution, et nous l’affinons activement partout où des améliorations peuvent être apportées.

**Qwen3.6-27B MLX :**

| [3 bits](https://huggingface.co/unsloth/Qwen3.6-27B-UD-MLX-3bit) | [4 bits](https://huggingface.co/unsloth/Qwen3.6-27B-UD-MLX-4bit) | [MXFP4](https://huggingface.co/unsloth/Qwen3.6-27B-UD-MLX-MXFP4) | [NVFP4](https://huggingface.co/unsloth/Qwen3.6-27B-UD-MLX-NVFP4) | [6 bits](https://huggingface.co/unsloth/Qwen3.6-27B-UD-MLX-6bit) | [8 bits](https://huggingface.co/unsloth/Qwen3.6-27B-MLX-8bit) |
| ---------------------------------------------------------------- | ---------------------------------------------------------------- | ---------------------------------------------------------------- | ---------------------------------------------------------------- | ---------------------------------------------------------------- | ------------------------------------------------------------- |

**Qwen3.6-35B-A3B MLX :**

| [3 bits](https://huggingface.co/unsloth/Qwen3.6-35B-A3B-UD-MLX-3bit) | [4 bits](https://huggingface.co/unsloth/Qwen3.6-35B-A3B-UD-MLX-4bit) | [8 bits](https://huggingface.co/unsloth/Qwen3.6-35B-A3B-MLX-8bit) |
| -------------------------------------------------------------------- | -------------------------------------------------------------------- | ----------------------------------------------------------------- |

Pour les essayer, utilisez :

{% code overflow="wrap" %}

```bash
curl -fsSL https://raw.githubusercontent.com/unslothai/unsloth/refs/heads/main/scripts/install_qwen3_6_mlx.sh | sh
source ~/.unsloth/unsloth_qwen3_6_mlx/bin/activate
python -m mlx_vlm.chat --model unsloth/Qwen3.6-27B-UD-MLX-4bit
```

{% endcode %}

Voir ci-dessous les scores de divergence KL (KLD) et de perplexité (PPL) de Qwen3.6-27B (plus bas est meilleur) :

| Modèle                                                           | KLD moyen | KLD médian | PPL   | KLD P90 | KLD P99,9 | Taille  |
| ---------------------------------------------------------------- | --------- | ---------- | ----- | ------- | --------- | ------- |
| [8 bits](https://huggingface.co/unsloth/Qwen3.6-27B-MLX-8bit)    | 0.0028    | 0.0003     | 4.812 | 0.0019  | 0.192     | 34,7 Go |
| [6 bits](https://huggingface.co/unsloth/Qwen3.6-27B-UD-MLX-6bit) | 0.0037    | 0.0007     | 4.809 | 0.0032  | 0.343     | 30,5 Go |
| [4 bits](https://huggingface.co/unsloth/Qwen3.6-27B-UD-MLX-4bit) | 0.0227    | 0.0053     | 4.821 | 0.0293  | 2.339     | 26,2 Go |
| [NVFP4](https://huggingface.co/unsloth/Qwen3.6-27B-UD-MLX-NVFP4) | 0.0325    | 0.0087     | 4.843 | 0.0466  | 3.693     | 26,2 Go |
| [MXFP4](https://huggingface.co/unsloth/Qwen3.6-27B-UD-MLX-MXFP4) | 0.0479    | 0.0153     | 4.902 | 0.0769  | 4.035     | 25,6 Go |
| [3 bits](https://huggingface.co/unsloth/Qwen3.6-27B-UD-MLX-3bit) | 0.0734    | 0.0223     | 4.976 | 0.1261  | 5.529     | 24,1 Go |

### 💡 Réflexion : activer/désactiver + conserver la réflexion

Qwen3.6 dispose également de **Conserver la réflexion** qui laisse la trace de réflexion de la conversation précédente. Cela augmente le nombre de jetons que vous utilisez, mais pourrait améliorer la précision dans les conversations prolongées. Unsloth Studio dispose de bascules 'Think' et 'Conserver la réflexion' pour Qwen3.6 :

<div data-with-frame="true"><figure><img src="/files/31c38c07670d49aecd1964d6f1124e2d504c41ae" alt="" width="563"><figcaption><p>Unsloth Studio a la bascule Think par défaut et une nouvelle <a href="#preserved-thinking">Raisonnement préservé</a> bascule</p></figcaption></figure></div>

Pour activer **conserver la réflexion** dans llama.cpp, utilisez (modifiez en 'true' ou 'false') '`preseve_thinking`' au lieu de '`enable_thinking`' ou '`disable_thinking`'.

{% code expandable="true" %}

```bash
--chat-template-kwargs '{"preserve_thinking":true}'
```

{% endcode %}

Pour la réflexion normale, vous pouvez activer / désactiver la réflexion dans llama.cpp en suivant les commandes ci-dessous. Utilisez '`true`' et '`false`' de manière interchangeable.&#x20;

<table data-full-width="false"><thead><tr><th width="197.76666259765625">Système llama-server :</th><th>Activer la réflexion</th><th>Désactiver la réflexion</th></tr></thead><tbody><tr><td>Linux, MacOS, WSL :</td><td><pre data-overflow="wrap"><code>--chat-template-kwargs '{"enable_thinking":true}'
</code></pre></td><td><pre data-overflow="wrap"><code>--chat-template-kwargs '{"enable_thinking":false}'
</code></pre></td></tr><tr><td>Windows / PowerShell :</td><td><pre data-overflow="wrap"><code>--chat-template-kwargs "{\"enable_thinking\":true}"
</code></pre></td><td><pre data-overflow="wrap"><code>--chat-template-kwargs "{\"enable_thinking\":false}"
</code></pre></td></tr></tbody></table>

À titre d’exemple pour Qwen3.6-35B-A3B afin d’activer la conservation de la réflexion (activée par défaut) :

```bash
./llama.cpp/llama-server \
    --model unsloth/Qwen3.6-35B-A3B-GGUF/Qwen3.6-35B-A3B-BF16.gguf \
    --alias "unsloth/Qwen3.6-35B-A3B-GGUF" \
    --temp 0.6 \
    --top-p 0.95 \
    --top-k 20 \
    --min-p 0.00 \
    --port 8001 \
    --chat-template-kwargs '{"preserve_thinking":true}'
```

Puis en Python :

```python
from openai import OpenAI
import json
openai_client = OpenAI(
    base_url = "http://127.0.0.1:8001/v1",
    api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
    model = "unsloth/Qwen3.6-35B-A3B-GGUF",
    messages = [{"role": "user", "content": "Combien font 2+2 ?"},],
)
print(completion.choices[0].message.content)
print(completion.choices[0].message.reasoning_content)
```

### 👨‍💻 OpenAI Codex et Claude Code <a href="#claude-codex" id="claude-codex"></a>

Pour exécuter le modèle via des charges de travail agentiques locales de codage, vous pouvez [suivre notre guide](/docs/fr/bases/claude-code.md). Il suffit de changer le nom du modèle pour votre variante 'Qwen3.6' et de vous assurer de suivre les bons paramètres Qwen3.6 et les instructions d’utilisation. Utilisez `llama-server` que nous venons juste de mettre en place.

{% columns %}
{% column %}
{% content-ref url="/pages/6c4a155ae35df476974e25b66af4db620dffaf2c" %}
[Claude Code](/docs/fr/bases/claude-code.md)
{% endcontent-ref %}
{% endcolumn %}

{% column %}
{% content-ref url="/pages/0bb2f0a13e244fd2f0ea640c96c4e297bf83db93" %}
[OpenAI Codex](/docs/fr/bases/codex.md)
{% endcontent-ref %}
{% endcolumn %}
{% endcolumns %}

Après avoir suivi les instructions pour Claude Code par exemple, vous verrez :

<div data-with-frame="true"><figure><img src="/files/19582d26040ff1c90cf6e4aaf692124d0f6da048" alt="" width="563"><figcaption></figcaption></figure></div>

Nous pouvons alors demander par exemple `Crée un jeu Python pour les échecs` :

<div><figure><img src="/files/0081141c94f3b9d9f5364616b143f6a10c9a55de" alt="" width="563"><figcaption></figcaption></figure> <figure><img src="/files/085cfe6556c6fc7a1af80d39c5ce906c38393522" alt="" width="563"><figcaption></figcaption></figure> <figure><img src="/files/f6c269d096a141438a03edc4b4f672800846049e" alt="" width="563"><figcaption></figcaption></figure></div>

## 📊 Benchmarks

### Benchmarks GGUF d’Unsloth

Nous avons effectué des benchmarks de divergence KL moyenne pour les GGUF Qwen3.6-35-A3B sur plusieurs fournisseurs afin de vous aider à choisir la meilleure quantification.

* La divergence KL place presque tous les GGUF Unsloth sur la frontière de Pareto SOTA
* Le KLD montre dans quelle mesure un modèle quantifié correspond à la distribution de sortie BF16 originale, indiquant la précision conservée.
* Cela fait d’Unsloth le plus performant dans 21 des 22 tailles
* Seul Q6\_K a été mis à jour pour davantage de couches dynamiques et nous avons introduit un nouveau `UD-IQ4_NL_XL` quant

<div data-with-frame="true"><figure><img src="/files/7d93795853898894656b195d5eef3eab9ccb68ba" alt=""><figcaption><p>35B-A3B - Benchmarks KLD (plus bas est meilleur)</p></figcaption></figure></div>

### Benchmarks MTP

Nous avons évalué les nouvelles quantifications que nous avons créées pour les modèles MoE 27B et 35B. En général, les modèles denses sont beaucoup plus accélérés avec MTP (1,4 à 2x) que les modèles MoE (1,15 à 1,25x).

Grâce à cela, Qwen3.6 27B peut désormais générer 140 tokens/s avec UD-Q2\_K\_XL et Qwen3.6 35B-A3B 220 tokens/s ! Certains chiffres de débit sont bruités, donc n’en déduisez pas que certaines quantifications sont plus lentes que d’autres.

<figure><img src="/files/44ee0aeb91458fa6cebb5afe10b115ba78cf7c53" alt=""><figcaption></figcaption></figure>

En termes d’accélération moyenne, nous observons un 1,4x pour les modèles denses avec draft tokens = 2 et pour les MoE environ 1,15 à 1,2x.

<figure><img src="/files/d8b7a5525322fe5d1bb39ee6326540e02b40297f" alt=""><figcaption></figcaption></figure>

Nous ne recommandons pas plus de 2 jetons brouillons, car le taux d’acceptation chute fortement de 83 % à 50 % avec 4 jetons brouillons, et les passes avant pour MTP deviennent moins avantageuses.

<figure><img src="/files/521a25c2bc1038d09539a37d108ccb538a3ae34e" alt=""><figcaption></figcaption></figure>

### Benchmarks officiels de Qwen

#### Qwen3.6-27B

<div data-with-frame="true"><figure><img src="/files/2240e6ddee55d46df506282f1fa21514b9932435" alt=""><figcaption></figcaption></figure></div>

#### Qwen3.6-35B-A3B

<div data-with-frame="true"><figure><img src="/files/86803b85bb48a728aaddb195c915456bb199a060" alt=""><figcaption></figcaption></figure></div>


---

# 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/qwen3.6.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.