Grok 2

Exécutez localement le modèle Grok 2 de xAI !

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 totale 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

Le 3-bit Q3_K_XL le modèle fonctionne sur un seul Mac 128 Go ou 24 Go VRAM + 128 Go RAM, atteignant 5+ tokens/s pour l'inférence. Merci à l'équipe et à la communauté llama.cpp pour leur soutien à Grok 2 et d'avoir rendu cela possible. Nous avons également été heureux d'avoir un peu aidé en chemin !

Tous les téléversements utilisent Unsloth Dynamic 2.0 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

⚙️ Paramètres recommandés

La quantification dynamique 3 bits utilise 118 Go (126 Gio) d'espace disque - cela fonctionne bien sur un Mac à mémoire unifiée de 128 Go 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.

Vous devez utiliser --jinja pour Grok 2. Vous pourriez obtenir des résultats incorrects si vous n'utilisez pas --jinja

La quantification 8 bits fait ~300 Go et tiendra dans un GPU 1x 80 Go (avec les couches MoE déchargées en RAM). Attendez-vous à environ 5 tokens/s avec cette configuration si vous avez en plus 200 Go de RAM. Pour apprendre à augmenter la vitesse de génération et à tenir des contextes plus longs, lisez ici.

Bien que ce ne soit pas obligatoire, pour de meilleures performances, faites en sorte 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, seule l'inférence sera plus lente.

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 temperature = 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

1

Installez le llama.cpp PR spécifique pour Grok 2 sur GitHub ici. Vous pouvez suivre les instructions de compilation ci-dessous également. Changez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n'avez pas de GPU ou si vous voulez simplement une inférence CPU.

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

2

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="folder" pour forcer llama.cpp à enregistrer dans un emplacement spécifique. Rappelez-vous que le modèle a seulement une longueur de contexte maximale de 128K.

Veuillez essayer -ot ".ffn_.*_exps.=CPU" pour décharger toutes les couches MoE vers le CPU ! Cela vous permet effectivement de faire tenir 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 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 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 le 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.

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"

3

Téléchargez le modèle via (après avoir installé pip install huggingface_hub hf_transfer ). Vous pouvez choisir UD-Q3_K_XL (quant 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 plus pour équilibrer taille et précision.

# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Peut parfois limiter le taux, 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
)

4

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 sur le nombre de couches. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le également si vous n'avez qu'une inférence CPU.

./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"

Téléversements de modèles

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, 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	81,8 Go	1,92/1,56 bit
1,78 bit	IQ1_S	88,9 Go	2,06/1,56 bit
1,93 bit	IQ1_M	94,5 Go	2.5/2.06/1.56
2,42 bit	IQ2_XXS	99,3 Go	2,5/2,06 bit
2,71 bit	Q2_K_XL	112 Go	3,5/2,5 bit
3,12 bit	IQ3_XXS	117 Go	3,5/2,06 bit
3,5 bit	Q3_K_XL	126 Go	4,5/3,5 bit
4,5 bit	Q4_K_XL	155 Go	5,5/4,5 bit
5,5 bit	Q5_K_XL	191 Go	6,5/5,5 bit

🏂 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 complètes elles-mêmes.

Normalement, -ot ".ffn_.*_exps.=CPU" décharge toutes les couches MoE vers le CPU ! Cela vous permet effectivement de faire tenir 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 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 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 le 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.

Le dernière version de llama.cpp introduit également le mode haut débit. Utilisez llama-parallel. Lisez-en davantage ici. 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 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 en réduisant les mouvements de données RAM / VRAM. Les options autorisées pour la quantification 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