# DeepSeek-R1: Wie man lokal ausführt

{% hint style="success" %}
Bitte siehe <https://docs.unsloth.ai/basics/deepseek-r1-0528-how-to-run-locally> für ein aktualisiertes DeepSeek R1-0528 (Version vom 28. Mai 2025)
{% endhint %}

## Verwendung von llama.cpp (empfohlen)

1. Vergiss nicht die `<｜User｜>` und `<｜Assistant｜>` Tokens! - Oder verwende einen Chat-Template-Formatter
2. Beschaffen Sie die neueste `llama.cpp` unter: [github.com/ggml-org/llama.cpp](https://github.com/ggml-org/llama.cpp). Du kannst auch den Build-Anweisungen unten folgen. **Für Apple Mac / Metal-Geräte**, setze `-DGGML_CUDA=OFF` und fahre 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
cmake llama.cpp -B llama.cpp/build \\
    -DBUILD_SHARED_LIBS=ON -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```

3. Am besten verwendet man `--min-p 0.05` um sehr seltene Token-Vorhersagen auszugleichen - ich habe festgestellt, dass dies besonders für das 1.58bit-Modell gut funktioniert.
4. Lade das Modell herunter über:

```python
# pip install huggingface_hub hf_transfer
# import os # Optional für schnelleres Herunterladen
# os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"

from huggingface_hub import snapshot_download
snapshot_download(
  repo_id = "unsloth/DeepSeek-R1-GGUF",
  local_dir = "DeepSeek-R1-GGUF",
  allow_patterns = ["*UD-IQ1_S*"], # Wähle den Quantisierungstyp UD-IQ1_S für 1.58bit
)
```

6. Beispiel mit Q4\_0 K-quantisiertem Cache **Hinweis: -no-cnv deaktiviert den Auto-Konversationsmodus**

```bash
./llama.cpp/llama-cli \\
    --model DeepSeek-R1-GGUF/DeepSeek-R1-UD-IQ1_S/DeepSeek-R1-UD-IQ1_S-00001-of-00003.gguf \\
    --cache-type-k q4_0 \\
    -no-cnv --prio 2 \\
    --temp 0.6 \\
    --ctx-size 8192 \\
    --seed 3407 \\
    --prompt "<｜User｜>Was ist 1+1?<｜Assistant｜>"
```

Beispielausgabe:

```txt
 <think>
 Okay, ich muss also herausfinden, was 1 plus 1 ist. Hm, wo fange ich überhaupt an? Ich erinnere mich aus der Schule, dass das Addieren von Zahlen ziemlich grundlegend ist, aber ich möchte sicherstellen, dass ich es richtig verstehe.
 Lass mich nachdenken: 1 plus 1. Also habe ich einen Gegenstand und füge einen weiteren hinzu. Vielleicht wie ein Apfel plus ein weiterer Apfel. Wenn ich einen Apfel habe und jemand gibt mir noch einen, habe ich jetzt zwei Äpfel. Also sollte 1 plus 1 gleich 2 sein. Das ergibt Sinn.
 Warte, aber Mathe kann manchmal knifflig sein. Könnte es etwas anderes sein? Vielleicht in einem anderen Zahlensystem? Aber ich denke, die Frage ist eindeutig und verwendet normale Zahlen, nicht etwa Binär- oder Hexadezimalzahlen oder so.
 Ich erinnere mich auch daran, dass Addition in der Arithmetik das Zusammenführen von Mengen ist. Wenn man also zwei Mengen von 1 hat, ergibt das zusammen insgesamt 2. Ja, das scheint richtig zu sein.
 Gibt es einen Fall, in dem 1 plus 1 nicht 2 wäre? Mir fällt keiner ein...
```

4. Wenn du eine GPU hast (zum Beispiel eine RTX 4090) mit 24 GB, kannst du mehrere Schichten auf die GPU auslagern, um die Verarbeitung zu beschleunigen. Wenn du mehrere GPUs hast, kannst du wahrscheinlich noch mehr Schichten auslagern.

```bash
./llama.cpp/llama-cli \\
    --model DeepSeek-R1-GGUF/DeepSeek-R1-UD-IQ1_S/DeepSeek-R1-UD-IQ1_S-00001-of-00003.gguf \\
    --cache-type-k q4_0 \\
    -no-cnv --prio 2 \\
    --n-gpu-layers 7 \\
    --temp 0.6 \\
    --ctx-size 8192 \\
    --seed 3407 \\
    --prompt "<｜User｜>Erstelle ein Flappy-Bird-Spiel in Python.<｜Assistant｜>"
```

5. Um unser Flappy-Bird-Beispiel zu testen, wie in unserem Blogbeitrag hier erwähnt: <https://unsloth.ai/blog/deepseekr1-dynamic>, können wir das zweite Beispiel wie unten mit unserem 1.58bit-Dynamic-Quant erzeugen:

<table data-column-title-hidden data-view="cards" data-full-width="false"><thead><tr><th></th><th></th><th></th><th data-hidden data-card-cover data-type="files"></th></tr></thead><tbody><tr><td>Originales DeepSeek R1</td><td></td><td></td><td><a href="/files/9fcb2e6fc3a5bd6e525d91e18d97c2315156f7ef">/files/9fcb2e6fc3a5bd6e525d91e18d97c2315156f7ef</a></td></tr><tr><td>1.58bit Dynamic Quant</td><td></td><td></td><td><a href="/files/f4a1461ff736cb53c5ae9909dae84d873f9c19ca">/files/f4a1461ff736cb53c5ae9909dae84d873f9c19ca</a></td></tr></tbody></table>

Die verwendete Eingabeaufforderung ist wie folgt:

{% code overflow="wrap" %}

```
<｜User｜>Erstelle ein Flappy-Bird-Spiel in Python. Du musst diese Dinge einbeziehen:
1. Du musst pygame verwenden.
2. Die Hintergrundfarbe sollte zufällig gewählt werden und ein heller Farbton sein. Beginne mit einem hellblauen Farbton.
3. Mehrfaches Drücken der LEERTASTE beschleunigt den Vogel.
4. Die Form des Vogels sollte zufällig als Quadrat, Kreis oder Dreieck gewählt werden. Die Farbe sollte zufällig als dunkle Farbe gewählt werden.
5. Platziere unten etwas Land, das zufällig dunkelbraun oder gelb gefärbt ist.
6. Zeige oben rechts eine Punktzahl an. Erhöhe sie, wenn du an Rohren vorbeikommst, ohne sie zu berühren.
7. Erstelle zufällig verteilte Rohre mit genügend Abstand. Färbe sie zufällig dunkelgrün, hellbraun oder in einem dunklen Grauton.
8. Wenn du verlierst, zeige die Bestpunktzahl an. Platziere den Text innerhalb des Bildschirms. Mit q oder Esc beendest du das Spiel. Ein Neustart erfolgt durch erneutes Drücken der LEERTASTE.
Das fertige Spiel sollte in einem Markdown-Abschnitt in Python stehen. Prüfe deinen Code auf Fehler und behebe sie vor dem endgültigen Markdown-Abschnitt.<｜Assistant｜>
```

{% endcode %}

Um llama.cpp mit diesem Beispiel aufzurufen, machen wir Folgendes:

```bash
./llama.cpp/llama-cli \\
    --model DeepSeek-R1-GGUF/DeepSeek-R1-UD-IQ1_S/DeepSeek-R1-UD-IQ1_S-00001-of-00003.gguf \\
    --cache-type-k q4_0 \\
    -no-cnv --prio 2 \\
    --n-gpu-layers 7 \\
    --temp 0.6 \\
    --ctx-size 8192 \\
    --seed 3407 \\
    --prompt "<｜User｜>Erstelle ein Flappy-Bird-Spiel in Python. Du musst diese Dinge einbeziehen:\n1. Du musst pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt werden und ein heller Farbton sein. Beginne mit einem hellblauen Farbton.\n3. Mehrfaches Drücken der LEERTASTE beschleunigt den Vogel.\n4. Die Form des Vogels sollte zufällig als Quadrat, Kreis oder Dreieck gewählt werden. Die Farbe sollte zufällig als dunkle Farbe gewählt werden.\n5. Platziere unten etwas Land, das zufällig dunkelbraun oder gelb gefärbt ist.\n6. Zeige oben rechts eine Punktzahl an. Erhöhe sie, wenn du an Rohren vorbeikommst, ohne sie zu berühren.\n7. Erstelle zufällig verteilte Rohre mit genügend Abstand. Färbe sie zufällig dunkelgrün, hellbraun oder in einem dunklen Grauton.\n8. Wenn du verlierst, zeige die Bestpunktzahl an. Platziere den Text innerhalb des Bildschirms. Mit q oder Esc beendest du das Spiel. Ein Neustart erfolgt durch erneutes Drücken der LEERTASTE.\nDas fertige Spiel sollte in einem Markdown-Abschnitt in Python stehen. Prüfe deinen Code auf Fehler und behebe sie vor dem endgültigen Markdown-Abschnitt.<｜Assistant｜>"
```

5. Wenn du außerdem die Gewichte beispielsweise für die Verwendung in Ollama zusammenführen möchtest, verwende dieses Skript:

```bash
./llama.cpp/llama-gguf-split --merge \\
    DeepSeek-R1-GGUF/DeepSeek-R1-UD-IQ1_S-00001-of-00003.gguf \\
    merged_file.gguf
```

6. DeepSeek R1 hat 61 Schichten. Mit einer 24GB-GPU oder 80GB-GPU kannst du nach Abrunden erwarten, dass du auslagern kannst (bei Out-of-Memory um 1 reduzieren):

| Quant   | Dateigröße | 24GB GPU | 80GB GPU | 2x80GB GPU        |
| ------- | ---------- | -------- | -------- | ----------------- |
| 1.58bit | 131GB      | 7        | 33       | Alle Schichten 61 |
| 1.73bit | 158GB      | 5        | 26       | 57                |
| 2.22bit | 183GB      | 4        | 22       | 49                |
| 2.51bit | 212GB      | 2        | 19       | 32                |

### Ausführung auf Mac / Apple-Geräten

Für Apple-Metal-Geräte sei vorsichtig mit --n-gpu-layers. Wenn du feststellst, dass dem System der Speicher ausgeht, reduziere den Wert. Bei einem Gerät mit 128 GB Unified Memory solltest du etwa 59 Schichten auslagern können.

```bash
./llama.cpp/llama-cli \\
    --model DeepSeek-R1-GGUF/DeepSeek-R1-UD-IQ1_S/DeepSeek-R1-UD-IQ1_S-00001-of-00003.gguf \\
    --cache-type-k q4_0 \\
    --prio 2 \\
    --temp 0.6 \\
    --ctx-size 8192 \\
    --seed 3407 \\
    --n-gpu-layers 59 \\
    -no-cnv \\
    --prompt "<｜User｜>Erstelle ein Flappy-Bird-Spiel in Python.<｜Assistant｜>"
```

### In Ollama/Open WebUI ausführen

Open WebUI hat hier ein Schritt-für-Schritt-Tutorial erstellt, wie man R1 ausführt: <https://docs.openwebui.com/tutorials/integrations/llm-providers/deepseekr1-dynamic>

\
Wenn du Ollama für Inferenz auf GGUFs verwenden möchtest, musst du zuerst die 3 gesplitteten GGUF-Dateien zu 1 zusammenführen, wie im folgenden Code. Danach musst du das Modell lokal ausführen.

```bash
./llama.cpp/llama-gguf-split --merge \\
  DeepSeek-R1-GGUF/DeepSeek-R1-UD-IQ1_S/DeepSeek-R1-UD-IQ1_S-00001-of-00003.gguf \\
	merged_file.gguf
```

## DeepSeek-Chat-Template

Alle destillierten Versionen und das Hauptmodell R1 mit 671B verwenden dasselbe Chat-Template:

`<｜begin▁of▁sentence｜><｜User｜>Was ist 1+1?<｜Assistant｜>Es ist 2.<｜end▁of▁sentence｜><｜User｜>Erkläre mehr!<｜Assistant｜>`

Ein BOS wird erzwungen hinzugefügt, und ein EOS trennt jede Interaktion. Um doppelte BOS-Tokens während der Inferenz zu vermeiden, solltest du nur *tokenizer.encode(..., add\_special\_tokens = False)* aufrufen, da das Chat-Template ebenfalls automatisch ein BOS-Token hinzufügt.\
Für llama.cpp / GGUF-Inferenz solltest du das BOS überspringen, da es automatisch hinzugefügt wird.

`<｜User｜>Was ist 1+1?<｜Assistant｜>`

Die Tokens \<think> und \</think> erhalten ihre eigenen speziellen Tokens. Für die destillierten Versionen von Qwen und Llama werden einige Tokens neu zugewiesen, während Qwen zum Beispiel kein BOS-Token hatte, sodass stattdessen <|object\_ref\_start|> verwendet werden musste.\
\
**Tokenizer-ID-Zuordnungen:**

| Token                     | R1     | Distill Qwen | Distill Llama |
| ------------------------- | ------ | ------------ | ------------- |
| \<think>                  | 128798 | 151648       | 128013        |
| \</think>                 | 128799 | 151649       | 128014        |
| <\|begin\_of\_sentence\|> | 0      | 151646       | 128000        |
| <\|end\_of\_sentence\|>   | 1      | 151643       | 128001        |
| <\|User\|>                | 128803 | 151644       | 128011        |
| <\|Assistant\|>           | 128804 | 151645       | 128012        |
| Padding-Token             | 2      | 151654       | 128004        |

Ursprüngliche Tokens in Modellen:

| Token                 | Qwen 2.5 32B Base        | Llama 3.3 70B Instruct            |
| --------------------- | ------------------------ | --------------------------------- |
| \<think>              | <\|box\_start\|>         | <\|reserved\_special\_token\_5\|> |
| \</think>             | <\|box\_end\|>           | <\|reserved\_special\_token\_6\|> |
| <｜begin▁of▁sentence｜> | <\|object\_ref\_start\|> | <\|begin\_of\_text\|>             |
| <｜end▁of▁sentence｜>   | <\|endoftext\|>          | <\|end\_of\_text\|>               |
| <｜User｜>              | <\|im\_start\|>          | <\|reserved\_special\_token\_3\|> |
| <｜Assistant｜>         | <\|im\_end\|>            | <\|reserved\_special\_token\_4\|> |
| Padding-Token         | <\|vision\_pad\|>        | <\|finetune\_right\_pad\_id\|>    |

Alle destillierten und die ursprünglichen R1-Versionen scheinen dem Padding-Token versehentlich <｜end▁of▁sentence｜> zugewiesen zu haben, was meistens keine gute Idee ist, insbesondere wenn du auf Basis dieser Reasoning-Modelle weiter feinabstimmen möchtest. Dies führt zu endlosen, unendlichen Generierungen, da die meisten Frameworks das EOS-Token als -100 maskieren.\
\
Wir haben alle destillierten und die ursprünglichen R1-Versionen mit dem korrekten Padding-Token behoben (Qwen verwendet <|vision\_pad|>, Llama verwendet <|finetune\_right\_pad\_id|>, und R1 verwendet <｜▁pad▁｜> oder unser eigenes hinzugefügtes <｜PAD▁TOKEN｜>.

## GGUF-R1-Tabelle

<table data-full-width="true"><thead><tr><th>MoE-Bits</th><th>Typ</th><th>Festplattengröße</th><th>Genauigkeit</th><th>Link</th><th>Details</th></tr></thead><tbody><tr><td>1.58bit</td><td>UD-IQ1_S</td><td><strong>131GB</strong></td><td>Mittel</td><td><a href="https://huggingface.co/unsloth/DeepSeek-R1-GGUF/tree/main/DeepSeek-R1-UD-IQ1_S">Link</a></td><td>MoE alle 1.56bit. <code>down_proj</code> in MoE-Mischung aus 2.06/1.56bit</td></tr><tr><td>1.73bit</td><td>UD-IQ1_M</td><td><strong>158GB</strong></td><td>Gut</td><td><a href="https://huggingface.co/unsloth/DeepSeek-R1-GGUF/tree/main/DeepSeek-R1-UD-IQ1_M">Link</a></td><td>MoE alle 1.56bit. <code>down_proj</code> in MoE bei 2.06bit belassen</td></tr><tr><td>2.22bit</td><td>UD-IQ2_XXS</td><td><strong>183GB</strong></td><td>Besser</td><td><a href="https://huggingface.co/unsloth/DeepSeek-R1-GGUF/tree/main/DeepSeek-R1-UD-IQ2_XXS">Link</a></td><td>MoE alle 2.06bit. <code>down_proj</code> in MoE-Mischung aus 2.5/2.06bit</td></tr><tr><td>2.51bit</td><td>UD-Q2_K_XL</td><td><strong>212GB</strong></td><td>Am besten</td><td><a href="https://huggingface.co/unsloth/DeepSeek-R1-GGUF/tree/main/DeepSeek-R1-UD-Q2_K_XL">Link</a></td><td>MoE alle 2.5bit. <code>down_proj</code> in MoE-Mischung aus 3.5/2.5bit</td></tr></tbody></table>


---

# 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/deepseek-r1-how-to-run-locally.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.