🌙Kimi K2 Thinking: Leitfaden zum lokalen Ausführen

Leitfaden zum Ausführen von Kimi-K2-Thinking und Kimi-K2 auf deinem eigenen lokalen Gerät!

Kimi-K2-Thinking wurde veröffentlicht. Lies unseren Thinking-Leitfaden oder greife hier auf GGUFs zu.

Wir haben auch mit dem Kimi-Team zusammengearbeitet an System-Prompt-Fix für Kimi-K2-Thinking.

Kimi-K2 und Kimi-K2-Thinking erreichen SOTA-Performance bei Wissens-, Reasoning-, Coding- und agentischen Aufgaben. Die vollständigen 1T-Parameter-Modelle von Moonshot AI benötigen 1,09 TB Festplattenspeicher, während die quantisierte Unsloth Dynamic 1,8-Bit Version dies auf nur 230 GB reduziert (-80 % Größe): Kimi-K2-GGUF

Du kannst jetzt auch unsere Kimi-K2-Thinking GGUFs.

Alle Uploads verwenden Unsloth Dynamic 2.0 für SOTA Aider Polyglot und 5-Shot-MMLU-Performance ausführen. Sieh dir an, wie unsere Dynamic 1–2-Bit-GGUFs bei Coding-Benchmarks hier abschneiden.

Thinking ausführenInstruct ausführen

⚙️ Empfohlene Voraussetzungen

Du benötigst 247 GB Festplattenspeicher um den 1-Bit-Quant auszuführen!

Die einzige Voraussetzung ist Festplattenspeicher + RAM + VRAM ≥ 247 GB. Das bedeutet, dass du nicht so viel RAM oder VRAM (GPU) haben musst, um das Modell auszuführen, aber es wird deutlich langsamer sein.

Der 1,8-Bit-(UD-TQ1_0)-Quant passt auf eine 1x-24-GB-GPU (wobei alle MoE-Layer in den System-RAM oder auf eine schnelle Festplatte ausgelagert werden). Rechne mit etwa ~1–2 Tokens/s mit diesem Setup, wenn du zusätzlich 256 GB RAM hast. Der vollständige Kimi K2 Q8 Quant ist 1,09 TB groß und benötigt mindestens 8 x H200 GPUs.

Für optimale Leistung benötigst du mindestens 247 GB einheitlichen Speicher oder 247 GB kombinierten RAM+VRAM für 5+ Tokens/s. Wenn du weniger als 247 GB kombinierten RAM+VRAM hast, wird die Geschwindigkeit des Modells definitiv beeinträchtigt.

Wenn du keine 247 GB RAM+VRAM hast, keine Sorge! llama.cpp hat von Natur aus Festplatten-Offloading, sodass es über mmaping weiterhin funktioniert, nur langsamer - zum Beispiel hast du zuvor vielleicht 5 bis 10 Tokens/Sekunde bekommen, jetzt sind es unter 1 Token.

Wir empfehlen unsere UD-Q2_K_XL (360 GB) Quantisierung, um Größe und Genauigkeit auszubalancieren!

Für beste Leistung sollte dein kombiniertes VRAM + RAM = der Größe des heruntergeladenen Quants entsprechen. Falls nicht, funktioniert es weiterhin per Festplatten-Offloading, nur eben langsamer!

💭Kimi-K2-Thinking-Leitfaden

Kimi-K2-Thinking sollte im Allgemeinen denselben Anweisungen wie das Instruct-Modell folgen, mit einigen wichtigen Unterschieden, insbesondere in Bereichen wie den Einstellungen und der Chat-Vorlage.

Um das Modell in voller Präzision auszuführen, musst du nur die 4-Bit- oder 5-Bit-Dynamic-GGUFs verwenden (z. B. UD_Q4_K_XL), da das Modell ursprünglich im INT4-Format veröffentlicht wurde.

Du kannst zur Sicherheit eine höhere Bit-Quantisierung wählen, falls es kleine Quantisierungsunterschiede gibt, aber in den meisten Fällen ist das unnötig.

🌙 Offizielle empfohlene Einstellungen:

Laut Moonshot AIsind dies die empfohlenen Einstellungen für die Kimi-K2-Thinking-Inferenz:

• Setzen Sie Temperatur 1,0 um Wiederholungen und Inkohärenz zu reduzieren.

• Empfohlene Kontextlänge = 98.304 (bis zu 256K)

• Hinweis: Die Verwendung verschiedener Tools kann unterschiedliche Einstellungen erfordern

Wir empfehlen, min_p auf 0,01 zu setzen um das Auftreten unwahrscheinlicher Tokens mit niedrigen Wahrscheinlichkeiten zu unterdrücken.

Zum Beispiel bei einer Benutzernachricht von „Was ist 1+1?“, erhalten wir:

<|im_system|>system<|im_middle|>Du bist Kimi, ein KI-Assistent, erstellt von Moonshot AI.<|im_end|><|im_user|>user<|im_middle|>Was ist 1+1?<|im_end|><|im_assistant|>assistant<|im_middle|>

✨ Kimi K2 Thinking in llama.cpp ausführen

Du kannst jetzt die neueste Aktualisierung von llama.cpp verwenden, um das Modell auszuführen:

1. Hole dir die neueste llama.cpp auf GitHub hier. Du kannst auch den untenstehenden Build-Anweisungen 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 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=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
cp llama.cpp/build/bin/llama-* llama.cpp

1. Wenn du llama.cpp direkt zum Laden von Modellen kannst du Folgendes tun: (:UD-TQ1_0) ist der Quantisierungstyp. Du kannst auch über Hugging Face herunterladen (Punkt 3). Dies ist ähnlich zu ollama run . Verwenden Sie export LLAMA_CACHE="folder" um zu erzwingen, dass llama.cpp um an einem bestimmten Speicherort zu speichern.

export LLAMA_CACHE="unsloth/Kimi-K2-Thinking-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/Kimi-K2-Thinking-GGUF:UD-TQ1_0 \
    --n-gpu-layers 99 \
    --temp 1.0 \
    --min-p 0,01 \
    --ctx-size 16384 \
    --seed 3407 \\
    -ot ".ffn_.*_exps.=CPU"

1. Das oben Genannte wird etwa 8 GB GPU-Speicher verwenden. Wenn du ungefähr 360 GB kombinierten GPU-Speicher hast, entferne -ot ".ffn_.*_exps.=CPU" um maximale Geschwindigkeit zu erhalten!

Bitte probieren Sie -ot ".ffn_.*_exps.=CPU" verwenden, um alle MoE-Layer auf die CPU auszulagern! Dadurch können Sie effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen, was die Generierungsgeschwindigkeit verbessert. Sie können den Regex-Ausdruck anpassen, um mehr Layer 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 die MoE-Layer für Up- und Down-Projektionen aus.

Versuchen Sie -ot ".ffn_(up)_exps.=CPU" wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur die MoE-Layer für Up-Projektionen aus.

Und schließlich lagern Sie alle Layer aus via -ot ".ffn_.*_exps.=CPU" Dies verwendet am wenigsten VRAM.

Sie können den Regex auch 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-Layer auszulagern, aber nur ab der 6. Schicht.

1. Lade das Modell herunter über (nach der Installation von pip install huggingface_hub hf_transfer ). Wir empfehlen, unseren 2-Bit-Dynamic-Quant UD-Q2_K_XL zu verwenden, um Größe und Genauigkeit auszubalancieren. Alle Versionen unter: huggingface.co/unsloth/Kimi-K2-Thinking-GGUF

# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Kann manchmal eine Ratenbegrenzung auslösen, daher auf 0 setzen, um zu deaktivieren
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/Kimi-K2-Thinking-GGUF",
    local_dir = "unsloth/Kimi-K2-Thinking-GGUF",
    allow_patterns = ["*UD-TQ1_0*"], # Verwende "*UD-Q2_K_XL*" für Dynamic 2bit (381GB)
)

Wenn du feststellst, dass Downloads bei etwa 90 bis 95 % hängen bleiben, siehe bitte https://docs.unsloth.ai/basics/troubleshooting-and-faqs#downloading-gets-stuck-at-90-to-95

1. Führe einen beliebigen Prompt aus.

2. Bearbeiten --threads -1 für die Anzahl der CPU-Threads (standardmäßig ist es auf die maximale Anzahl CPU-Threads gesetzt), --ctx-size 16384 für die Kontextlänge, --n-gpu-layers 99 für das GPU-Offloading, für wie viele Schichten. Setze es auf 99 zusammen mit MoE-CPU-Offloading, um die beste Leistung zu erhalten. Versuche, es anzupassen, wenn deiner GPU der Speicher ausgeht. Entferne es außerdem, wenn du nur CPU-Inferenz hast.

./llama.cpp/llama-cli \
    --model unsloth/Kimi-K2-Thinking-GGUF/UD-TQ1_0/Kimi-K2-Thinking-UD-TQ1_0-00001-of-00006.gguf \
    --n-gpu-layers 99 \
    --temp 1.0 \
    --min-p 0,01 \
    --ctx-size 16384 \
    --seed 3407 \\
    -ot ".ffn_.*_exps.=CPU"

🤔Keine Thinking-Tags?

Vielleicht fällt dir auf, dass es keine thinking Tags gibt, wenn du das Modell ausführst. Das ist normal und beabsichtigtes Verhalten.

In deinem llama.cpp Skript stelle sicher, dass du das --special Flag ganz am Ende deines Befehls einfügst. Sobald du das tust, wirst du das <think> Token wie erwartet erscheinen sehen.

Möglicherweise siehst du auch, dass jede Antwort mit <|im_end|>endet. Das ist normal, da <|im_end|> ein spezielles Token ist, das beim Ausgeben spezieller Tokens erscheint. Wenn du es ausblenden möchtest, kannst du <|im_end|> als Stop-String in deinen Einstellungen setzen.

✨ Bereitstellen mit llama-server und der Completion-Bibliothek von OpenAI

Nachdem du llama.cpp gemäß Kimi K2 Thinkinginstalliert hast, kannst du Folgendes verwenden, um einen OpenAI-kompatiblen Server zu starten:

./llama.cpp/llama-server \
    --model unsloth/Kimi-K2-Thinking-GGUF/UD-TQ1_0/Kimi-K2-Thinking-UD-TQ1_0-00001-of-00006.gguf \
    --alias "unsloth/Kimi-K2-Thinking" \
    -fa on \
    --n-gpu-layers 999 \
    -ot ".ffn_.*_exps.=CPU" \
    --min-p 0,01 \
    --ctx-size 16384 \
    --port 8001 \
    --jinja

Verwenden Sie anschließend die Python-Bibliothek von OpenAI nach pip install openai :

from openai import OpenAI
openai_client = OpenAI(
    base_url = "http://127.0.0.1:8001/v1",
    api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
    model = "unsloth/Kimi-K2-Thinking",
    messages = [{"role": "user", "content": "Was ist 2+2?"},],
)
print(completion.choices[0].message.content)

🔍Eigenheiten des Tokenizers und Fehlerbehebungen

7. November 2025: Wir haben das Kimi-Team informiert und den Standard-System-Prompt von Du bist Kimi, ein KI-Assistent, erstellt von Moonshot AI. erscheint nicht beim ersten Benutzerprompt! Siehe https://huggingface.co/moonshotai/Kimi-K2-Thinking/discussions/12

Ein riesiges Dankeschön an das Moonshot-Kimi-Team für ihre extrem schnelle Antwortzeit auf unsere Anfragen und dafür, dass sie das Problem so schnell wie möglich behoben haben!

16. Juli 2025: Kimi K2 hat ihren Tokenizer aktualisiert, um mehrere Tool-Aufrufe zu ermöglichen gemäß https://x.com/Kimi_Moonshot/status/1945050874067476962

18. Juli 2025: Wir haben einen System-Prompt behoben - Kimi hat auch hier über unseren Fix getwittert: https://x.com/Kimi_Moonshot/status/1946130043446690030. Der Fix wurde auch hier beschrieben: https://huggingface.co/moonshotai/Kimi-K2-Instruct/discussions/28

Wenn du die alten Checkpoints bereits heruntergeladen hast - keine Sorge - lade einfach den ersten GGUF-Split herunter, der geändert wurde. ODER wenn du keine neuen Dateien herunterladen möchtest, mache Folgendes:

wget https://huggingface.co/unsloth/Kimi-K2-Instruct/raw/main/chat_template.jinja
./llama.cpp ... --chat-template-file /dir/to/chat_template.jinja

Mit dem Kimi-K2-Tokenizer herumzuspielen war interessant - er verhält sich größtenteils ähnlich wie der Tokenizer von GPT-4o! Zuerst sehen wir in der tokenization_kimi.py Datei den folgenden regulären Ausdruck (Regex), den Kimi K2 verwendet:

pat_str = "|".join(
    [
        r"""[\p{Han}]+""",
        r"""[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}&&[^\p{Han}]]*[\p{Ll}\p{Lm}\p{Lo}\p{M}&&[^\p{Han}]]+(?i:'s|'t|'re|'ve|'m|'ll|'d)?""",
        r"""[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}&&[^\p{Han}]]+[\p{Ll}\p{Lm}\p{Lo}\p{M}&&[^\p{Han}]]*(?i:'s|'t|'re|'ve|'m|'ll|'d)?""",
        r"""\p{N}{1,3}""",
        r""" ?[^\s\p{L}\p{N}]+[\r\n]*""",
        r"""\s*[\r\n]+""",
        r"""\s+(?!\S)""",
        r"""\s+""",
    ]
)

Nach sorgfältiger Prüfung stellen wir fest, dass Kimi K2 dem Regex des GPT-4o-Tokenizers nahezu identisch ist, den man in llama.cpps Quellcode.

[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]*[\p{Ll}\p{Lm}\p{Lo}\p{M}]+(?i:'s|'t|'re|'ve|'m|'ll|'d)?|[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]+[\p{Ll}\p{Lm}\p{Lo}\p{M}]*(?i:'s|'t|'re|'ve|'m|'ll|'d)?|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n/]*|\s*[\r\n]+|\s+(?!\S)|\s+

Beide tokenisieren Zahlen in Gruppen von 1 bis 3 Zahlen (9, 99, 999) und verwenden ähnliche Muster. Der einzige Unterschied scheint die Behandlung von "Han"- oder chinesischen Zeichen zu sein, mit denen Kimis Tokenizer stärker umgeht. Der PR von https://github.com/gabriellarson geht mit diesen Unterschieden nach einigen Diskussionen hier.

Wir stellen außerdem fest, dass das korrekte EOS-Token nicht [EOS] sein sollte, sondern <|im_end|>, was wir ebenfalls in unseren Modellkonvertierungen behoben haben.

🌝Kimi-K2-Instruct-Leitfaden

Schritt-für-Schritt-Anleitung zum Ausführen der Instruct-Kimi-K2-Modelle einschließlich Kimi K2 0905 - dem Update vom 5. September.

🌙 Offizielle empfohlene Einstellungen:

Laut Moonshot AI, dies sind die empfohlenen Einstellungen für die Kimi K2-Inferenz:

• Setzen Sie Temperatur 0,6 um Wiederholungen und Inkohärenz zu reduzieren.

• Der ursprüngliche Standard-System-Prompt lautet:

  Du bist ein hilfreicher Assistent

• (Optional) Moonshot schlägt außerdem Folgendes für den System-Prompt vor:

  Du bist Kimi, ein KI-Assistent, erstellt von Moonshot AI.

Wir empfehlen, min_p auf 0,01 zu setzen um das Auftreten unwahrscheinlicher Tokens mit niedrigen Wahrscheinlichkeiten zu unterdrücken.

🔢 Chat-Vorlage und Prompt-Format

Kimi Chat verwendet tatsächlich ein BOS-Token (Beginn des Satzes). Die Rollen System, Benutzer und Assistent sind alle eingeschlossen mit <|im_middle|> was interessant ist, und jede erhält ihr eigenes entsprechendes Token <|im_system|>, <|im_user|>, <|im_assistant|>.

<|im_system|>system<|im_middle|>Du bist ein hilfreicher Assistent<|im_end|><|im_user|>user<|im_middle|>Was ist 1+1?<|im_end|><|im_assistant|>assistant<|im_middle|>2<|im_end|>

Um die Gesprächsgrenzen zu trennen (du musst jede neue Zeile entfernen), erhalten wir:

<|im_system|>system<|im_middle|>Du bist ein hilfreicher Assistent<|im_end|>
<|im_user|>user<|im_middle|>Was ist 1+1?<|im_end|>
<|im_assistant|>assistant<|im_middle|>2<|im_end|>

💾 Modell-Uploads

ALLE unsere Uploads - einschließlich solcher, die nicht auf imatrix basieren oder dynamisch sind, verwenden unseren Kalibrierungsdatensatz, der speziell für Gesprächs-, Coding- und Reasoning-Aufgaben optimiert ist.

MoE-Bits	Typ + Link	Festplattengröße	Details
1,66 Bit	UD-TQ1_0	245 GB	1,92/1,56 Bit
1,78 Bit	UD-IQ1_S	281 GB	2,06/1,56 Bit
1,93 Bit	UD-IQ1_M	304 GB	2.5/2.06/1.56
2,42 Bit	UD-IQ2_XXS	343 GB	2,5/2,06 Bit
2,71 Bit	UD-Q2_K_XL	381 GB	3,5/2,5 Bit
3,12 Bit	UD-IQ3_XXS	417 GB	3,5/2,06 Bit
3,5 Bit	UD-Q3_K_XL	452 GB	4,5/3,5 Bit
4,5 Bit	UD-Q4_K_XL	588 GB	5,5/4,5 Bit
5,5 Bit	UD-Q5_K_XL	732 GB	6,5/5,5 Bit

Wir haben auch Versionen in BF16-Format.

✨ Instruct in llama.cpp ausführen

1. Hole dir die neueste llama.cpp auf GitHub hier. Du kannst auch den untenstehenden Build-Anweisungen folgen. Ändere -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn du keine GPU hast oder nur CPU-Inferenz möchtest.

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=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
cp llama.cpp/build/bin/llama-* llama.cpp

1. Wenn du llama.cpp direkt zum Laden von Modellen kannst du Folgendes tun: (:UD-IQ1_S) ist der Quantisierungstyp. Du kannst auch über Hugging Face herunterladen (Punkt 3). Dies ist ähnlich zu ollama run . Verwenden Sie export LLAMA_CACHE="folder" um zu erzwingen, dass llama.cpp um an einem bestimmten Speicherort zu speichern. Um das neue September-2025-Update für das Modell auszuführen, ändere den Modellnamen von 'Kimi-K2-Instruct' in 'Kimi-K2-Instruct-0905'.

Bitte probieren Sie -ot ".ffn_.*_exps.=CPU" verwenden, um alle MoE-Layer auf die CPU auszulagern! Dadurch können Sie effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen, was die Generierungsgeschwindigkeit verbessert. Sie können den Regex-Ausdruck anpassen, um mehr Layer 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 die MoE-Layer für Up- und Down-Projektionen aus.

Versuchen Sie -ot ".ffn_(up)_exps.=CPU" wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur die MoE-Layer für Up-Projektionen aus.

Und schließlich lagern Sie alle Layer aus via -ot ".ffn_.*_exps.=CPU" Dies verwendet am wenigsten VRAM.

Sie können den Regex auch 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-Layer auszulagern, aber nur ab der 6. Schicht.

export LLAMA_CACHE="unsloth/Kimi-K2-Instruct-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/Kimi-K2-Instruct-GGUF:TQ1_0 \
    --n-gpu-layers 99 \
    --temp 0.6 \\
    --min-p 0,01 \
    --ctx-size 16384 \
    --seed 3407 \\
    -ot ".ffn_.*_exps.=CPU"

1. Lade das Modell herunter über (nach der Installation von pip install huggingface_hub hf_transfer ). Du kannst UD-TQ1_0(Dynamic-1,8-Bit-Quant) oder andere quantisierte Versionen wie Q2_K_XL . Wir empfehlen die Verwendung unseres 2-Bit-Dynamic-Quants UD-Q2_K_XL zu verwenden, um Größe und Genauigkeit auszubalancieren. Weitere Versionen unter: huggingface.co/unsloth/Kimi-K2-Instruct-GGUF

# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Kann manchmal eine Ratenbegrenzung auslösen, daher auf 0 setzen, um zu deaktivieren
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/Kimi-K2-Instruct-GGUF",
    local_dir = "unsloth/Kimi-K2-Instruct-GGUF",
    allow_patterns = ["*UD-TQ1_0*"], # Dynamic 1bit (281GB) Verwende "*UD-Q2_K_XL*" für Dynamic 2bit (381GB)
)

Wenn du feststellst, dass Downloads bei etwa 90 bis 95 % hängen bleiben, siehe bitte https://docs.unsloth.ai/basics/troubleshooting-and-faqs#downloading-gets-stuck-at-90-to-95

1. Führe einen beliebigen Prompt aus.

2. Bearbeiten --threads -1 für die Anzahl der CPU-Threads (standardmäßig ist es auf die maximale Anzahl CPU-Threads gesetzt), --ctx-size 16384 für die Kontextlänge, --n-gpu-layers 99 für das GPU-Offloading, für wie viele Schichten. Setze es auf 99 zusammen mit MoE-CPU-Offloading, um die beste Leistung zu erhalten. Versuche, es anzupassen, wenn deiner GPU der Speicher ausgeht. Entferne es außerdem, wenn du nur CPU-Inferenz hast.

./llama.cpp/llama-cli \
    --model unsloth/Kimi-K2-Instruct-GGUF/UD-TQ1_0/Kimi-K2-Instruct-UD-TQ1_0-00001-of-00005.gguf \
    --n-gpu-layers 99 \
    --temp 0.6 \\
    --min-p 0,01 \
    --ctx-size 16384 \
    --seed 3407 \\
    -ot ".ffn_.*_exps.=CPU"

🐦 Flappy Bird + andere Tests

Wir haben den Flappy-Bird-Test eingeführt, als unsere 1,58-Bit-Qants für DeepSeek R1 bereitgestellt wurden. Wir stellten fest, dass Kimi K2 eines der wenigen Modelle ist, das alle unsere Aufgaben einschließlich dieser in einem Durchlauf löst, Heptagon und andere Tests sogar bei 2-Bit. Das Ziel ist, das LLM dazu zu bringen, ein Flappy-Bird-Spiel zu erstellen, aber unter Befolgung einiger spezifischer Anweisungen:

Erstelle ein Flappy-Bird-Spiel in Python. Du musst diese Dinge einschließen:
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 endgültige Spiel sollte sich in einem Markdown-Abschnitt in Python befinden. Prüfe deinen Code auf Fehler und behebe sie vor dem endgültigen Markdown-Abschnitt.

Du kannst die Dynamic Quants auch über den Heptagon-Test testen, gemäß r/Localllama der das Modell beim Erstellen einer einfachen Physik-Engine testet, um Bälle zu simulieren, die in einer sich bewegenden, geschlossenen Heptagon-Form rotieren.

Das Ziel ist, dass sich das Heptagon dreht und sich die Bälle im Heptagon bewegen. Der Prompt steht unten:

Schreibe ein Python-Programm, das 20 Bälle zeigt, die in einem rotierenden Heptagon herumhüpfen:\n- Alle Bälle haben denselben Radius.\n- Alle Bälle haben eine Nummer von 1 bis 20.\n- Alle Bälle fallen beim Start vom Zentrum des Heptagons.\n- Farben sind: #f8b862, #f6ad49, #f39800, #f08300, #ec6d51, #ee7948, #ed6d3d, #ec6800, #ec6800, #ee7800, #eb6238, #ea5506, #ea5506, #eb6101, #e49e61, #e45e32, #e17b34, #dd7a56, #db8449, #d66a35\n- Die Bälle sollten von Schwerkraft und Reibung beeinflusst werden und realistisch von den rotierenden Wänden abprallen. Es sollte auch Kollisionen zwischen den Bällen geben.\n- Das Material aller Bälle bestimmt, dass ihre Aufprall-Sprunghöhe den Radius des Heptagons nicht überschreiten darf, aber höher als der Ballradius sein muss.\n- Alle Bälle rotieren mit Reibung, die Zahlen auf dem Ball können verwendet werden, um die Rotation des Balls anzuzeigen.\n- Das Heptagon rotiert um sein Zentrum, und die Rotationsgeschwindigkeit beträgt 360 Grad pro 5 Sekunden.\n- Die Heptagon-Größe sollte groß genug sein, um alle Bälle aufzunehmen.\n- Verwende nicht die pygame-Bibliothek; implementiere Kollisionsdetektionsalgorithmen und Kollisionsreaktion usw. selbst. Die folgenden Python-Bibliotheken sind erlaubt: tkinter, math, numpy, dataclasses, typing, sys.\n- Der gesamte Code sollte in einer einzigen Python-Datei stehen.