# GLM-4.6 : Guide d'exécution locale GLM-4.6 et **GLM-4.6V-Flash** sont les derniers modèles de raisonnement de **Z.ai**, atteignant des performances SOTA 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 Unsloth réduit la taille à **135 Go** (-**75%)**. [**GLM-4.6-GGUF**](https://huggingface.co/unsloth/GLM-4.6-GGUF) {% hint style="success" %} Nous avons effectué plusieurs [**corrections du modèle de chat**](#unsloth-chat-template-fixes) pour GLM-4.6 afin de faire `llama.cpp/llama-cli --jinja` fonctionner - veuillez utiliser uniquement `--jinja` sinon la sortie sera incorrecte ! Vous avez demandé des benchmarks sur nos quants, donc nous présentons les résultats d’Aider Polyglot ! Notre DeepSeek V3.1 GGUF Dynamic 3-bit obtient **75.6%**, dépassant de nombreux LLM SOTA en précision complète. [En savoir plus.](/docs/fr/bases/unsloth-dynamic-2.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot.md) {% endhint %} Tous les téléchargements utilisent Unsloth [Dynamic 2.0](/docs/fr/bases/unsloth-dynamic-2.0-ggufs.md) pour des performances SOTA en 5-shot MMLU 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-Flash Exécuter GLM-4.6 ### :bug:Modèle de chat Unsloth et corrections de bogues L’une des corrections importantes que nous avons apportées résout un problème de prompt avec les GGUF, où le second prompt ne fonctionnait pas. Nous avons corrigé ce problème ; cependant, ce souci persiste toujours dans les GGUF sans nos correctifs. Par exemple, lorsqu’on utilise n’importe quel GGUF GLM-4.6 non-Unsloth, la première conversation fonctionne bien, mais la seconde se casse.

Nous avons résolu cela dans notre modèle de chat, donc en utilisant notre version, les conversations au-delà de la deuxième (troisième, quatrième, etc.) fonctionnent sans aucune erreur. Il reste encore quelques problèmes avec l’appel d’outils, que nous n’avons pas encore entièrement examiné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 corrections de GLM 4.6V Flash {% hint style="info" %} GLM-4.6V-Flash peut raisonner et produire du texte en chinois. Ce n’est pas propre à nos quants, mais une particularité du modèle. Utilisez un prompt système du type « Répondez en anglais et raisonnez en anglais » pour forcer le raisonnement et les sorties en anglais ! {% endhint %} Nous avons testé les quants BF16 et Q8\_0 d’autres fournisseurs de quants, et tous semblent raisonner en chinois. Par exemple, 2 quants distincts sur la graine 3407 et avec le même prompt « Create a Flappy Bird game in Python » affichent un raisonnement en chinois : {% columns %} {% column %}

{% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} En utilisant un prompt système « Reason in English » via `--system-prompt "Respond in English"` dans llama.cpp, par exemple 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 "Respond in English" ``` Nous obtenons un raisonnement en chinois, mais des sorties en anglais. Nous posons aussi une question de suivi « What is 1+1 » et obtenons uniquement de l’anglais :

Et enfin, en utilisant un prompt système « Respond in English and reason in English » via `--system-prompt "Respond in English and reason in English"` dans llama.cpp, par exemple 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 "Respond in English and reason in English" ``` Nous obtenons un raisonnement en anglais et des sorties en anglais ! Nous posons aussi une question de suivi « 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 avec **1 carte 24 Go et 128 Go de RAM** avec le déchargement MoE. Le UD-TQ1 GGUF 1 bit **fonctionne aussi nativement dans Ollama**! {% hint style="info" %} Vous devez utiliser `--jinja` pour les quantifications llama.cpp - cela utilise nos [modèles de chat fixes](#chat-template-bug-fixes) et active le bon modèle ! Vous pourriez obtenir des résultats incorrects si vous n'utilisez pas `--jinja` {% endhint %} Les quantifications 4 bits tiendront sur un GPU 1x 40 Go (avec les couches MoE déchargées vers la RAM). Attendez-vous à environ 5 jetons/s avec cette configuration si vous disposez aussi de 165 Go de RAM supplémentaires. Il est recommandé d’avoir au moins 205 Go de RAM pour exécuter ce modèle 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 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 soient égales à 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 llama.cpp - nous **avons aussi corrigé certains problèmes de modèles de chat !** ## Tutoriels pour exécuter GLM-4.6 : Consultez nos guides étape par étape pour exécuter [GLM-4.6V-Flash](#glm-4.6v-flash) et le grand modèle [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 également utiliser 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 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` directement pour charger des modèles, vous pouvez faire ce qui suit : (:Q8\_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` à être enregistré à un emplacement spécifique. N'oubliez pas que le modèle a une longueur de contexte maximale de 128K uniquement. ```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 entraîner une limitation de débit, donc mettre à 0 pour 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 les paramètres suggérés (température, etc.) dans `params` dans notre téléchargement 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 découpé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. Changez `-DGGML_CUDA=ON` en `-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` à être enregistré à un emplacement spécifique. N'oubliez pas que le modèle a une longueur de contexte maximale de 128K uniquement. {% hint style="success" %} Veuillez essayer `-ot ".ffn_.*_exps.=CPU"` pour décharger toutes les couches MoE vers le CPU ! Cela permet effectivement 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 montante 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 montante. Et enfin, déchargez toutes les couches via `-ot ".ffn_.*_exps.=CPU"` Cela utilise le moins de VRAM. 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. {% 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 entraîner une limitation de débit, donc mettre à 0 pour 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*"], # Dynamic 2bit Use "*UD-TQ1_0*" for Dynamic 1bit ) ``` {% endstep %} {% step %} Vous pouvez modifier `--threads 32` pour le nombre de threads CPU, `--ctx-size 16384` pour la longueur du contexte, `--n-gpu-layers 2` pour le déchargement GPU, selon le nombre de couches. Essayez de l’ajuster si votre GPU manque de mémoire. Supprimez-le aussi si vous n'avez qu'une inférence 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éployer avec llama-server et la bibliothèque de complétion 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 %} Ensuite, 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": "What is 2+2?"},], ) print(completion.choices[0].message.content) ``` ### :minidisc:Téléversements du modèle **TOUS nos téléversements** - y compris ceux qui ne sont pas basés sur imatrix ou dynamiques, utilisent notre jeu de données de calibration, spécialement optimisé pour les tâches conversationnelles, de codage et linguistiques. * Téléchargements complets du modèle GLM-4.6 ci-dessous : Nous avons également téléversé [IQ4\_NL](https://huggingface.co/unsloth/DeepSeek-V3.1-GGUF/tree/main/IQ4_NL) et [Q4\_1](https://huggingface.co/unsloth/DeepSeek-V3.1-GGUF/tree/main/Q4_1) des quantifications qui s’exécutent spécifiquement plus rapidement sur les appareils ARM et Apple respectivement.

Bits MoE	Type + Lien	Taille sur disque	Détails
1,66 bit	TQ1_0	84 Go	1,92/1,56 bit
1,78 bit	IQ1_S	96 Go	2,06/1,56 bit
1,93 bit	IQ1_M	107 Go	2.5/2.06/1.56
2,42 bit	IQ2_XXS	115 Go	2,5/2,06 bit
2,71 bit	Q2_K_XL	135 Go	3,5/2,5 bit
3,12 bit	IQ3_XXS	145 Go	3,5/2,06 bit
3,5 bit	Q3_K_XL	158 Go	4,5/3,5 bit
4,5 bit	Q4_K_XL	204 Go	5,5/4,5 bit
5,5 bit	Q5_K_XL	252 Go	6,5/5,5 bit

### :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. Normalement, `-ot ".ffn_.*_exps.=CPU"` décharge toutes les couches MoE vers le CPU ! Cela permet effectivement 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 montante 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 montante. 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. Llama.cpp introduit aussi un mode à haut débit. Utilisez `llama-parallel`. En savoir plus [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 déplacements VRAM / RAM, ce qui peut aussi accélérer le processus de génération. ### 📐Comment adapter un long contexte (200K complet) Pour faire tenir 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 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 meilleure, bien que ce soit un peu plus lent. Par exemple `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 `-DGGML_CUDA_FA_ALL_QUANTS=ON`, et utiliser `--flash-attn` pour l’activer. Ensuite, vous pouvez 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: 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/glm-4.6-how-to-run-locally.md?ask= ``` 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.