# Grok 2 Vous pouvez maintenant exécuter **Grok 2** (alias Grok 2.5), le modèle de 270 milliards de paramètres par xAI. La précision complète nécessite **539 Go**, tandis que la version dynamique 3 bits Unsloth réduit la taille à seulement **118 Go** (une réduction de 75%). GGUF : [Grok-2-GGUF](https://huggingface.co/unsloth/grok-2-GGUF) La **3-bit Q3\_K\_XL** le modèle fonctionne sur un seul **Mac 128 Go** ou **24 Go de VRAM + 128 Go de RAM**, atteignant **5+ tokens/s** pour l'inférence. Merci à l'équipe llama.cpp et à la communauté pour [le support de Grok 2](https://github.com/ggml-org/llama.cpp/pull/15539) et d'avoir rendu cela possible. Nous avons également été heureux d'avoir un peu aidé en chemin ! Tous les téléchargements utilisent Unsloth [méthodologie Dynamic 2.0](https://unsloth.ai/docs/fr/bases/unsloth-dynamic-2.0-ggufs) pour des performances SOTA en MMLU 5-shot et divergence KL, ce qui signifie que vous pouvez exécuter des Grok LLM quantifiés avec une perte d'exactitude minimale. Exécuter le tutoriel llama.cpp ## :gear: Paramètres recommandés La quantification dynamique 3 bits utilise 118 Go (126 Gio) d'espace disque - cela fonctionne bien sur un Mac avec mémoire unifiée de 128 Go de RAM ou sur une carte 1x24Go et 128 Go de RAM. Il est recommandé d'avoir au moins 120 Go de RAM pour exécuter cette quantification 3 bits. {% hint style="warning" %} Vous devez utiliser `--jinja` pour Grok 2. Vous pourriez obtenir des résultats incorrects si vous n'utilisez pas `--jinja` {% endhint %} La quantification 8 bits fait \~300 Go et tiendra sur un GPU 1x 80Go (avec les couches MoE déchargées en RAM). Attendez-vous à environ 5 tokens/s avec cette configuration si vous disposez également de 200 Go de RAM supplémentaires. Pour apprendre comment augmenter la vitesse de génération et prendre en charge des contextes plus longs, [lire ici](#improving-generation-speed). {% hint style="info" %} Bien que ce ne soit pas obligatoire, pour de meilleures performances, faites en sorte que votre VRAM + RAM combinées égalent la taille de la quantification que vous téléchargez. Sinon, le déchargement sur disque dur / SSD fonctionnera avec llama.cpp, simplement l'inférence sera plus lente. {% endhint %} ### Paramètres d'échantillonnage * Grok 2 a une longueur de contexte maximale de 128K, donc utilisez `131,072` contexte ou moins. * Utilisez `--jinja` pour les variantes llama.cpp Il n'existe pas de paramètres d'échantillonnage officiels pour exécuter le modèle, vous pouvez donc utiliser les valeurs par défaut standard pour la plupart des modèles : * Définissez le **température = 1.0** * **Min\_P = 0.01** (optionnel, mais 0,01 fonctionne bien, la valeur par défaut de llama.cpp est 0,1) ## Exécuter le tutoriel Grok 2 : Actuellement, vous ne pouvez exécuter Grok 2 que dans llama.cpp. ### ✨ Exécuter dans llama.cpp {% stepper %} {% step %} Installez la `llama.cpp` PR spécifique pour Grok 2 sur [GitHub ici](https://github.com/ggml-org/llama.cpp/pull/15539). Vous pouvez aussi 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 voulez simplement de l'inférence CPU. **Pour les appareils Apple Mac / Metal**, définissez `-DGGML_CUDA=OFF` puis continuez comme d'habitude - le support Metal est activé par défaut. ```bash apt-get update apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y git clone https://github.com/ggml-org/llama.cpp cd llama.cpp && git fetch origin pull/15539/head:MASTER && git checkout MASTER && cd .. 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 voulez utiliser `llama.cpp` directement pour charger les modèles, vous pouvez faire ce qui suit : (:Q3\_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="dossier"` pour forcer `llama.cpp` à enregistrer à un emplacement spécifique. Rappelez-vous que le modèle a seulement une longueur de contexte maximale de 128K. {% hint style="info" %} Veuillez essayer `-ot ".ffn_.*_exps.=CPU"` pour décharger toutes les couches MoE sur le CPU ! Cela vous permet effectivement de placer toutes les couches non-MoE sur 1 GPU, améliorant les vitesses de génération. Vous pouvez personnaliser l'expression regex pour décharger plus de couches si vous 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 up et down. Essayez `-ot ".ffn_(up)_exps.=CPU"` si vous avez encore plus de mémoire GPU. Cela ne décharge que les couches MoE de projection up. Et enfin déchargez toutes les couches via `-ot ".ffn_.*_exps.=CPU"` Ceci 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/grok-2-GGUF" ./llama.cpp/llama-cli \ -hf unsloth/grok-2-GGUF:Q3_K_XL \ --jinja \ --n-gpu-layers 99 \ --temp 1.0 \ --top-p 0.95 \ --min-p 0.01 \ --ctx-size 16384 \ --seed 3407 \ -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-Q3_K_XL` (quantification dynamique 3 bits) ou d'autres versions quantifiées comme `Q4_K_M` . Nous **recommandons d'utiliser notre quant dynamique 2,7 bits**** ****`UD-Q2_K_XL`**** ****ou ci-dessus 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 limiter le débit, donc mettez à 0 pour désactiver from huggingface_hub import snapshot_download snapshot_download( repo_id = "unsloth/grok-2-GGUF", local_dir = "unsloth/grok-2-GGUF", allow_patterns = ["*UD-Q3_K_XL*"], # Dynamic 3bit ) ``` {% 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 sur GPU du nombre de couches. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le également si vous avez uniquement une inférence CPU. {% code overflow="wrap" %} ```bash ./llama.cpp/llama-cli \ --model unsloth/grok-2-GGUF/UD-Q3_K_XL/grok-2-UD-Q3_K_XL-00001-of-00003.gguf \ --jinja \ --threads -1 \ --n-gpu-layers 99 \ --temp 1.0 \ --top_p 0.95 \ --min_p 0.01 \ --ctx-size 16384 \ --seed 3407 \ -ot ".ffn_.*_exps.=CPU" ``` {% endcode %} {% endstep %} {% endstepper %} ## Uploads de modèles **TOUS nos uploads** - y compris ceux qui ne sont pas basés sur imatrix ou dynamiques, utilisent notre jeu de données de calibration, qui est spécialement optimisé pour les tâches conversationnelles, de codage et linguistiques. | Bits MoE | Type + Lien | Taille sur disque | Détails | | -------- | ----------------------------------------------------------------------------------- | ----------------- | ------------- | | 1,66 bit | [TQ1\_0](https://huggingface.co/unsloth/grok-2-GGUF/blob/main/grok-2-UD-TQ1_0.gguf) | **81,8 Go** | 1,92/1,56 bit | | 1,78 bit | [IQ1\_S](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-IQ1_S) | **88,9 Go** | 2,06/1,56 bit | | 1,93 bit | [IQ1\_M](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-IQ1_M) | **94,5 Go** | 2.5/2.06/1.56 | | 2,42 bit | [IQ2\_XXS](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-IQ2_XXS) | **99,3 Go** | 2,5/2,06 bit | | 2,71 bit | [Q2\_K\_XL](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-Q2_K_XL) | **112 Go** | 3,5/2,5 bit | | 3,12 bit | [IQ3\_XXS](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-IQ3_XXS) | **117 Go** | 3,5/2,06 bit | | 3,5 bit | [Q3\_K\_XL](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-Q3_K_XL) | **126 Go** | 4,5/3,5 bit | | 4,5 bit | [Q4\_K\_XL](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-Q4_K_XL) | **155 Go** | 5,5/4,5 bit | | 5,5 bit | [Q5\_K\_XL](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-Q5_K_XL) | **191 Go** | 6,5/5,5 bit | ## :snowboarder: Amélioration de la vitesse de génération Si vous avez plus de VRAM, vous pouvez essayer de décharger plus 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 effectivement de placer toutes les couches non-MoE sur 1 GPU, améliorant les vitesses de génération. Vous pouvez personnaliser l'expression regex pour décharger plus de couches si vous 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 up et down. Essayez `-ot ".ffn_(up)_exps.=CPU"` si vous avez encore plus de mémoire GPU. Cela ne décharge que les couches MoE de projection up. Vous pouvez aussi personnaliser la regex, par exemple `-ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU"` signifie décharger les couches MoE gate, up et down mais uniquement à partir de la 6e couche. La [dernière version de llama.cpp](https://github.com/ggml-org/llama.cpp/pull/14363) introduit aussi un mode haut débit. Utilisez `llama-parallel`. Lisez-en 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 adapter un long contexte (128K complet) Pour adapter un contexte plus long, vous pouvez utiliser **quantification du cache KV** pour quantifier les caches K et V en bits plus faibles. Cela peut également augmenter la vitesse de génération en réduisant les mouvements de données RAM / VRAM. Les options autorisées pour la quantification de K (par défaut est `f16`) incluent ci-dessous. `--cache-type-k f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1` Vous devriez utiliser les `_1` variantes pour une précision quelque peu accrue, bien que ce soit légèrement plus lent. Par ex `q4_1, q5_1` Vous pouvez aussi quantifier le cache V, mais vous devrez **compiler llama.cpp avec le support Flash Attention** via `-DGGML_CUDA_FA_ALL_QUANTS=ON`, et utiliser `--flash-attn` pour l'activer. Ensuite vous pouvez l'utiliser conjointement 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/grok-2.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.