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 à 270B de paramètres de xAI. La précision complète nécessite 539 Go, tandis que la version dynamique 3 bits d’Unsloth réduit la taille à seulement 118 Go (une réduction de 75 %). GGUF : Grok-2-GGUF

Le Q3_K_XL 3 bits modèle fonctionne sur un seul Mac 128 Go ou 24 Go de VRAM + 128 Go de RAM, atteignant plus de 5 jetons/s d’inférence. Merci à l’équipe de llama.cpp et à la communauté pour la prise en charge de Grok 2 et pour avoir rendu cela possible. Nous avons aussi été heureux d’avoir pu apporter un petit coup de main en chemin !

Tous les téléchargements utilisent Unsloth Dynamic 2.0 pour des performances de pointe en MMLU 5-shot et en divergence KL, ce qui signifie que vous pouvez exécuter des LLM Grok quantifiés avec une perte de précision minimale.

Tutoriel d’exécution dans 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 avec mémoire unifiée de 128 Go de RAM ou sur une carte 1x24 Go avec 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 environ 300 Go et tient sur un GPU 1x 80 Go (avec les couches MoE déchargées vers la RAM). Attendez-vous à environ 5 jetons/s avec cette configuration si vous disposez également de 200 Go de RAM supplémentaires. Pour apprendre à augmenter la vitesse de génération et à prendre en charge des contextes plus longs, lisez ici.

Bien que ce ne soit pas indispensable, 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 vers le disque dur / SSD fonctionnera avec llama.cpp, mais l’inférence sera plus lente.

Paramètres d’échantillonnage

Grok 2 a une longueur de contexte maximale de 128K, donc utilisez 131,072 de contexte ou moins.
Utilisez --jinja pour les variantes de 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 (facultatif, mais 0.01 fonctionne bien ; la valeur par défaut de llama.cpp est 0.1)

Tutoriel d’exécution de Grok 2 :

Actuellement, vous ne pouvez exécuter Grok 2 que dans llama.cpp.

✨ Exécuter dans llama.cpp

Installez le llama.cpp PR spécifique pour Grok 2 sur GitHub ici. 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. 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.

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

Si vous souhaitez utiliser llama.cpp directement pour charger des 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 à être enregistré à un emplacement spécifique. N'oubliez pas que le modèle a une longueur de contexte maximale de 128K uniquement.

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.

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"

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 quantification dynamique 2,7 bits UD-Q2_K_XL ou plus pour équilibrer la taille et la précision.

# !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/grok-2-GGUF",
    local_dir = "unsloth/grok-2-GGUF",
    allow_patterns = ["*UD-Q3_K_XL*"], # 3 bits dynamique
)

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.

./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 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 de langage.

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é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.

Le la dernière version de llama.cpp introduit également le mode à haut débit. Utilisez llama-parallel. En savoir plus ici. 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 gérer un long contexte (128K 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

Mis à jour il y a 2 mois

Ce contenu vous a-t-il été utile ?