> 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/kimi-k2-thinking-how-to-run-locally.md).

# Kimi K2 Thinking : guide d'exécution locale

Guide pour exécuter Kimi-K2-Thinking et Kimi-K2 sur votre propre appareil local !

{% hint style="success" %}
Kimi-K2-Thinking est sorti. Lisez notre [guide de raisonnement](#kimi-k2-thinking-guide) ou accéder à [les GGUF ici](https://huggingface.co/unsloth/Kimi-K2-Thinking-GGUF).

Nous avons également collaboré avec l'équipe Kimi sur [**la correction du prompt système**](#tokenizer-quirks-and-bug-fixes) pour Kimi-K2-Thinking.
{% endhint %}

Kimi-K2 et **Kimi-K2-Thinking** atteignent des performances SOTA en connaissances, raisonnement, codage et tâches agentiques. Les modèles complets de 1T paramètres de Moonshot AI nécessitent 1,09 To d'espace disque, tandis que la version quantifiée **Unsloth Dynamic 1,8 bits** réduit cela à seulement 230 Go (-80 % de taille)**:** [**Kimi-K2-GGUF**](https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF)

Vous pouvez également exécuter désormais notre [**Kimi-K2-Thinking** GGUF](https://huggingface.co/unsloth/Kimi-K2-Thinking-GGUF).

Tous les téléversements utilisent Unsloth [Dynamic 2.0](/docs/fr/notions-de-base/dynamic-3.0-ggufs.md) pour du SOTA [Aider Polyglot](/docs/fr/notions-de-base/dynamic-3.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot.md) et les performances MMLU en 5-shot. Voyez comment nos GGUF dynamiques 1–2 bits se comportent sur [les benchmarks de codage ici](/docs/fr/notions-de-base/dynamic-3.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot.md).

<a href="#kimi-k2-thinking-guide" class="button primary">Exécuter Thinking</a><a href="#kimi-k2-instruct-guide" class="button primary">Exécuter Instruct</a>

### :gear: Configuration recommandée

{% hint style="info" %}
Vous avez besoin de **247 Go d'espace disque** pour exécuter la quantification 1 bit !

La seule exigence est **`espace disque + RAM + VRAM ≥ 247 Go`**. Cela signifie que vous n'avez pas besoin d'autant de RAM ou de VRAM (GPU) pour exécuter le modèle, mais ce sera beaucoup plus lent.
{% endhint %}

La quantification 1,8 bits (UD-TQ1\_0) tient dans 1 GPU de 24 Go (avec toutes les couches MoE déchargées vers la RAM système ou un disque rapide). Attendez-vous à environ \~1-2 jetons/s avec cette configuration si vous disposez aussi de 256 Go de RAM supplémentaires. La quantification Q8 complète de Kimi K2 fait 1,09 To et nécessitera au moins 8 GPU H200.

Pour des performances optimales, vous aurez besoin d'au moins **247 Go de mémoire unifiée ou 247 Go de RAM+VRAM combinées** pour 5+ jetons/s. Si vous avez moins de 247 Go de RAM+VRAM combinées, alors la vitesse du modèle en souffrira certainement.

**Si vous n'avez pas 247 Go de RAM+VRAM, pas d'inquiétude !** llama.cpp intègre nativement **le déchargement sur disque**, donc via le mmap, cela fonctionnera quand même, simplement ce sera plus lent - par exemple, auparavant vous pouviez obtenir 5 à 10 jetons / seconde, maintenant c'est moins d'1 jeton.

Nous vous suggérons d'utiliser notre **UD-Q2\_K\_XL (360 Go)** quantification pour équilibrer taille et précision !

{% hint style="success" %}
Pour de meilleures performances, faites en sorte que votre VRAM + RAM combinées = la taille de la quantification que vous téléchargez. Sinon, cela fonctionnera quand même via le déchargement sur disque, mais ce sera plus lent !
{% endhint %}

## 💭Guide Kimi-K2-Thinking

Kimi-K2-Thinking devrait généralement suivre les mêmes instructions que le modèle Instruct, avec quelques différences clés, notamment dans des domaines tels que les paramètres et le modèle de chat.

{% hint style="success" %}
**Pour exécuter le modèle en précision complète, il suffit d'utiliser les GGUF dynamiques 4 bits ou 5 bits (par ex. UD\_Q4\_K\_XL), car le modèle a été initialement publié au format INT4.**

Vous pouvez choisir une quantification à plus grand nombre de bits par prudence en cas de petites différences de quantification, mais dans la plupart des cas cela est inutile.
{% endhint %}

### 🌙 Paramètres recommandés officiels :

Selon [Moonshot AI](https://huggingface.co/moonshotai/Kimi-K2-Thinking), voici les paramètres recommandés pour l'inférence de Kimi-K2-Thinking :

* Réglez la <mark style="background-color:green;">**température 1,0**</mark> pour réduire les répétitions et l’incohérence.
* Longueur de contexte suggérée = 98 304 (jusqu'à 256K)
* Remarque : l'utilisation de différents outils peut nécessiter des paramètres différents

{% hint style="info" %}
Nous recommandons de régler <mark style="background-color:green;">**min\_p à 0,01**</mark> afin de supprimer l'apparition de jetons peu probables à faible probabilité.
{% endhint %}

Par exemple, avec un message utilisateur « What is 1+1? », nous obtenons :

{% code overflow="wrap" %}

```
<|im_system|>system<|im_middle|>Vous êtes Kimi, un assistant IA créé par Moonshot AI.<|im_end|><|im_user|>user<|im_middle|>Combien font 1+1 ?<|im_end|><|im_assistant|>assistant<|im_middle|>
```

{% endcode %}

### ✨ Exécutez Kimi K2 Thinking dans llama.cpp

{% hint style="success" %}
Vous pouvez désormais utiliser la dernière mise à jour de [llama.cpp](https://github.com/ggml-org/llama.cpp) pour exécuter le modèle :
{% endhint %}

1. 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. **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-quantize llama-cli llama-gguf-split llama-mtmd-cli
cp llama.cpp/build/bin/llama-* llama.cpp
```

2. Si vous souhaitez utiliser `llama.cpp` pour charger directement les modèles, vous pouvez faire ce qui suit : (:UD-TQ1\_0) 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 à un emplacement spécifique.

```bash
export LLAMA_CACHE="unsloth/Kimi-K2-Thinking-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/Kimi-K2-Thinking-GGUF:UD-TQ1_0 \\
    --n-gpu-layers 99 \
    --temp 1.0 \
    --min-p 0.01 \
    --ctx-size 16384 \
    --seed 3407 \
    -ot ".ffn_.*_exps.=CPU"
```

3. Ce qui précède utilisera environ 8 Go de mémoire GPU. Si vous avez environ 360 Go de mémoire GPU combinée, supprimez `-ot ".ffn_.*_exps.=CPU"` pour obtenir la vitesse maximale !

{% hint style="info" %}
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 %}

3. Téléchargez le modèle via (après avoir installé `pip install huggingface_hub hf_transfer`  ). Nous recommandons d'utiliser notre quantification dynamique 2 bits UD-Q2\_K\_XL pour équilibrer taille et précision. Toutes les versions à : [huggingface.co/unsloth/Kimi-K2-Thinking-GGUF](https://huggingface.co/unsloth/Kimi-K2-Thinking-GGUF)

{% code overflow="wrap" %}

```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/Kimi-K2-Thinking-GGUF",
    local_dir = "unsloth/Kimi-K2-Thinking-GGUF",
    allow_patterns = ["*UD-TQ1_0*"], # Utilisez "*UD-Q2_K_XL*" pour la quantification dynamique 2 bits (381 Go)
)
```

{% endcode %}

{% hint style="info" %}
Si vous constatez que les téléchargements se bloquent à environ 90 à 95 % ou plus, veuillez consulter <https://docs.unsloth.ai/basics/troubleshooting-and-faqs#downloading-gets-stuck-at-90-to-95>
{% endhint %}

4. Exécutez n'importe quelle invite.
5. Modifier `--threads -1` pour le nombre de threads CPU (par défaut, il est réglé sur le nombre maximal de threads CPU), `--ctx-size 16384` pour la longueur de contexte, `--n-gpu-layers 99` pour le déchargement GPU sur le nombre de couches. Réglez-le sur 99 combiné au déchargement CPU MoE pour obtenir les meilleures performances. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le également si vous faites une inférence CPU uniquement.

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \
    --model unsloth/Kimi-K2-Thinking-GGUF/UD-TQ1_0/Kimi-K2-Thinking-UD-TQ1_0-00001-of-00006.gguf \\
    --n-gpu-layers 99 \
    --temp 1.0 \
    --min-p 0.01 \
    --ctx-size 16384 \
    --seed 3407 \
    -ot ".ffn_.*_exps.=CPU"
```

{% endcode %}

### :thinking:**Pas de balises Thinking ?**

Vous pourriez remarquer qu'il n'y a pas de *réflexion* balises lorsque vous exécutez le modèle. C'est normal et prévu.

Dans votre `llama.cpp` script, assurez-vous d'inclure le `--special` drapeau tout à la fin de votre commande. Une fois cela fait, vous verrez le `<think>` jeton apparaître comme prévu.

Vous pourriez aussi voir chaque réponse se terminer par `<|im_end|>`. C'est normal car `<|im_end|>` est un jeton spécial qui apparaît lors de l'affichage des jetons spéciaux. Si vous souhaitez le masquer, vous pouvez définir `<|im_end|>` comme chaîne d'arrêt dans vos paramètres.

### ✨ Déployez avec llama-server et la bibliothèque completion d'OpenAI

Après avoir installé llama.cpp conformément à [#run-kimi-k2-thinking-in-llama.cpp](#run-kimi-k2-thinking-in-llama.cpp "mention"), vous pouvez utiliser ce qui suit pour lancer un serveur compatible OpenAI :

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-server \
    --model unsloth/Kimi-K2-Thinking-GGUF/UD-TQ1_0/Kimi-K2-Thinking-UD-TQ1_0-00001-of-00006.gguf \\
    --alias "unsloth/Kimi-K2-Thinking" \\
    -fa on \\
    --n-gpu-layers 999 \
    -ot ".ffn_.*_exps.=CPU" \\
    --min-p 0.01 \
    --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
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/Kimi-K2-Thinking",
    messages = [{"role": "user", "content": "Combien font 2+2 ?"},],
)
print(completion.choices[0].message.content)
```

## :mag:Particularités du tokenizer et corrections de bugs

**7 novembre 2025 : nous avons averti l'équipe Kimi et corrigé le prompt système par défaut de** `Vous êtes Kimi, un assistant IA créé par Moonshot AI.` **qui ne s'affichait pas sur la première invite utilisateur !** Voir <https://huggingface.co/moonshotai/Kimi-K2-Thinking/discussions/12>

Un immense merci à l'équipe Moonshot Kimi pour son temps de réponse extrêmement rapide à nos questions et pour avoir corrigé le problème au plus vite !

**16 juillet 2025 : Kimi K2 a mis à jour son tokenizer pour permettre plusieurs appels d'outils** conformément à <https://x.com/Kimi_Moonshot/status/1945050874067476962>

**18 juillet 2025 : nous avons corrigé un prompt système - Kimi a également tweeté à propos de notre correction ici :** <https://x.com/Kimi_Moonshot/status/1946130043446690030>. La correction a également été décrite ici : <https://huggingface.co/moonshotai/Kimi-K2-Instruct/discussions/28>

Si vous avez téléchargé les anciens checkpoints - pas d'inquiétude - téléchargez simplement le premier split GGUF qui a été modifié. OU si vous ne souhaitez télécharger aucun nouveau fichier, faites :

```bash
wget https://huggingface.co/unsloth/Kimi-K2-Instruct/raw/main/chat_template.jinja
./llama.cpp ... --chat-template-file /dir/to/chat_template.jinja
```

Le tokenizer Kimi K2 était intéressant à manipuler - <mark style="background-color:green;">**il fonctionne pour l'essentiel de manière similaire au tokenizer de GPT-4o**</mark>! Nous le voyons d'abord dans le [tokenization\_kimi.py](https://huggingface.co/moonshotai/Kimi-K2-Instruct/blob/main/tokenization_kimi.py) fichier l'expression régulière (regex) suivante utilisée par Kimi K2 :

```python
pat_str = "|".join(
    [
        r"""[\p{Han}]+""",
        r"""[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}&&[^\p{Han}]]*[\p{Ll}\p{Lm}\p{Lo}\p{M}&&[^\p{Han}]]+(?i:'s|'t|'re|'ve|'m|'ll|'d)?""",
        r"""[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}&&[^\p{Han}]]+[\p{Ll}\p{Lm}\p{Lo}\p{M}&&[^\p{Han}]]*(?i:'s|'t|'re|'ve|'m|'ll|'d)?""",
        r"""\p{N}{1,3}""",
        r""" ?[^\s\p{L}\p{N}]+[\r\n]*""",
        r"""\s*[\r\n]+""",
        r"""\s+(?!\S)""",
        r"""\s+""",
    ]
)
```

Après examen attentif, nous constatons que la regex du tokenizer de Kimi K2 est presque identique à celle de GPT-4o, que l'on peut trouver dans [le code source de llama.cpp](https://github.com/ggml-org/llama.cpp/blob/55c509daf51d25bfaee9c8b8ce6abff103d4473b/src/llama-vocab.cpp#L400).

{% code overflow="wrap" %}

```
[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]*[\p{Ll}\p{Lm}\p{Lo}\p{M}]+(?i:'s|'t|'re|'ve|'m|'ll|'d)?|[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]+[\p{Ll}\p{Lm}\p{Lo}\p{M}]*(?i:'s|'t|'re|'ve|'m|'ll|'d)?|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n/]*|\s*[\r\n]+|\s+(?!\S)|\s+
```

{% endcode %}

Les deux tokenisent les nombres en groupes de 1 à 3 chiffres (9, 99, 999) et utilisent des schémas similaires. La seule différence semble être la gestion des caractères « Han » ou chinois, que le tokenizer de Kimi traite davantage. [La PR](https://github.com/ggml-org/llama.cpp/pull/14654) par <https://github.com/gabriellarson> gère bien ces différences après quelques [discussions ici](https://github.com/ggml-org/llama.cpp/issues/14642#issuecomment-3067324745).

<mark style="background-color:green;">**Nous constatons également que le bon jeton EOS ne doit pas être \[EOS], mais plutôt <|im\_end|>, ce que nous avons aussi corrigé dans nos conversions de modèles.**</mark>

## 🌝Guide Kimi-K2-Instruct

Guide étape par étape pour exécuter les modèles Kimi K2 Instruct, y compris Kimi K2 0905 - la mise à jour du 5 septembre.

### 🌙 Paramètres recommandés officiels :

Selon [Moonshot AI](https://huggingface.co/moonshotai/Kimi-K2-Instruct), voici les paramètres recommandés pour l'inférence de Kimi K2 :

* Réglez la <mark style="background-color:green;">**température à 0,6**</mark> pour réduire les répétitions et l’incohérence.
* Le prompt système par défaut original est :

  ```
  Vous êtes un assistant utile
  ```
* (Facultatif) Moonshot suggère également ce qui suit pour le prompt système :

  ```
  Vous êtes Kimi, un assistant IA créé par Moonshot AI.
  ```

{% hint style="success" %}
Nous recommandons de régler <mark style="background-color:green;">**min\_p à 0,01**</mark> afin de supprimer l'apparition de jetons peu probables à faible probabilité.
{% endhint %}

### :1234: Modèle de chat et format du prompt

Kimi Chat utilise bien un BOS (jeton de début de phrase). Les rôles système, utilisateur et assistant sont tous encadrés par `<|im_middle|>` ce qui est intéressant, et chacun obtient son propre jeton respectif `<|im_system|>, <|im_user|>, <|im_assistant|>`.

{% code overflow="wrap" %}

```python
<|im_system|>system<|im_middle|>Vous êtes un assistant utile<|im_end|><|im_user|>user<|im_middle|>Combien font 1+1 ?<|im_end|><|im_assistant|>assistant<|im_middle|>2<|im_end|>
```

{% endcode %}

Pour séparer les limites de la conversation (vous devez supprimer chaque nouvelle ligne), on obtient :

{% code overflow="wrap" %}

```
<|im_system|>system<|im_middle|>Vous êtes un assistant utile<|im_end|>
<|im_user|>user<|im_middle|>Combien font 1+1 ?<|im_end|>
2
```

{% endcode %}

### :floppy\_disk: Téléversements des modèles

**TOUTES nos mises en ligne** - 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 de raisonnement.

<table data-full-width="false"><thead><tr><th>Bits MoE</th><th>Type + lien</th><th>Taille sur disque</th><th>Détails</th></tr></thead><tbody><tr><td>1,66 bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-TQ1_0">UD-TQ1_0</a></td><td><strong>245GB</strong></td><td>1,92/1,56 bit</td></tr><tr><td>1,78 bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-IQ1_S">UD-IQ1_S</a></td><td><strong>281GB</strong></td><td>2,06/1,56 bit</td></tr><tr><td>1,93 bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-IQ1_M">UD-IQ1_M</a></td><td><strong>304GB</strong></td><td>2.5/2.06/1.56</td></tr><tr><td>2,42 bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-IQ2_XXS">UD-IQ2_XXS</a></td><td><strong>343GB</strong></td><td>2,5/2,06 bit</td></tr><tr><td>2,71 bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-Q2_K_XL">UD-Q2_K_XL</a></td><td><strong>381GB</strong></td><td>3,5/2,5 bit</td></tr><tr><td>3,12 bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-IQ3_XXS">UD-IQ3_XXS</a></td><td><strong>417GB</strong></td><td>3,5/2,06 bit</td></tr><tr><td>3,5 bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-Q3_K_XL">UD-Q3_K_XL</a></td><td><strong>452GB</strong></td><td>4,5/3,5 bit</td></tr><tr><td>4,5 bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-Q4_K_XL">UD-Q4_K_XL</a></td><td><strong>588GB</strong></td><td>5,5/4,5 bit</td></tr><tr><td>5,5 bit</td><td><a href="https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF/tree/main/UD-Q5_K_XL">UD-Q5_K_XL</a></td><td><strong>732GB</strong></td><td>6,5/5,5 bit</td></tr></tbody></table>

Nous avons également téléversé des versions au format [BF16](https://huggingface.co/unsloth/Kimi-K2-Instruct-BF16).

### ✨ Exécutez Instruct dans llama.cpp

1. 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
cp llama.cpp/build/bin/llama-* llama.cpp
```

2. Si vous souhaitez utiliser `llama.cpp` pour charger directement les modèles, vous pouvez faire ce qui suit : (:UD-IQ1\_S) 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 à un emplacement spécifique.\ <mark style="background-color:green;">**Pour exécuter la nouvelle mise à jour de septembre 2025 du modèle, remplacez le nom du modèle de 'Kimi-K2-Instruct' par 'Kimi-K2-Instruct-0905'.**</mark>

{% hint style="info" %}
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/Kimi-K2-Instruct-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/Kimi-K2-Instruct-GGUF:TQ1_0 \\
    --n-gpu-layers 99 \
    --temp 0.6 \
    --min-p 0.01 \
    --ctx-size 16384 \
    --seed 3407 \
    -ot ".ffn_.*_exps.=CPU"
```

3. Téléchargez le modèle via (après avoir installé `pip install huggingface_hub hf_transfer` ). Vous pouvez choisir `UD-TQ1_0`(quantification dynamique 1,8 bits) ou d'autres versions quantifiées comme `Q2_K_XL` . Nous <mark style="background-color:green;">**nous recommandons d’utiliser notre quantification dynamique 2 bits**</mark><mark style="background-color:green;">**&#x20;**</mark><mark style="background-color:green;">**`UD-Q2_K_XL`**</mark><mark style="background-color:green;">**&#x20;**</mark><mark style="background-color:green;">**pour équilibrer taille et précision**</mark>. Plus de versions sur : [huggingface.co/unsloth/Kimi-K2-Instruct-GGUF](https://huggingface.co/unsloth/Kimi-K2-Instruct-GGUF)

{% code overflow="wrap" %}

```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/Kimi-K2-Instruct-GGUF",
    local_dir = "unsloth/Kimi-K2-Instruct-GGUF",
    allow_patterns = ["*UD-TQ1_0*"], # Quantification dynamique 1 bit (281 Go) Utilisez "*UD-Q2_K_XL*" pour la quantification dynamique 2 bits (381 Go)
)
```

{% endcode %}

{% hint style="info" %}
Si vous constatez que les téléchargements se bloquent à environ 90 à 95 % ou plus, veuillez consulter <https://docs.unsloth.ai/basics/troubleshooting-and-faqs#downloading-gets-stuck-at-90-to-95>
{% endhint %}

4. Exécutez n'importe quelle invite.
5. Modifier `--threads -1` pour le nombre de threads CPU (par défaut, il est réglé sur le nombre maximal de threads CPU), `--ctx-size 16384` pour la longueur de contexte, `--n-gpu-layers 99` pour le déchargement GPU sur le nombre de couches. Réglez-le sur 99 combiné au déchargement CPU MoE pour obtenir les meilleures performances. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le également si vous faites une inférence CPU uniquement.

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \
    --model unsloth/Kimi-K2-Instruct-GGUF/UD-TQ1_0/Kimi-K2-Instruct-UD-TQ1_0-00001-of-00005.gguf \\
    --n-gpu-layers 99 \
    --temp 0.6 \
    --min-p 0.01 \
    --ctx-size 16384 \
    --seed 3407 \
    -ot ".ffn_.*_exps.=CPU"
```

{% endcode %}

### :bird: Flappy Bird + autres tests <a href="#heptagon-test" id="heptagon-test"></a>

Nous avons introduit le test Flappy Bird lorsque nos quantifications 1,58 bit pour DeepSeek R1 ont été fournies. Nous avons constaté que Kimi K2 était l'un des seuls modèles à réussir en one-shot toutes nos tâches, y compris celle-ci, [Heptagone ](/docs/fr/modeles/tutorials/deepseek-r1-0528-how-to-run-locally.md#heptagon-test)et les autres tests même en 2 bits. L'objectif est de demander au LLM de créer un jeu Flappy Bird en suivant quelques instructions spécifiques :

{% code overflow="wrap" %}

```
Créez un jeu Flappy Bird en Python. Vous devez inclure les éléments suivants :
1. Tu dois utiliser pygame.
2. La couleur d’arrière-plan doit être choisie aléatoirement et être une teinte claire. Commence par une couleur bleu clair.
3. Appuyer plusieurs fois sur ESPACE accélérera l’oiseau.
4. La forme de l’oiseau doit être choisie aléatoirement parmi un carré, un cercle ou un triangle. La couleur doit être choisie aléatoirement parmi des couleurs foncées.
5. Place en bas un sol coloré en brun foncé ou en jaune, choisi aléatoirement.
6. Affiche un score en haut à droite. Incrémente-le si tu passes les tuyaux sans les heurter.
7. Crée des tuyaux espacés aléatoirement avec suffisamment d’espace. Colore-les aléatoirement en vert foncé, brun clair ou dans une teinte de gris foncé.
8. Lorsque tu perds, affiche le meilleur score. Le texte doit se trouver à l’intérieur de l’écran. Appuyer sur q ou Échap quittera le jeu. Pour redémarrer, appuie à nouveau sur ESPACE.
Le jeu final doit se trouver dans une section markdown en Python. Vérifiez votre code pour détecter les erreurs et corrigez-les avant la section markdown finale.
```

{% endcode %}

Vous pouvez également tester les quantifications dynamiques via le test de l'heptagone conformément à [r/Localllama](https://www.reddit.com/r/LocalLLaMA/comments/1j7r47l/i_just_made_an_animation_of_a_ball_bouncing/) qui teste le modèle sur la création d'un moteur physique de base simulant des balles tournant dans un heptagone fermé en mouvement.

<figure><img src="https://docs.unsloth.ai/~gitbook/image?url=https%3A%2F%2F3215535692-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252FxhOjnexMCB3dmuQFQ2Zq%252Fuploads%252F2O72oTw5yPUbcxXjDNKS%252Fsnapshot.jpg%3Falt%3Dmedia%26token%3Dce852f9f-20ee-4b93-9d7b-1a5f211b9e04&#x26;width=768&#x26;dpr=4&#x26;quality=100&#x26;sign=55d1134d&#x26;sv=2" alt="" width="563"><figcaption></figcaption></figure>

L'objectif est de faire tourner l'heptagone, et les balles dans l'heptagone doivent bouger. L'invite est ci-dessous :

{% code overflow="wrap" %}

```
Écrivez un programme Python qui montre 20 balles rebondissant à l'intérieur d'un heptagone en rotation :\n- Toutes les balles ont le même rayon.\n- Chaque balle porte un numéro de 1 à 20.\n- Toutes les balles tombent depuis le centre de l'heptagone au démarrage.\n- Couleurs : #f8b862, #f6ad49, #f39800, #f08300, #ec6d51, #ee7948, #ed6d3d, #ec6800, #ec6800, #ee7800, #eb6238, #ea5506, #ea5506, #eb6101, #e49e61, #e45e32, #e17b34, #dd7a56, #db8449, #d66a35\n- Les balles doivent être affectées par la gravité et la friction, et elles doivent rebondir de manière réaliste sur les parois en rotation. Il doit également y avoir des collisions entre les balles.\n- Le matériau de toutes les balles doit faire en sorte que la hauteur de rebond à l'impact ne dépasse pas le rayon de l'heptagone, mais soit supérieure au rayon de la balle.\n- Toutes les balles tournent avec friction ; les numéros sur la balle peuvent être utilisés pour indiquer la rotation de la balle.\n- L'heptagone tourne autour de son centre, et sa vitesse de rotation est de 360 degrés toutes les 5 secondes.\n- La taille de l'heptagone doit être suffisamment grande pour contenir toutes les balles.\n- N'utilisez pas la bibliothèque pygame ; implémentez vous-même les algorithmes de détection de collision et de réponse aux collisions, etc. Les bibliothèques Python suivantes sont autorisées : tkinter, math, numpy, dataclasses, typing, sys.\n- Tout le code doit être placé dans un seul fichier Python.
```

{% endcode %}


---

# 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/kimi-k2-thinking-how-to-run-locally.md?ask=<question>&goal=<user_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.