🐋DeepSeek-R1: Anleitung zum lokalen Betrieb

Eine Anleitung, 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 eine aktualisierte DeepSeek R1-0528 (Version vom 28. Mai 2025)

Verwendung von llama.cpp (empfohlen)

1. Vergiss nicht <｜User｜> und <｜Assistant｜> Tokens! - Oder benutze einen Chat-Template-Formatter

2. Holen Sie sich die neueste llama.cpp bei: github.com/ggerganov/llama.cpp. Du kannst auch den untenstehenden Build-Anweisungen folgen:

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggerganov/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 verwendest du --min-p 0.05 um sehr seltene Token-Vorhersagen entgegenzuwirken - ich fand, dass dies besonders gut für das 1,58-Bit-Modell 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 Quant-Typ UD-IQ1_S für 1,58 Bit
)

1. Beispiel mit Q4_0 K quantisiertem Cache Hinweis -no-cnv deaktiviert den automatischen 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｜>What is 1+1?<｜Assistant｜>"

Beispielausgabe:

 <think>
 Okay, also muss ich 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 mir jemand einen weiteren gibt, habe ich jetzt zwei Äpfel. Also sollte 1 plus 1 gleich 2 sein. Das ergibt Sinn.
 Warte, aber manchmal kann Mathematik knifflig sein. Könnte es etwas anderes sein? Zum Beispiel in einem anderen Zahlensystem vielleicht? Aber ich denke, die Frage ist eindeutig, mit normalen Zahlen, nicht etwa binär oder hexadezimal oder so.
 Ich erinnere mich auch, dass in der Arithmetik Addition das Zusammenführen von Mengen ist. Wenn du zwei Mengen von 1 hast, ergibt das Zusammenführen insgesamt 2. Ja, das scheint richtig zu sein.
 Gibt es ein Szenario, in dem 1 plus 1 nicht 2 wäre? Mir fällt keines ein...

1. Wenn du eine GPU (z. B. RTX 4090) mit 24 GB hast, kannst du mehrere Schichten auf die GPU auslagern für schnellere Verarbeitung. Wenn du mehrere GPUs hast, kannst du wahrscheinlich 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｜>Create a Flappy Bird game 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 2. Beispiel wie unten mit unserem 1,58-Bit-Dynamik-Quant erzeugen:

Original DeepSeek R1

1,58-Bit Dynamische Quantisierung

Der verwendete Prompt 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 einen hellen Ton haben. Beginne mit einem hellen Blauton.
3. Das mehrfache Drücken von SPACE wird den Vogel beschleunigen.
4. Die Form des Vogels sollte zufällig als Quadrat, Kreis oder Dreieck gewählt werden. Die Farbe sollte zufällig als eine dunkle Farbe gewählt werden.
5. Platziere unten etwas Land, das zufällig dunkelbraun oder gelb gefärbt ist.
6. Zeige eine Punktzahl oben rechts an. Erhöhe die Punktzahl, wenn du Rohre passiert und nicht getroffen wirst.
7. Erzeuge zufällig verteilte Rohre mit genügend Platz. Färbe sie zufällig dunkelgrün oder hellbraun oder in einem dunklen Grauton.
8. Wenn du verlierst, zeige die Bestpunktzahl an. Platziere den Text innerhalb des Bildschirms. Das Drücken von q oder Esc beendet das Spiel. Neustarten erfolgt durch erneutes Drücken von SPACE.
Das fertige Spiel sollte innerhalb eines Markdown-Abschnitts in Python sein. Prüfe deinen Code auf Fehler und behebe sie vor dem finalen Markdown-Abschnitt.<｜Assistant｜>

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

./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｜>Create a Flappy Bird game in Python. You must include these things:\n1. You must use pygame.\n2. The background color should be randomly chosen and is a light shade. Start with a light blue color.\n3. Pressing SPACE multiple times will accelerate the bird.\n4. The bird's shape should be randomly chosen as a square, circle or triangle. The color should be randomly chosen as a dark color.\n5. Place on the bottom some land colored as dark brown or yellow chosen randomly.\n6. Make a score shown on the top right side. Increment if you pass pipes and don't hit them.\n7. Make randomly spaced pipes with enough space. Color them randomly as dark green or light brown or a dark gray shade.\n8. When you lose, show the best score. Make the text inside the screen. Pressing q or Esc will quit the game. Restarting is pressing SPACE again.\nThe final game should be inside a markdown section in Python. Check your code for errors and fix them before the final markdown section.<｜Assistant｜>"

1. Wenn du außerdem die Gewichte zusammenführen willst, z. B. für die Verwendung in Ollama, benutze 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. Zum Beispiel kannst du bei einer 24-GB-GPU oder 80-GB-GPU damit rechnen, nach dem Abrunden auszulagern (reduziere um 1, wenn es zu Out-of-Memory kommt):

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

Bei Apple-Metal-Geräten sei vorsichtig mit --n-gpu-layers. Wenn der Rechner in den Out-of-Memory-Zustand gerät, reduziere diesen Wert. Bei einer Maschine mit 128 GB Unified Memory solltest du in der Lage sein, ungefähr 59 Schichten auszulagern.

./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｜>Create a Flappy Bird game in Python.<｜Assistant｜>"

Ausführen in Ollama/Open WebUI

Open WebUI hat ein Schritt-für-Schritt-Tutorial, wie man R1 ausführt, hier: docs.openwebui.com/tutorials/integrations/deepseekr1-dynamic/ Wenn du Ollama für Inferenz mit GGUFs verwenden willst, musst du zuerst die 3 GGUF-Split-Dateien zu einer zusammenführen wie im Code unten. Dann 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 distillierten Versionen und das Hauptmodell R1 671B verwenden dasselbe Chat-Template:

<｜begin▁of▁sentence｜><｜User｜>What is 1+1?<｜Assistant｜>It's 2.<｜end▁of▁sentence｜><｜User｜>Explain more!<｜Assistant｜>

Ein BOS wird zwangsweise hinzugefügt, und ein EOS trennt jede Interaktion. Um doppelte BOS-Token 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｜>What is 1+1?<｜Assistant｜>

Die <think>- und </think>-Tokens erhalten eigene, zugewiesene Tokens. Für die distillierten Versionen von Qwen und Llama werden einige Tokens neu zugeordnet, 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 distillierten und die ursprünglichen R1-Versionen scheinen den Padding-Token versehentlich auf <｜end▁of▁sentence｜> gesetzt zu haben, was meistens keine gute Idee ist, besonders wenn du diese Reasoning-Modelle weiter feinabstimmen möchtest. Dies verursacht endlose, unendliche Generierungen, da die meisten Frameworks das EOS-Token als -100 maskieren. Wir haben alle distillierten und die ursprünglichen R1-Versionen mit dem korrekten Padding-Token korrigiert (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	Platten-/Festplattengröße	Genauigkeit	Link	Details
1,58bit	UD-IQ1_S	131GB	Fair	Link	MoE alle 1,56 Bit. down_proj in MoE Mischung aus 2,06/1,56 Bit
1,73bit	UD-IQ1_M	158GB	Gut	Link	MoE alle 1,56 Bit. down_proj in MoE links bei 2,06 Bit
2,22bit	UD-IQ2_XXS	183GB	Besser	Link	MoE alle 2,06 Bit. down_proj in MoE Mischung aus 2,5/2,06 Bit
2,51bit	UD-Q2_K_XL	212GB	Am besten	Link	MoE alle 2,5 Bit. down_proj in MoE Mischung aus 3,5/2,5 Bit