# Grok 2

Du kannst jetzt ausführen **Grok 2** (auch bekannt als Grok 2.5), das 270B Parameter-Modell von xAI. Volle Präzision erfordert **539GB**, während die Unsloth Dynamic 3-Bit-Version die Größe auf nur **118GB** (eine Reduktion um 75%). GGUF: [Grok-2-GGUF](https://huggingface.co/unsloth/grok-2-GGUF)

Die **3-Bit Q3\_K\_XL** Modell läuft auf einem einzelnen **128GB Mac** oder **24GB VRAM + 128GB RAM**, und erreicht **5+ Token/s** Inference. Dank an das llama.cpp-Team und die Community für [die Unterstützung von Grok 2](https://github.com/ggml-org/llama.cpp/pull/15539) und dafür, dies möglich gemacht zu haben. Wir freuen uns auch, ein wenig dazu beigetragen zu haben!

Alle Uploads verwenden Unsloth [Dynamic 2.0](https://unsloth.ai/docs/de/grundlagen/unsloth-dynamic-2.0-ggufs) für SOTA 5-Shot MMLU- und KL-Divergenz-Leistung, was bedeutet, dass du quantisierte Grok-LLMs mit minimalem Genauigkeitsverlust ausführen kannst.

<a href="#run-in-llama.cpp" class="button secondary">Im llama.cpp-Tutorial ausführen</a>

## :gear: Empfohlene Einstellungen

Die 3-Bit-dynamische Quantisierung verwendet 118GB (126GiB) Speicherplatz auf der Festplatte – das funktioniert gut in einem 128GB RAM Unified-Memory Mac oder auf einer 1x24GB-Karte und 128GB RAM. Es wird empfohlen, mindestens 120GB RAM zu haben, um diese 3-Bit-Quantisierung auszuführen.

{% hint style="warning" %}
Sie müssen `--jinja` für Grok 2. Du könntest falsche Ergebnisse erhalten, wenn du nicht `--jinja`
{% endhint %}

Die 8-Bit-Quantisierung ist \~300GB groß und passt in eine 1x80GB GPU (mit MoE-Schichten, die in den RAM ausgelagert werden). Erwartet werden etwa 5 Token/s mit diesem Setup, wenn du zusätzlich 200GB RAM hast. Um zu lernen, wie man die Generationsgeschwindigkeit erhöht und längere Kontexte unterbringt, [hier lesen](#improving-generation-speed).

{% hint style="info" %}
Obwohl nicht zwingend erforderlich, gilt für beste Leistung: Habe VRAM + RAM zusammen in etwa gleich groß wie die Quantisierung, die du herunterlädst. Wenn nicht, funktioniert Offloading auf Festplatte/SSD mit llama.cpp, nur die Inferenz wird langsamer sein.
{% endhint %}

### Sampling-Parameter

* Grok 2 hat eine maximale Kontextlänge von 128K; verwende daher `131,072` Kontext oder weniger.
* Verwende `--jinja` für llama.cpp-Varianten

Es gibt keine offiziellen Sampling-Parameter zum Ausführen des Modells, daher kannst du für die meisten Modelle die Standardwerte verwenden:

* Setze das <mark style="background-color:green;">**temperature = 1.0**</mark>
* <mark style="background-color:green;">**Min\_P = 0.01**</mark> (optional, aber 0.01 funktioniert gut, der llama.cpp-Standard ist 0.1)

## Grok 2 Tutorial ausführen:

Derzeit kannst du Grok 2 nur in llama.cpp ausführen.

### ✨ In llama.cpp ausführen

{% stepper %}
{% step %}
Installiere den spezifischen `llama.cpp` PR für Grok 2 auf [GitHub hier](https://github.com/ggml-org/llama.cpp/pull/15539). Du kannst auch den Build-Anweisungen unten folgen. Ändere `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn du keine GPU hast oder nur CPU-Inferenz möchtest. **Für Apple Mac / Metal-Geräte**, setze `-DGGML_CUDA=OFF` dann wie gewohnt fort - Metal-Unterstützung ist standardmäßig aktiviert.

```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 %}
Wenn du `llama.cpp` direkt, um Modelle zu laden, kannst du Folgendes tun: (:Q3\_K\_XL) ist der Quantisierungstyp. Du kannst auch über Hugging Face herunterladen (Punkt 3). Das ist ähnlich wie `ollama run` . Verwenden Sie `export LLAMA_CACHE="folder"` um `llama.cpp` zu zwingen, an einem bestimmten Ort zu speichern. Denken Sie daran, dass das Modell nur eine maximale Kontextlänge von 128K hat.

{% hint style="info" %}
Bitte probieren Sie `-ot ".ffn_.*_exps.=CPU"` um alle MoE-Schichten auf die CPU auszulagern! Dadurch können Sie effektiv alle Nicht-MoE-Schichten auf einer GPU unterbringen, was die Generationsgeschwindigkeit verbessert. Sie können den Regex-Ausdruck anpassen, um mehr Schichten zu verschieben, wenn Sie mehr GPU-Kapazität haben.

Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie `-ot ".ffn_(up|down)_exps.=CPU"` Dies lagert Up- und Down-Projektions-MoE-Schichten aus.

Versuchen Sie `-ot ".ffn_(up)_exps.=CPU"` wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur Up-Projektions-MoE-Schichten aus.

Und schließlich lagern Sie alle Schichten über `-ot ".ffn_.*_exps.=CPU"` aus.

Sie können auch den Regex anpassen, zum Beispiel `-ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU"` bedeutet, Gate-, Up- und Down-MoE-Schichten auszulagern, aber nur ab der 6. Schicht.
{% 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 %}
Laden Sie das Modell herunter (nach der Installation `pip install huggingface_hub hf_transfer` ). Sie können wählen `UD-Q3_K_XL` (dynamische 3-Bit-Quantisierung) oder andere quantisierte Versionen wie `Q4_K_M` Q4\_K\_XL <mark style="background-color:green;">**. Wir**</mark><mark style="background-color:green;">**&#x20;**</mark><mark style="background-color:green;">**`empfehlen die Verwendung unseres 2,7-Bit Dynamic Quant`**</mark><mark style="background-color:green;">**&#x20;**</mark><mark style="background-color:green;">**oder oben, um Größe und Genauigkeit auszubalancieren**</mark>.

```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Kann manchmal Ratenbegrenzung verursachen, also auf 0 setzen, um zu deaktivieren
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*"], # Dynamisches 3-Bit
)
```

{% endstep %}

{% step %}
\--include "\*UD-Q2\_K\_XL\*" # Verwenden Sie "\*UD-TQ1\_0\*" für Dynamic 1bit `Sie können` --threads 32 `für die Anzahl der CPU-Threads bearbeiten,` --ctx-size 16384 `für Kontextlänge,` --n-gpu-layers 2

{% 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 %}

## Modell-Uploads

**ALLE unsere Uploads** - einschließlich jener, die nicht imatrix-basiert oder dynamisch sind, verwenden unseren Kalibrationsdatensatz, der speziell für Konversations-, Coding- und Sprachaufgaben optimiert ist.

| MoE Bits | Typ + Link                                                                          | Platzbedarf auf Datenträger | Details       |
| -------- | ----------------------------------------------------------------------------------- | --------------------------- | ------------- |
| 1,66bit  | [TQ1\_0](https://huggingface.co/unsloth/grok-2-GGUF/blob/main/grok-2-UD-TQ1_0.gguf) | **81,8 GB**                 | 1,92/1,56bit  |
| 1,78bit  | [IQ1\_S](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-IQ1_S)             | **88,9 GB**                 | 2,06/1,56bit  |
| 1,93bit  | [IQ1\_M](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-IQ1_M)             | **94,5 GB**                 | 2.5/2.06/1.56 |
| 2,42bit  | [IQ2\_XXS](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-IQ2_XXS)         | **99,3 GB**                 | 2,5/2,06bit   |
| 2,71bit  | [Q2\_K\_XL](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-Q2_K_XL)        | **112 GB**                  | 3,5/2,5bit    |
| 3,12bit  | [IQ3\_XXS](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-IQ3_XXS)         | **117 GB**                  | 3,5/2,06bit   |
| 3,5bit   | [Q3\_K\_XL](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-Q3_K_XL)        | **126 GB**                  | 4,5/3,5bit    |
| 4,5bit   | [Q4\_K\_XL](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-Q4_K_XL)        | **155 GB**                  | 5,5/4,5bit    |
| 5,5bit   | [Q5\_K\_XL](https://huggingface.co/unsloth/grok-2-GGUF/tree/main/UD-Q5_K_XL)        | **191 GB**                  | 6,5/5,5bit    |

## :snowboarder: "content": \[{"type": "text", "text": "Erstelle eine Fibonacci-Funktion in Python und finde fib(20)."}],

Wenn Sie mehr VRAM haben, können Sie versuchen, mehr MoE-Schichten auszulagern oder ganze Schichten selbst auszulagern.

Normalerweise, `-ot ".ffn_.*_exps.=CPU"` lagert alle MoE-Schichten auf die CPU aus! Dies ermöglicht effektiv, alle Nicht-MoE-Schichten auf 1 GPU unterzubringen und verbessert die Generationsgeschwindigkeit. Sie können den Regex-Ausdruck anpassen, um mehr Schichten unterzubringen, wenn Sie mehr GPU-Kapazität haben.

Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie `-ot ".ffn_(up|down)_exps.=CPU"` Dies lagert Up- und Down-Projektions-MoE-Schichten aus.

Versuchen Sie `-ot ".ffn_(up)_exps.=CPU"` wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur Up-Projektions-MoE-Schichten aus.

Sie können auch den Regex anpassen, zum Beispiel `-ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU"` bedeutet, Gate-, Up- und Down-MoE-Schichten auszulagern, aber nur ab der 6. Schicht.

Die [neueste llama.cpp-Version](https://github.com/ggml-org/llama.cpp/pull/14363) führt außerdem einen Hochdurchsatzmodus ein. Verwenden Sie `llama-parallel`. Lesen Sie mehr darüber [hier](https://github.com/ggml-org/llama.cpp/tree/master/examples/parallel). Sie können auch **den KV-Cache z. B. auf 4 Bit quantisieren,** den KV-Cache auf 4 Bit quantisieren

## zum Beispiel, um VRAM-/RAM-Bewegungen zu reduzieren, was den Generationsprozess ebenfalls beschleunigen kann.

Um längeren Kontext unterzubringen, können Sie **KV-Cache-Quantisierung** verwenden, um die K- und V-Caches auf niedrigere Bits zu quantisieren. Dies kann auch die Generationsgeschwindigkeit erhöhen aufgrund reduzierter RAM-/VRAM-Datenbewegungen. Die erlaubten Optionen für K-Quantisierung (Standard ist `f16`) umfassen die untenstehenden.

`--cache-type-k f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1`

Sie sollten die `_1` Varianten für etwas erhöhte Genauigkeit verwenden, obwohl sie etwas langsamer sind. Zum Beispiel `q4_1, q5_1`

Sie können auch den V-Cache quantisieren, aber Sie müssen **llama.cpp mit Flash Attention kompilieren** Unterstützung via `-DGGML_CUDA_FA_ALL_QUANTS=ON`, und verwenden `--flash-attn` --flash-attn `um es zu aktivieren. Dann können Sie es zusammen mit` :

`--cache-type-k verwenden, und`


---

# 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/de/modelle/tutorials/grok-2.md?ask=<question>
```

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.
