🐋DeepSeek-R1: Wie man lokal ausführt

Ein Leitfaden, wie du unsere 1,58-Bit-Dynamic-Quants für DeepSeek-R1 mit llama.cpp ausführen kannst.

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)

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

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

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

2. Lade das Modell herunter über:

# 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
)

1. Beispiel mit Q4_0 K-quantisiertem Cache Hinweis: -no-cnv deaktiviert den Auto-Konversationsmodus

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

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

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

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

1. 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:

Originales DeepSeek R1

1.58bit Dynamic Quant

Die verwendete Eingabeaufforderung ist wie folgt:

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

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

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

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

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

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

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

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

MoE-Bits	Typ	Festplattengröße	Genauigkeit	Link	Details
1.58bit	UD-IQ1_S	131GB	Mittel	Link	MoE alle 1.56bit. down_proj in MoE-Mischung aus 2.06/1.56bit
1.73bit	UD-IQ1_M	158GB	Gut	Link	MoE alle 1.56bit. down_proj in MoE bei 2.06bit belassen
2.22bit	UD-IQ2_XXS	183GB	Besser	Link	MoE alle 2.06bit. down_proj in MoE-Mischung aus 2.5/2.06bit
2.51bit	UD-Q2_K_XL	212GB	Am besten	Link	MoE alle 2.5bit. down_proj in MoE-Mischung aus 3.5/2.5bit