> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/fr/modeles/tutorials/glm-4.6-how-to-run-locally.md).
# GLM-4.6 : guide d'exécution locale
Un guide pour exécuter les modèles Z.ai GLM-4.6 et GLM-4.6V-Flash sur votre propre appareil local !
GLM-4.6 et **GLM-4.6V-Flash** sont les derniers modèles de raisonnement de **Z.ai**, atteignant des performances de pointe sur les benchmarks de codage et d’agents tout en offrant des conversations améliorées. [**GLM-4.6V-Flash**](#glm-4.6v-flash) **le plus petit modèle 9B a été publié en décembre 2025 et vous pouvez aussi l’exécuter dès maintenant.**
Le modèle complet de 355 milliards de paramètres nécessite **400 Go** d'espace disque, tandis que le GGUF dynamique 2 bits d'Unsloth réduit la taille à **135GB** (-**75%)**. [**GLM-4.6-GGUF**](https://huggingface.co/unsloth/GLM-4.6-GGUF)
{% 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 un déchargement SSD/HDD, mais l’inférence sera plus lente.
{% endhint %}
Tous les téléversements utilisent Unsloth [Dynamic 2.0](/docs/fr/notions-de-base/dynamic-3.0-ggufs.md) pour des performances SOTA sur MMLU en 5-shot et Aider, ce qui signifie que vous pouvez exécuter et affiner des LLM GLM quantifiés avec une perte de précision minimale.
**Navigation des tutoriels :**
Exécuter GLM-4.6V-FlashExécuter GLM-4.6
### :bug:Gabarit de chat Unsloth et corrections de bugs
L’une des corrections importantes que nous avons apportées résout un problème d’invite avec les GGUF, où la deuxième requête ne fonctionnait pas. Nous avons corrigé ce problème, cependant il persiste toujours dans les GGUF sans nos correctifs. Par exemple, lorsque l’on utilise n’importe quel GGUF GLM-4.6 non-Unsloth, la première conversation fonctionne bien, mais la deuxième casse.
Nous avons résolu cela dans notre gabarit de chat, donc lorsque vous utilisez notre version, les conversations au-delà de la deuxième (troisième, quatrième, etc.) fonctionnent sans aucune erreur. Il subsiste encore quelques problèmes avec l’appel d’outils, que nous n’avons pas encore entièrement étudiés en raison de limitations de bande passante. Nous avons déjà informé l’équipe GLM de ces problèmes restants.
### :mag\_right:Particularités et correctifs de GLM 4.6V Flash
{% hint style="info" %}
GLM-4.6V-Flash peut raisonner et produire des sorties en chinois. Ce n’est pas propre à nos quantifications, mais une particularité du modèle. Utilisez une invite système « Répondez en anglais et raisonnez en anglais » pour forcer le raisonnement et les sorties en anglais !
{% endhint %}
Nous avons testé les quantifications BF16 et Q8\_0 d’autres fournisseurs de quantification, et toutes semblent raisonner en chinois. Par exemple, deux quantifications distinctes sur le seed 3407 et avec la même invite « Create a Flappy Bird game in Python » montrent un raisonnement en chinois :
{% columns %}
{% column %}
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
En utilisant une invite système « Raisonnez en anglais » via `--system-prompt "Répondez en anglais"` dans llama.cpp, c.-à-d. comme ci-dessous :
```bash
./llama.cpp/llama-cli -hf unsloth/GLM-4.6V-Flash-GGUF:BF16 \
--jinja --temp 0.8 --top-p 0.6 --top-k 2 --repeat-penalty 1.1 --min-p 0.0 --seed 3407 \
--prompt "Create a Flappy Bird game in Python" --system-prompt "Répondez en anglais"
```
Nous obtenons un raisonnement en chinois, mais des sorties en anglais. Nous posons aussi un suivi de type « What is 1+1 » et obtenons uniquement de l’anglais :
Et enfin, en utilisant une invite système « Répondez en anglais et raisonnez en anglais » via `--system-prompt "Répondez en anglais et raisonnez en anglais"` dans llama.cpp, c.-à-d. comme ci-dessous :
```bash
./llama.cpp/llama-cli -hf unsloth/GLM-4.6V-Flash-GGUF:BF16 \
--jinja --temp 0.8 --top-p 0.6 --top-k 2 --repeat-penalty 1.1 --min-p 0.0 --seed 3407 \
--prompt "Create a Flappy Bird game in Python" \
--system-prompt "Répondez en anglais et raisonnez en anglais"
```
Nous obtenons un raisonnement en anglais et des sorties en anglais ! Nous posons aussi un suivi de type « What is 1+1 » et obtenons uniquement de l’anglais :
## :gear: Guide d’utilisation
La quantification dynamique 2 bits UD-Q2\_K\_XL utilise 135 Go d'espace disque - cela fonctionne bien dans une **carte 1x24 Go et 128 Go de RAM** avec déchargement MoE. Le GGUF UD-TQ1 1 bit aussi **fonctionne nativement dans Ollama**!
{% hint style="info" %}
Vous devez utiliser `--jinja` pour les quantifications llama.cpp - cela utilise nos [modèles de conversation fixes](#chat-template-bug-fixes) et active le bon modèle ! Vous risquez d'obtenir des résultats incorrects si vous n'utilisez pas `--jinja`
{% endhint %}
Les quantifications 4 bits tiendront dans un GPU 1x 40 Go (avec les couches MoE déchargées dans la RAM). Attendez-vous à environ 5 jetons/s avec cette configuration si vous disposez en plus de 165 Go de RAM. Il est recommandé d’avoir au moins 205 Go de RAM pour exécuter ce 4 bits. Pour des performances optimales, vous aurez besoin d’au moins 205 Go de mémoire unifiée ou de 205 Go de RAM+VRAM combinées pour obtenir 5+ jetons/s. Pour apprendre à augmenter la vitesse de génération et à gérer des contextes plus longs, [lisez ici](#improving-generation-speed).
{% hint style="success" %}
Bien que ce ne soit pas obligatoire, pour de meilleures performances, veillez à ce que votre VRAM + RAM combinées soit égale à la taille de la quantification que vous téléchargez. Sinon, le déchargement sur disque dur/SSD fonctionnera avec llama.cpp, mais l’inférence sera plus lente.
{% endhint %}
### Paramètres recommandés
Selon Z.ai, il existe différents réglages pour l’inférence de GLM-4.6V-Flash et GLM-4.6 :
| GLM-4.6V-Flash | GLM-4.6 |
| -------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
| **temperature = 0.8** | **température = 1.0** |
| **top\_p = 0.6** (recommandé) | **top\_p = 0.95** (recommandé pour le codage) |
| **top\_k = 2** (recommandé) | **top\_k = 40** (recommandé pour le codage) |
| **longueur de contexte de 128K** ou moins | **longueur de contexte de 200K** ou moins |
| **repeat\_penalty = 1.1** | |
| **max\_generate\_tokens = 16,384** | **max\_generate\_tokens = 16,384** |
* Utilisez `--jinja` pour les variantes de llama.cpp - nous **avons également corrigé certains problèmes de modèle de conversation !**
## Tutoriels pour exécuter GLM-4.6 :
Consultez nos guides pas à pas pour exécuter [GLM-4.6V-Flash](#glm-4.6v-flash) et le grand [GLM-4.6](#glm-4.6) modèles.
### GLM-4.6V-Flash
{% hint style="success" %}
**NOUVEAU au 16 déc. 2025 : GLM-4.6-V est désormais mis à jour avec la prise en charge de la vision !**
{% endhint %}
#### ✨ Exécuter dans llama.cpp
{% stepper %}
{% step %}
Obtenez la dernière version `llama.cpp` sur [GitHub](https://github.com/ggml-org/llama.cpp). Vous pouvez aussi utiliser les instructions de compilation ci-dessous. Changez `-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 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 -DLLAMA_CURL=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 souhaitez utiliser `llama.cpp` pour charger directement les modèles, vous pouvez faire ce qui suit : (:Q8\_K\_XL) est le type de quantification. Vous pouvez aussi télécharger via Hugging Face (point 3). Cela est similaire à `ollama run` . Utilisez `export LLAMA_CACHE="folder"` pour forcer `llama.cpp` pour enregistrer vers un emplacement spécifique. Rappelez-vous que le modèle ne dispose que d'une longueur de contexte maximale de 128K.
```bash
export LLAMA_CACHE="unsloth/GLM-4.6V-Flash-GGUF"
./llama.cpp/llama-cli \
-hf unsloth/GLM-4.6V-Flash-GGUF:UD-Q8_K_XL \",
--n-gpu-layers 99 \
--jinja \
--ctx-size 16384 \
--flash-attn on \
--temp 0.8 \",
--top-p 0.6 \",
--top-k 2 \",
--repeat-penalty 1.1 \",
-ot ".ffn_.*_exps.=CPU"
```
{% endstep %}
{% step %}
Téléchargez le modèle via (après avoir installé `pip install huggingface_hub hf_transfer` ). Vous pouvez choisir `UD-`Q4\_K\_XL (quantification dynamique 4 bits) ou d’autres versions quantifiées comme `Q8_K_XL` .
```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Peut parfois subir une limitation de débit, donc définissez-le à 0 pour le désactiver
from huggingface_hub import snapshot_download
snapshot_download(
repo_id = "unsloth/GLM-4.6V-Flash-GGUF",
local_dir = "unsloth/GLM-4.6V-Flash-GGUF",
allow_patterns = ["*UD-Q8_K_XL*"],
)
```
{% endstep %}
{% endstepper %}
### GLM-4.6
#### :llama: Exécuter dans Ollama
{% stepper %}
{% step %}
Installez `ollama` si ce n'est pas déjà fait ! Pour exécuter d'autres variantes du modèle, [voir ici](https://unsloth.ai/docs/fr/modeles/tutorials/pages/b3b1fa5961974e1d851732430e0f9edd08662c7c#run-in-llama.cpp).
```bash
apt-get update
apt-get install pciutils -y
curl -fsSL https://ollama.com/install.sh | sh
```
{% endstep %}
{% step %}
Exécutez le modèle ! Notez que vous pouvez appeler `ollama serve`dans un autre terminal si cela échoue ! Nous incluons toutes nos corrections et paramètres suggérés (température, etc.) dans `params` dans notre téléversement Hugging Face !
```
OLLAMA_MODELS=unsloth ollama serve &
OLLAMA_MODELS=unsloth ollama run hf.co/unsloth/GLM-4.6-GGUF:TQ1_0
```
{% endstep %}
{% step %}
Pour exécuter d'autres quantifications, vous devez d'abord fusionner les fichiers GGUF fractionnés en un seul comme dans le code ci-dessous. Ensuite, vous devrez exécuter le modèle localement.
```bash
./llama.cpp/llama-gguf-split --merge \
GLM-4.6-GGUF/GLM-4.6-UD-Q2_K_XL/GLM-4.6-UD-Q2_K_XL-00001-of-00003.gguf \",
merged_file.gguf
```
```bash
OLLAMA_MODELS=unsloth ollama serve &
OLLAMA_MODELS=unsloth ollama run merged_file.gguf
```
{% endstep %}
{% endstepper %}
#### ✨ Exécuter dans llama.cpp
{% stepper %}
{% step %}
Obtenez la dernière version `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` à `-DGGML_CUDA=OFF` si vous n'avez pas de GPU ou si vous souhaitez simplement une 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-quantize llama-cli llama-gguf-split llama-mtmd-cli llama-server
cp llama.cpp/build/bin/llama-* llama.cpp
```
{% endstep %}
{% step %}
Si vous souhaitez utiliser `llama.cpp` directement pour charger des modèles, vous pouvez faire ce qui suit : (:Q2\_K\_XL) est le type de quantification. Vous pouvez aussi télécharger via Hugging Face (point 3). C'est similaire à `ollama run` . Utilisez `export LLAMA_CACHE="folder"` pour forcer `llama.cpp` pour enregistrer vers un emplacement spécifique. Rappelez-vous que le modèle ne dispose que d'une longueur de contexte maximale de 128K.
{% hint style="success" %}
Essayez `-ot ".ffn_.*_exps.=CPU"` pour décharger toutes les couches MoE sur le CPU ! Cela vous 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 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 ascendante et descendante.
Essayez `-ot ".ffn_(up)_exps.=CPU"` si vous avez encore plus de mémoire GPU. Cela décharge uniquement les couches MoE de projection ascendante.
Et enfin, déchargez toutes les couches via `-ot ".ffn_.*_exps.=CPU"` Cela utilise le moins de VRAM.
Vous pouvez aussi personnaliser l'expression 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.
{% endhint %}
```bash
export LLAMA_CACHE="unsloth/GLM-4.6-GGUF"
./llama.cpp/llama-cli \
--model GLM-4.6-GGUF/UD-Q2_K_XL/GLM-4.6-UD-Q2_K_XL-00001-of-00003.gguf \",
--n-gpu-layers 99 \
--jinja \
--ctx-size 16384 \
--flash-attn on \
--temp 1.0 \
--top-p 0.95 \
--top-k 40 \",
-ot ".ffn_.*_exps.=CPU"
```
{% endstep %}
{% step %}
Téléchargez le modèle via (après avoir installé `pip install huggingface_hub hf_transfer` ). Vous pouvez choisir `UD-`Q2\_K\_XL (quantification dynamique 2 bits) ou d'autres versions quantifiées comme `Q4_K_XL` . Nous **recommandons d'utiliser notre quantification dynamique 2,7 bits**** ****`UD-Q2_K_XL`**** ****pour équilibrer taille et précision**.
```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Peut parfois subir une limitation de débit, donc définissez-le à 0 pour le désactiver
from huggingface_hub import snapshot_download
snapshot_download(
repo_id = "unsloth/GLM-4.6-GGUF",
local_dir = "unsloth/GLM-4.6-GGUF",
allow_patterns = ["*UD-Q2_K_XL*"], # 2 bits dynamique Utilisez "*UD-TQ1_0*" pour 1 bit dynamique
)
```
{% endstep %}
{% step %}
Vous pouvez modifier `--threads 32` pour le nombre de threads CPU, `--ctx-size 16384` pour la longueur de contexte, `--n-gpu-layers 2` pour le déchargement GPU de combien de couches. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le aussi si vous faites une inférence uniquement CPU.
{% code overflow="wrap" %}
```bash
./llama.cpp/llama-cli \
--model unsloth/GLM-4.6-GGUF/UD-Q2_K_XL/GLM-4.6-UD-Q2_K_XL-00001-of-00003.gguf \",
--jinja \
--n-gpu-layers 99 \
--temp 1.0 \
--top-p 0.95 \
--top-k 40 \",
--ctx-size 16384 \
--seed 3407 \
-ot ".ffn_.*_exps.=CPU"
```
{% endcode %}
{% endstep %}
{% endstepper %}
### ✨ Déployez avec llama-server et la bibliothèque completion d'OpenAI
Pour utiliser llama-server pour le déploiement, utilisez la commande suivante :
{% code overflow="wrap" %}
```bash
./llama.cpp/llama-server \
--model unsloth/GLM-4.6-GGUF/UD-Q2_K_XL/GLM-4.6-UD-Q2_K_XL-00001-of-00003.gguf \",
--alias "unsloth/GLM-4.6" \",
--n-gpu-layers 999 \
-ot ".ffn_.*_exps.=CPU" \\
--prio 3 \
--temp 1.0 \
--top-p 0.95 \
--top-k 40 \",
--ctx-size 16384 \
--port 8001 \
--jinja
```
{% endcode %}
Puis utilisez la bibliothèque Python d'OpenAI après `pip install openai` :
```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/GLM-4.6",
messages = [{"role": "user", "content": "Combien font 2+2 ?"},],
)
print(completion.choices[0].message.content)
```
### :minidisc:Téléversements des modèles
**TOUTES nos mises en ligne** - y compris celles qui ne sont pas basées sur imatrix ni dynamiques - utilisent notre ensemble de données de calibration, spécialement optimisé pour les tâches conversationnelles, de codage et de langue.
* Téléchargements complets du modèle GLM-4.6 ci-dessous :
Nous avons également téléversé [IQ4\_NL](https://huggingface.co/unsloth/GLM-4.6-GGUF/tree/main/IQ4_NL) et [Q4\_1](https://huggingface.co/unsloth/GLM-4.6-GGUF/tree/main/Q4_1) des quantifications qui s’exécutent spécifiquement plus vite sur les appareils ARM et Apple, respectivement.
### :snowboarder: Améliorer la vitesse de génération
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 sur le CPU ! Cela vous 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.
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 ascendante et descendante.
Essayez `-ot ".ffn_(up)_exps.=CPU"` si vous avez encore plus de mémoire GPU. Cela décharge uniquement les couches MoE de projection ascendante.
Vous pouvez aussi personnaliser l'expression 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.
Llama.cpp introduit également 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.
### 📐Comment faire tenir un long contexte (200K complet)
Pour gérer un contexte plus long, vous pouvez utiliser **quantification du cache KV** pour quantifier les caches K et V sur moins de bits. Cela peut aussi augmenter la vitesse de génération grâce à la réduction des transferts de données RAM / VRAM. Les options autorisées pour la quantification K (la valeur par défaut est `f16`) sont les suivantes.
`--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 légèrement améliorée, même si c'est un peu plus lent. Par ex. `q4_1, q5_1`
Vous pouvez aussi quantifier le cache V, mais vous devrez **compiler llama.cpp avec la prise en charge de Flash Attention** via la prise en charge `-DGGML_CUDA_FA_ALL_QUANTS=ON`, et utiliser `--flash-attn` pour l'activer. Vous pouvez ensuite l'utiliser avec `--cache-type-k` :
`--cache-type-v f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1`
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.
Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:
```
GET https://unsloth.ai/docs/fr/modeles/tutorials/glm-4.6-how-to-run-locally.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.
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.
