> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/modelle/deepseek-v4.1-flash.md).

# DeepSeek-V4.1-Flash: Anleitung zum lokalen Ausführen

Führe DeepSeek-V4.1-Flash-1017 lokal mit Unsloth GGUFs und Engram-n-Gramm-Auslagerung aus.

**DeepSeek-V4.1-Flash-1017** ist das neue Update für V4.1-Flash und damit das **leistungsstärkste** Open-Source-Modell bisher für Programmierung, agentische Aufgaben und mehr. Mit einem Kontextfenster von 1 Mio. Token unterstützen seine **552B** Backbone- + **196B Engram-** Parameter SSD-Offloading, um den RAM-/VRAM-Bedarf zu reduzieren. Diese Anleitung zeigt, wie du DeepSeek-V4.1 lokal mit Unsloth [Dynamic V3.1](#dynamic-v3.1-update-october-30th-2026) GGUFs ausführst, die eine um **10–15 % höhere Genauigkeit** und **30 % weniger Tokenverbrauch** als andere Quants derselben Größe bieten.

[Unsloth Desktop](https://unsloth.ai/docs/de/desktop.md) + llama.cpp ermöglicht eine etwa**3-mal schnellere** DeepSeek-V4.1-Inferenz als andere CPU-/VRAM-/Ngram-Repositories. DeepSeek läuft lokal auf Systemen mit mindestens 128 GB RAM oder mit 64 GB RAM (langsamer). `UD-Q8_K_XL` (verlustfrei) hat eine Größe von **508,4 GB**, während `UD-Q4_K_XL` (nahezu verlustfrei) **500,7 GB**groß ist. GGUF: [**DeepSeek-V4.1-Flash-1017-GGUF**](https://huggingface.co/unsloth/DeepSeek-V4.1-Flash-1017-GGUF)

<a href="https://unsloth.ai/docs/de/modelle/deepseek-v4.1-flash.md#usage-guide" class="button primary">DeepSeek-V4.1-Tutorials ausführen</a>

### Update zu Dynamic V3.1 (2. November 2026)

Wir veröffentlichen neue DeepSeek-V4.1-Flash-1017-GGUFs, die unseren neuen [**Unsloth Dynamic**](https://unsloth.ai/docs/de/grundlagen/dynamic-3.0-ggufs.md) **V3.1-Algorithmus (Vorschau)** verwenden. Dieser verbessert Unsloth-Quants bei nahezu allen Benchmarks und ist im Vergleich zu anderen Anbietern branchenführend.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FXC2NHQCS4KKsMoY4IjpT%2Fimage.png?alt=media&amp;token=67fb9d55-8fbb-4f35-a13f-83465cee8475" alt="" width="563"><figcaption></figcaption></figure>

Wenn wir auch das Coder-Modell von ISTA benchmarken, sehen wir, dass das beschnittene Coder-Modell bei agentischen Aufgaben deutlich schlechter abschneidet: Aider Polyglot erreicht eine Genauigkeit von 47,6 % statt 78,2 % und ist dabei nur 20 % kleiner. Das bedeutet teilweise, dass jeder Rückgang der Größe um 1 % mit einem Rückgang der Genauigkeit um etwa 1 % einhergeht.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fe3HYFau6qEpkFwkLVwru%2FCoder%20benchmark.png?alt=media&amp;token=59e2ab09-3f42-4226-bd03-3b5a8d109e6a" alt="" width="563"><figcaption></figcaption></figure>

**Wir haben agentische Benchmarks durchgeführt, darunter Terminal Bench 2.1, DeepSWE v1.1,** Automation Bench v1.0.6, Aider Polyglot sowie allgemeine Benchmarks wie SciCode, HLE Diamond (nur Text), LiveCodeBench v6, GPQA Diamond, MMLU-Pro, AIME25, IFEval, MATH-500 (Level 5), HMMT 2025 und HMMT 2026. Wir sind auf einige Probleme eingegangen, die angesichts dieser neuen Benchmarks angesprochen wurden:

* Ein Kontext von 32K war zu kurz – wir verwendeten **512K Kontext für agentische Aufgaben** + 128K für allgemeine Aufgaben
* Gesättigte Benchmarks – neue, **nicht gesättigte Benchmarks im agentischen Stil,** darunter Terminal Bench, DeepSWE und Automation Bench
* Benchmarks sind verrauscht – wir verwendeten **35,1B Tokens für das Benchmarking statt zuvor 1,3B, also 27-mal mehr Daten**. Siehe [#benchmark-runs-per-model](#benchmark-runs-per-model "mention") dort führten wir 64 AIME-2025-Durchläufe, 3 DeepSWE-Durchläufe, 3 TB-Durchläufe und mehr aus.
* Unsere Bewertungsverfahren sind fehlerhaft – wir verwendeten [Math Verify](https://huggingface.co/blog/math_verify_leaderboard), verbesserte Bewertungsverfahren, für HLE gpt-6-luna xhigh sowie die offiziellen Bewertungsverfahren für Terminal Bench (Harbor), DeepSWE und die übrigen Benchmarks. Siehe [#graders](#graders "mention") und [#infrastructure-and-benchmark-issues-and-fixes](#infrastructure-and-benchmark-issues-and-fixes "mention")

Die vollständigen Benchmark-Ergebnisse sind ebenfalls verfügbar. Das erste Diagramm zeigt die prozentuale Genauigkeitswiederherstellung gegenüber der Baseline, gemittelt über alle 14 Benchmarks (ungewichtet). Dies ist ungefähr ein Maß dafür, wie viel Genauigkeit jede Quantisierung im Vergleich zur DeepSeek-Baseline beibehält.

Eine [vollständige Aufschlüsselung unserer Benchmarks finden Sie hier.](#gguf-benchmark-breakdown)

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FQumjSkZM3UWgSRSa5taa%2Fimage.png?alt=media&amp;token=23092c27-abae-4376-b44a-7ae91f918705" alt="" width="563"><figcaption></figcaption></figure>

#### Wir können die Wiederherstellungswerte von GSQ-RCO weiterhin nicht reproduzieren

GSQ-RCO IQ1\_M gibt eine Wiederherstellung von 98,7 % an, wir haben jedoch 97,24 \[96,23, 98,21] mit einem **p-Wert von 0,0013** (statistisch signifikant, also extrem unwahrscheinlich)

Dass GSQ-RCO IQ2\_XS die angegebene Wiederherstellung von 100 % erreicht, ist bei einem p-Wert von 0,21 möglich. Wir haben 98,38 % \[97,52, 99,22] gemessen.

GSQ-RCO IQ2\_XXS gibt eine Wiederherstellung von 99,80 % an, wir haben jedoch 98,38 \[97,52, 99,22] mit einem **p-Wert von 0,0001 gemessen (extrem signifikant)**.

Die angegebene Wiederherstellung wurde direkt mit unserer Messung verglichen (Definition auf der Karte: Summe der 3 Werte / Summe der Baseline, gegenüber offiziellen FP8/FP4-Werten): p (kein Verlust) = gepaarter Vorzeichen-Flip-Permutationstest für eine Wiederherstellung von = 100 %; p (Wiederherstellung >= Angabe) = einseitiger gepaarter Bootstrap über die Fragen.

|                  | Angegebene Wiederherstellung | Gemessene Wiederherstellung \[95-%-KI] | p (kein Verlust) | p (Wiederherstellung >= Angabe) |
| ---------------- | ---------------------------: | -------------------------------------: | ---------------: | ------------------------------: |
| GSQ-RCO IQ1\_M   |                        98.70 |                  97.24 \[96.23, 98.21] |          0.00002 |                          0.0013 |
| GSQ-RCO IQ2\_XXS |                       100.00 |                  98.38 \[97.52, 99.22] |           0.0003 |                          0.0001 |
| GSQ-RCO IQ2\_XS  |                        99.80 |                 99.54 \[98.88, 100.18] |             0.16 |                            0.21 |

Angegebene gegenüber tatsächlicher Wiederherstellung je Benchmark, jeweils verglichen mit den offiziellen FP8/FP4-Werten (der Baseline der Karte). Angegeben = Kartenwert / Karten-Baseline; tatsächlich = unser Mittelwert aus 12–64 Stichproben pro Frage / Mittelwert des offiziellen Modells für dieselben Fragen, gepaartes 95-%-Bootstrap-KI. p (tatsächlich >= Angabe): einseitiger gepaarter Bootstrap; gibt die Wahrscheinlichkeit an, dass die tatsächliche Wiederherstellung den angegebenen Wert erreicht. p (kein Verlust): zweiseitiger gepaarter Permutationstest für eine tatsächliche Wiederherstellung von = 100 % (das Quantisierungs-/offizielle Paar jeder Frage wird zufällig vertauscht). Unsloth-Quantisierungen (nur gemessen) dienen als Referenz bei ähnlichen Größen.

<details>

<summary>Klicken Sie hier für eine detaillierte Tabellenanalyse</summary>

| Modell           |                           |                  AIME25 |                  GPQA-D |                  LCB v6 | 3 Benchmarks (Kartendefinition) |
| ---------------- | ------------------------- | ----------------------: | ----------------------: | ----------------------: | ------------------------------: |
| GSQ-RCO IQ1\_M   | angegeben (Karte)         |                  100.00 |                   97.22 |                   98.73 |                           98.69 |
|                  | tatsächlich (gemessen)    |   98.37 \[97.06, 99.53] |   96.83 \[94.60, 98.89] |   96.44 \[94.69, 98.08] |           97.24 \[96.24, 98.21] |
|                  | p (tatsächlich >= Angabe) |                  0.0028 |                    0.38 |                  0.0027 |                          0.0014 |
|                  | p (kein Verlust)          |                   0.019 |                  0.0041 |                 <0.0001 |                         <0.0001 |
| GSQ-RCO IQ2\_XXS | angegeben (Karte)         |                  100.00 |                  100.00 |                  100.00 |                          100.00 |
|                  | tatsächlich (gemessen)    |  99.53 \[98.84, 100.21] |   97.73 \[95.80, 99.61] |   97.80 \[96.08, 99.39] |           98.38 \[97.52, 99.23] |
|                  | p (tatsächlich >= Angabe) |                     0.1 |                  0.0092 |                  0.0027 |                         <0.0001 |
|                  | p (kein Verlust)          |                    0.25 |                   0.022 |                  0.0085 |                         0.00025 |
| GSQ-RCO IQ2\_XS  | angegeben (Karte)         |                  100.00 |                   99.44 |                  100.00 |                           99.82 |
|                  | tatsächlich (gemessen)    |  99.58 \[98.53, 100.47] |  99.45 \[98.12, 100.73] |  99.58 \[98.47, 100.70] |          99.54 \[98.88, 100.17] |
|                  | p (tatsächlich >= Angabe) |                    0.21 |                    0.51 |                    0.24 |                            0.19 |
|                  | p (kein Verlust)          |                    0.48 |                    0.43 |                    0.52 |                            0.17 |
| UD IQ1\_S        | tatsächlich (gemessen)    |  99.58 \[98.96, 100.21] |   97.42 \[95.41, 99.39] | 100.21 \[99.03, 101.38] |           99.08 \[98.29, 99.85] |
|                  | p (kein Verlust)          |                    0.26 |                   0.011 |                    0.73 |                           0.023 |
| UD IQ1\_M        | tatsächlich (gemessen)    |  99.68 \[98.94, 100.42] |   98.37 \[96.95, 99.76] | 100.37 \[99.15, 101.61] |          99.48 \[98.82, 100.14] |
|                  | p (kein Verlust)          |                    0.52 |                   0.025 |                    0.56 |                            0.13 |
| UD IQ2\_XXS      | tatsächlich (gemessen)    | 100.00 \[99.32, 100.58] |  99.53 \[98.36, 100.68] | 100.47 \[99.27, 101.74] |         100.00 \[99.40, 100.58] |
|                  | p (kein Verlust)          |                       1 |                    0.45 |                    0.46 |                               1 |
| UD Q2\_K\_XL     | tatsächlich (gemessen)    |  99.79 \[99.16, 100.37] |  99.74 \[98.69, 100.77] | 100.89 \[99.90, 101.93] |         100.13 \[99.63, 100.65] |
|                  | p (kein Verlust)          |                    0.63 |                    0.66 |                   0.076 |                            0.62 |
| UD-Q8\_K\_XL     | tatsächlich (gemessen)    |  99.47 \[97.94, 100.53] | 100.28 \[99.52, 101.09] | 100.89 \[99.95, 101.95] |         100.19 \[99.53, 100.77] |
|                  | p (kein Verlust)          |                    0.73 |                    0.48 |                   0.084 |                            0.59 |

</details>

#### AIME-2025-Fragen, die GSQ-RCO IQ1\_M falsch beantwortet hat

GSQ-RCO IQ1\_M erzielt bei AIME 2025 eine Punktzahl von 97,34 % (51 falsche Antworten bei 1.920 Stichproben, 64 pro Frage) und verfehlt bei 15 der 30 Fragen mindestens eine Stichprobe. Daher kommt ein einzelner Durchlauf mit 30/30 etwa 43 % der Zeit vor. Jede falsche Antwort ist tatsächlich falsch (bei 2 wurde die Grenze von 128K ohne endgültige Antwort erreicht). Zum Vergleich die Anzahl richtiger Antworten anderer Modelle bei denselben Fragen:

<details>

<summary>Klicken Sie hier für eine detaillierte Tabellenanalyse</summary>

| Frage (Antwort) | GSQ IQ1\_M falsch / Stichproben | Gegebene falsche Antworten                            | Offiziell richtig | UD-Q8\_K\_XL richtig | UD IQ1\_S richtig | GSQ IQ2\_XS richtig |
| --------------- | ------------------------------: | ----------------------------------------------------- | ----------------: | -------------------: | ----------------: | ------------------: |
| Q15 (735)       |                            9/64 | 637 x2, 833 x2, 271, 636, 613, 52, 539                |             31/32 |                60/64 |             59/64 |               56/64 |
| Q28 (248)       |                            8/64 | 888, 256, 608, 808, 632, 592, 136, 448                |             31/32 |                63/64 |             60/64 |               64/64 |
| Q22 (237)       |                            6/64 | 57, 993, 945, 249, 473, 125                           |             32/32 |                63/64 |             62/64 |               64/64 |
| Q13 (204)       |                            5/64 | \frac{587}{3}, 154, \frac{662}{3}, \frac{562}{3}, 179 |             31/32 |                64/64 |             63/64 |               63/64 |
| Q24 (149)       |                            5/64 | 150 x4, 145                                           |             30/32 |                48/64 |             63/64 |               55/64 |
| Q5 (279)        |                            4/64 | 9 x2, 135, 423                                        |             32/32 |                63/64 |             63/64 |               63/64 |
| Q4 (117)        |                            3/64 | 119 x3                                                |             31/32 |                64/64 |             62/64 |               64/64 |
| Q11 (259)       |                            2/64 | 23, 261                                               |             32/32 |                64/64 |             64/64 |               64/64 |
| Q14 (60)        |                            2/64 | keine endgültige Antwort (128K-Begrenzung) x2         |             31/32 |                64/64 |             63/64 |               64/64 |
| Q18 (82)        |                            2/64 | 106, 712                                              |             32/32 |                63/64 |             64/64 |               64/64 |
| Q2 (588)        |                            1/64 | 1176                                                  |             32/32 |                64/64 |             64/64 |               64/64 |
| Q3 (16)         |                            1/64 | 520                                                   |             31/32 |                63/64 |             62/64 |               63/64 |
| Q7 (821)        |                            1/64 | 271                                                   |             32/32 |                63/64 |             63/64 |               63/64 |
| Q19 (106)       |                            1/64 | 317                                                   |             32/32 |                63/64 |             63/64 |               63/64 |
| Q29 (104)       |                            1/64 | 55                                                    |             32/32 |                64/64 |             64/64 |               62/64 |

</details>

Q28 und Q22 sind Folgen von Quantisierungsfehlern (IQ1\_M verfehlt 8 bzw. 6 von 64; bei GSQ IQ2\_XS und dem offiziellen Modell kommt das fast nie vor); Q15 und Q24 sind für jedes Modell schwierig (UD-Q8\_K\_XL beantwortet Q24 in 48/64 Fällen richtig und antwortet häufig mit 150 statt 149).

### Dynamic-V3.1-Update (30. Oktober 2026)

Wir haben AIME25, Aider Polyglot, LiveCodeBench v6, HMMT 2026, GPQA Diamond, MMLU-Pro, IFEval und weitere Benchmarks mit all unseren UDv3- und UD3.1-Quants sowie den GSQ-RCO-Varianten durchgeführt. Für Letztere wurde behauptet, sie erreichten bei AIME25 mit allen Quants 100 %, doch wir konnten diese Zahlen nicht reproduzieren.

Wir geben einen vollständigen Durchschnitt aus 6 Benchmarks an (Aider Polyglot ausgenommen – bezieht man Aider mit ein, ist der Unterschied noch deutlicher) und zeigen, dass UD3.1 bei nahezu allen Aufgaben gut abschneidet.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FOuLKE4mwn1xkCJchptDN%2Ftotal_ista.png?alt=media&amp;token=cdc15dba-6b30-4ca3-8318-94138acf6d27" alt=""><figcaption></figcaption></figure>

#### Wir können die Zahlen von GSQ-RCO nicht reproduzieren

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FgEHmQB9WBKLJ1vMssB6N%2Fclaims_ista.png?alt=media&amp;token=838ee657-1085-4c00-bcdb-66abbe2862c1" alt=""><figcaption></figcaption></figure>

Für die von ISTA-DASLab erstellten GSQ-RCO-Quants von DeepSeek-V4.1-Flash-1017 wurde angegeben, dass sie bei AIME25 mit allen Quants 100 % erreichten. Wir konnten das nicht reproduzieren und zeigen anhand mehrerer Durchläufe von AIME25 und ihres Durchschnitts, dass **GSQ-RCO 94,64 % der Basisleistung beibehält (nicht 100 %)**. Im zweiten Diagramm haben wir auch alle Basiswerte skaliert, um den methodischen Unterschieden Rechnung zu tragen.

<div><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FMFdsiPUHkPAXMYPblKDx%2Fgsq_rco_claims_vs_true_bars(1).png?alt=media&amp;token=99b6f559-52fe-481f-911a-92b559cfd01f" alt=""><figcaption></figcaption></figure> <figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FDHa3imd8XoDXehkvATcC%2Fgsq_rco_claims_vs_true_bars_recovery.png?alt=media&amp;token=244b229c-1b23-47e3-bfa5-d0b9631f426b" alt=""><figcaption></figcaption></figure></div>

Für AIME25 meldete ISTA eine Genauigkeit von 100 % bei allen drei Quants. Als wir jedoch jedes Quant 16-mal pro Frage auf AIME25 testeten – 30 Aufgaben × 16 Stichproben = 480 Antworten pro Quant, bei Temperatur 1,0 und einem Reasoning-Aufwand von 50 –, stellten wir bei den Quants einen deutlichen Leistungsabfall fest; bei keiner Bitbreite lag die Genauigkeit bei 100 %.&#x20;

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FtcF0k9ss042lXLgvDyIt%2Faime25.png?alt=media&amp;token=8025e417-e669-43cb-bf8f-ce69a9254aca" alt="" width="375"><figcaption></figcaption></figure>

Laut README.md wurden die GSQ-RCO-Benchmarks ebenfalls mit einem Reasoning-Aufwand von 50 durchgeführt.

#### KLD ist eine sinnvolle Metrik

In letzter Zeit wurde behauptet, KLD sei keine gute Metrik. Die Kullback-Leibler-Divergenz (KLD) misst, wie stark die Vorhersagen des nächsten Tokens eines quantisierten Modells für denselben Text von denen eines Referenzmodells abweichen.

$$
\text{min  } D\_{KL} \large( \theta, \hat{\theta}\large)
$$

**Das Hauptziel der Quantisierung besteht darin, die KLD auf 0 zu minimieren und gleichzeitig den Speicherbedarf des quantisierten Modells zu verringern** (man kann auch weitere Optimierungsziele einbeziehen, zum Beispiel die Generierungsgeschwindigkeit).

Bei einer KLD von 0 sind die Ausgabelogits des Modells perfekt rekonstruiert, sodass das quantisierte Modell exakt dieselbe Ausgabe wie das Originalmodell erzeugt.

Man sieht deutlich, dass GSQ-RCO eine höhere KLD und eine geringere Top-1-%-Übereinstimmung aufweist als selbst unsere älteren Unsloth-v3-Quants – v3.1 verbessert diese Werte weiter.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F0YkDIvosvnP6nRVlhNy5%2FKLD%20ISTA.png?alt=media&amp;token=a4601232-2858-4b8d-a618-8991a48eeb6d" alt="" width="563"><figcaption></figcaption></figure>

Manche behaupten, die KLD lasse sich durch Betrug „manipulieren“ oder für Benchmarks optimieren, indem man sie auf dem Testdatensatz oder anhand nur eines Datensatzes berechnet. Um diese Behauptung zu überprüfen, haben wir die KLD auf mehreren zurückgehaltenen Tests berechnet und zeigen, dass UDv3.1 in allen Bereichen besser abschneidet als GSQ-RCO.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FBBJeFPqCiW0Al9IvGNsC%2Fsize_vs_kld_per_axis(2).png?alt=media&amp;token=08452280-2005-4fa9-bdc7-a37f162b49e7" alt=""><figcaption></figcaption></figure>

Wir geben außerdem die Top-1-%-Übereinstimmung für alle zurückgehaltenen Tests an:

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FcCroCNVfybzFZ7lAMHVy%2Fsize_vs_top1_per_axis(2).png?alt=media&amp;token=a7f50164-e15c-45ef-911b-e73882436845" alt=""><figcaption></figcaption></figure>

#### Quantisierung verlängert die Reasoning-Zeit

Wir haben auch untersucht, ob Quants mit weniger Bits länger nachdenken. Dafür haben wir alle Tests auf eine Kontextlänge von 32K eingestellt und Quants ausgeschlossen, wenn sie zu lange nachdenken. Außerdem haben wir LiveCodeBench mit bis zu 128K Tokens ausgeführt; die Ergebnisse sind ähnlich. Wir geben für alle 6 Benchmarks die Anzahl der abgeschnittenen Antworten an und zeigen, dass bei Unsloth-Quants deutlich seltener Antworten abgeschnitten werden als bei GSQ-Quants (sie denken also weniger lange nach).

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FEKPO459yFA9vQwKohCR0%2Ftruncation.png?alt=media&amp;token=e8ddafad-7f4e-4891-a329-511ffd177365" alt="" width="375"><figcaption></figcaption></figure>

Das zeigt jedoch, dass Quantisierung die Länge des Denkprozesses erhöht. Stellen Sie sich bei Quants mit weniger Bits daher auf ein höheres Reasoning-Budget ein.

#### Engram-Entfernung für Benchmarks

Für die Diagramme haben wir außerdem das Engram entfernt. Das ändert jedoch nichts, da alle Quants mit wenigen Bits IQ4\_NL als Engram verwenden – Q2\_K\_XL und IQ2\_XXS verwenden Q5\_K.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fzggh3ij4y2HInPA0LU80%2Fremove%20engram.png?alt=media&amp;token=5900687a-ad79-4d69-8650-318fa3a17d61" alt=""><figcaption></figcaption></figure>

#### Vollständige Benchmark-Ergebnisse

<details>

<summary>Klicken Sie hier für eine detaillierte Tabellenanalyse</summary>

| Quant                   | Größe (GB) | AIME25 | HMMT Feb26 | GPQA-D | MMLU-Pro | IFEval | LCB v6 (32K) | Durchschnitt aus 6 | Aider pass\@1 | Abgeschnitten (%) (6) |
| ----------------------- | ---------: | -----: | ---------: | -----: | -------: | -----: | -----------: | -----------------: | ------------: | --------------------: |
| UD-Q8\_K\_XL (Referenz) |      508.4 |  97.08 |      68.94 |  90.47 |    88.61 |  95.10 |        85.90 |              87.68 |             - |                  1.48 |
| UD-Q2\_K\_XL (v3.1)     |      334.8 |  97.50 |      69.89 |  89.58 |    88.28 |  94.92 |        84.76 |              87.49 |             - |                  2.10 |
| UD-IQ2\_XXS (v3.1)      |      300.5 |  96.88 |      67.61 |  88.95 |    87.53 |  95.19 |        83.62 |              86.63 |         44.38 |                  2.71 |
| UD-IQ1\_M (v3.1)        |      250.4 |  95.00 |      62.88 |  88.38 |    87.53 |  95.10 |        84.38 |              85.55 |         42.13 |                  2.91 |
| UD-IQ1\_S (v3.1)        |      233.0 |  92.92 |      57.01 |  87.63 |    86.62 |  94.92 |        82.10 |              83.53 |         36.52 |                  4.15 |
| GSQ-RCO IQ2\_XS         |      265.8 |  95.00 |      64.39 |  88.64 |    86.62 |  94.27 |        84.95 |              85.64 |         41.57 |                  2.83 |
| GSQ-RCO IQ2\_XXS        |      248.8 |  95.21 |      57.95 |  85.80 |    86.53 |  93.72 |        82.86 |              83.68 |         36.52 |                  4.00 |
| GSQ-RCO IQ1\_M          |      231.3 |  91.88 |      53.60 |  85.10 |    85.49 |  91.77 |        82.86 |              81.78 |         29.78 |                  4.69 |

</details>

#### Vollständige Benchmark-Methoden

<details>

<summary>Klicken Sie hier für eine detaillierte Tabellenanalyse</summary>

| Benchmark             | Quelle (Revision)                            | Elemente |       Stichproben pro Element |        Max. Tokens | Basis-Seed          | Prompt                                                                             | Bewertung                                                                                       |
| --------------------- | -------------------------------------------- | -------: | ----------------------------: | -----------------: | ------------------- | ---------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
| AIME25                | MathArena/aime\_2025 (c94da77e)              |       30 |                            16 |             32,768 | 20261029            | problem + "Please reason step by step, and put your final answer within \boxed{}." | math\_verify für das letzte \boxed{}, ersatzweise exakte Ganzzahl                               |
| HMMT Feb26            | MathArena/hmmt\_feb\_2026                    |       33 |                            16 |             32,768 | 20261029            | wie AIME25                                                                         | math\_verify                                                                                    |
| GPQA-D                | Idavidrein/gpqa diamond (633f5ee8)           |      198 | 8 (4 + 4; frühere Uploads: 4) |             32,768 | 20261026 + 20261029 | Multiple-Choice-Vorlage von OpenAI simple-evals                                    | letztes "Answer: X", ersatzweise \boxed{X}, "answer is (X)", einzelner Buchstabe                |
| MMLU-Pro              | Stratifizierte Teilmenge mit 1.203 Elementen |    1,203 |                             2 |             32,768 | 20261029            | im Stil von simple-evals, bis zu 10 Optionen                                       | letztes "Answer: X"                                                                             |
| IFEval                | google/IFEval                                |      541 |                             2 |             32,768 | 20261029            | unveränderter Prompt                                                               | offizielles instruction\_following\_eval, streng, auf Prompt-Ebene                              |
| LCB v6 (32K)          | livecodebench/code\_generation\_lite test6   |      175 |                             3 |             32,768 | 20261026            | offizieller LCB-System- und User-Prompt                                            | offizielles extract\_code + run\_test, 6 s pro Test, in einer Sandbox ausgeführter Unterprozess |
| Durchschnitt aus 6    | Alle obigen Benchmarks                       |          |                               |                    |                     |                                                                                    | Mittelwert der 9 pass\@1-Werte                                                                  |
| Aider pass\@1         | Aider Polyglot                               |      225 |                   1 Durchlauf | 32.768 pro Antwort | n. zutr.            | offizieller Aider-Benchmark in Docker                                              | die Unit-Tests der Übung                                                                        |
| Abgeschnitten (%) (6) | die 6 Benchmarks                             |          |                               |             32,768 |                     |                                                                                    | Anteil der Antworten, die am Token-Limit enden                                                  |

</details>

### ⚙️ Nutzungshinweise

**DeepSeek-V4.1-Flash-1017** kombiniert MoE mit **Engram-Konditionalspeicher**: N-Gramme mit bis zu vier Tokens greifen pro Token auf einige Tabellenzeilen zu, sodass die Tabelle nicht im GPU-Speicher verbleiben muss. Für die Inferenz empfiehlt sich Unsloth, da es bis zu **3-mal schnellere** DeepSeek-V4.1-Inferenz als andere auf CPU/VRAM/N-Gramme ausgerichtete Repositories ermöglicht, indem es auf llama.cpp aufbaut und dieses optimiert.

1-Bit `UD-IQ1_S` funktioniert mit Konfigurationen mit 128 GB RAM, etwa einem MacBook, DGX Spark oder RTX Spark, während die 3-Bit-Variante `UD-IQ3_XXS` funktioniert auf Systemen mit 256 GB RAM wie einem Mac Studio.

Wie die PLE-/N-Gramm-Ebenen in unserem [Qwen3.8-Flash-Next](https://unsloth.ai/docs/de/modelle/qwen3.8-next.md) Leitfaden kann die 110,6–202,8-GB-Tabelle von Engram per mmap auf der SSD verbleiben. Zeilen werden bei Bedarf in den Betriebssystem-Cache geladen. Das spart RAM/VRAM, während der volle Speicherplatzbedarf auf der Festplatte erhalten bleibt.

#### **Anforderungen für DeepSeek-V4.1-Flash-1017:**

**Tabelle: Hardwareanforderungen** (RAM + VRAM oder gemeinsamer Speicher; Engram auf SSD).

| 1 Bit      | 2 Bit      | 3 Bit      | 4 Bit  | 8 Bit  |
| ---------- | ---------- | ---------- | ------ | ------ |
| 128–145 GB | 176–205 GB | 256–290 GB | 305 GB | 315 GB |

Die Schätzungen liegen etwa 5–10 GB über dem Bedarf für Gewichte ohne Engram. Laufzeit und Kontext können mehr Speicher erfordern.

**N-Gramm-Speicher:** Die Lookup-Formate und Gewichtungsgrößen sind unten aufgeführt. „Rest GB“ bezeichnet die absolut erforderliche Mindestmenge an RAM/VRAM.

| Quant        | N-Gramm-Format / GB | Rest GB |
| ------------ | ------------------- | ------- |
| UD-IQ1\_S    | IQ4\_NL / 110.6     | 122.4   |
| UD-IQ1\_M    | IQ4\_NL / 110.6     | 139.8   |
| UD-IQ2\_XXS  | Q5\_K / 135.2       | 165.3   |
| UD-Q2\_K\_XL | Q5\_K / 135.2       | 199.6   |
| UD-IQ3\_XXS  | Q6\_K / 161.3       | 233.5   |
| UD-IQ3\_S    | Q6\_K / 161.3       | 262.3   |
| UD-Q3\_K\_XL | MXFP8 / 202.8       | 282.3   |
| UD-Q4\_K\_XL | MXFP8 / 202.8       | 297.9   |
| UD-Q8\_K\_XL | MXFP8 / 202.8       | 305.6   |

### Empfohlene Einstellungen

DeepSeek empfiehlt temperature = 1.0 und top-p = 1.0 sowie, top-k und min-p zu deaktivieren:

| Parameter             | Einstellung        |
| --------------------- | ------------------ |
| `temperature`         | `1.0`              |
| `top_p`               | `1.0`              |
| Maximale Kontextlänge | `1,048,576` Tokens |

DeepSeek empfiehlt, für die Langgenerierung **mindestens 256K Ausgabetokens** zuzulassen.

#### **Denkaufwand**

Das Denken ist standardmäßig aktiviert, mit `reasoning_effort=75` („hoch“). Sie können eine ganze Zahl zwischen **1 und 100**. Höhere Werte veranlassen das Modell zu gründlicherem Nachdenken; sie sind kein Token-Limit. Die enthaltene Vorlage akzeptiert außerdem `low` = 50, `medium` = 62, `high` = 75 und `max` = 100.

Füge beispielsweise eine dieser Optionen zu deinem Startbefehl hinzu:

```bash
# Standard-Aufwand für das Nachdenken
--chat-template-kwargs '{"reasoning_effort":75}'

# Maximaler Aufwand für das Nachdenken
--chat-template-kwargs '{"reasoning_effort":100}'

# Nachdenken deaktivieren
--chat-template-kwargs '{"enable_thinking":false}'
```

## Führe **DeepSeek-V4.1-Flash-1017** Tutorials:

In diesem Tutorial verwenden wir `UD-Q2_K_XL`. Unsloth wählt automatisch nahezu optimale Konfigurationen für DeepSeek-V4.1-Offloading, N-Gramme usw. aus, damit dein Setup eine möglichst hohe Geschwindigkeit erzielt.

### 🦥 Unsloth-Anleitung

[Unsloth Desktop](https://unsloth.ai/docs/desktop) ist unsere Open-Source-Oberfläche für lokale KI unter macOS, Windows und Linux. Du kannst GGUFs suchen und herunterladen, das CPU- und GPU-Offloading konfigurieren, Inferenz-Einstellungen anpassen und Tools über eine einzige App verbinden.

{% stepper %}
{% step %}

#### Unsloth installieren

Am einfachsten startest du, indem du die [Unsloth-Desktop-App](https://unsloth.ai/docs/de/desktop.md) herunterlädst. Funktioniert unter [macOS](https://unsloth.ai/docs/de/loslegen/install/mac.md), [Windows](https://unsloth.ai/docs/de/loslegen/install/windows-installation.md) und [Linux](https://unsloth.ai/docs/de/loslegen/install/linux.md).

<a href="https://unsloth.ai/download" class="button primary" data-icon="down-to-bracket">Unsloth herunterladen</a>

* <i class="fa-apple">:apple:</i> [Für macOS herunterladen](https://unsloth.ai/download/mac)
* <i class="fa-windows">:windows:</i> [Für Windows herunterladen](https://unsloth.ai/download/windows)
* <i class="fa-linux">:linux:</i> [Für Linux herunterladen](https://unsloth.ai/download/linux)

Oder, wenn du die manuelle Installation bevorzugst:
{% endstep %}

{% step %}

#### DeepSeek-V4.1-Flash-1017 suchen und herunterladen

Öffne [Unsloth Chat](https://unsloth.ai/docs/de/neu/studio/chat.md) oder den Model Hub und suche nach **DeepSeek-V4.1-Flash-1017** und wähle [unsloth/DeepSeek-V4.1-Flash-1017-GGUF](https://huggingface.co/unsloth/DeepSeek-V4.1-Flash-1017-GGUF). Lade die gewünschte Quantisierung anhand der oben angegebenen Größen und Speicheranforderungen herunter.
{% endstep %}

{% step %}

#### DeepSeek-V4.1-Flash-1017 ausführen

Mit `75` ist „Thinking“ standardmäßig aktiviert. Du kannst die Einstellung über unseren Umschalter ändern. Unsloth wählt automatisch nahezu optimale Konfigurationen für DeepSeek-V4.1-Offloading, N-Gramme usw. aus, damit dein Setup eine möglichst hohe Geschwindigkeit erreicht.

Weitere Informationen findest du in unserem [Unsloth-Inferenzleitfaden](https://unsloth.ai/docs/de/neu/studio/chat.md).

Bei UD-IQ1\_S umfasst der 233,0-GB-Download eine 110,6-GB-Engram-N-Gramm-Tabelle und 122,4 GB an sonstigen Gewichten. Verwende das bedarfsgesteuerte Laden von Engram, um die Lookup-Tabelle auf der SSD zu belassen; zusätzlich benötigst du RAM/VRAM für zwischengespeicherte Zeilen, den Kontext und Laufzeitpuffer. Beachte die Speicheranforderungen im obigen Nutzungshandbuch.
{% endstep %}

{% step %}

#### DeepSeek-V4.1-Flash-1017 mit der Unsloth-API bereitstellen

Du kannst den Befehl `unsloth run` verwenden, um DeepSeek-V4.1-Flash-1017 über eine API mit der Laufzeitumgebung `llama-server` bereitzustellen. Zu den Laufzeitoptionen gehören Kontextgröße, GPU-Layer, Threading, Sampling, Netzwerk und Tool-Konfiguration. Weitere Informationen findest du in unserer [API-Dokumentation](https://unsloth.ai/docs/de/grundlagen/api.md) oder mit [unsloth start](https://unsloth.ai/docs/de/integrationen/unsloth-start.md).

{% code overflow="wrap" %}

```bash
unsloth run --model unsloth/DeepSeek-V4.1-Flash-1017-GGUF:UD-Q2_K_XL \
    --temp 1.0 \
    --top-p 1.0 \
    --min-p 0.0 \
    --chat-template-kwargs '{"reasoning_effort":75}'
```

{% endcode %}

Verwende eine Laufzeitumgebung, die DeepSeek-V4.1-1017 und das bedarfsgesteuerte Laden von Engram unterstützt. Wenn die N-Gramm-Tabelle auf der Festplatte verbleibt, übernimm die SSD-Offloading- und Speichereinstellungen aus dem Nutzungshandbuch.
{% endstep %}

{% step %}

#### Unsloth ist jetzt einsatzbereit

Du kannst DeepSeek-V4.1-Flash-1017 über Unsloth Desktop mit deinen Tools verbinden. Unsloth unterstützt außerdem folgende Workflows:

* **Tools verbinden:** [Claude Code](https://unsloth.ai/docs/de/grundlagen/claude-code.md), [Codex](https://unsloth.ai/docs/de/grundlagen/codex.md), [Websuche](https://unsloth.ai/docs/de/neu/studio/chat.md#advanced-web-search), [MCP](https://unsloth.ai/docs/de/grundlagen/mcp.md) und mehr
* **Modelle trainieren:** Andere unterstützte Text-, Diffusions-, [Embedding-](https://unsloth.ai/docs/de/grundlagen/embedding-finetuning.md), und weitere Modelle feinabstimmen
* **Medien generieren:** Erstellen und trainieren Sie [Bilder](https://unsloth.ai/docs/de/grundlagen/diffusion-image.md), Videos, [Sprachsynthese (TTS)](https://unsloth.ai/docs/de/grundlagen/text-to-speech-tts-fine-tuning.md) lokal

<div align="center"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FYShiiub5gs5pCQLX6d4U%2FScreenshot%202026-08-15%20at%2012.18.24%E2%80%AFAM.png?alt=media&amp;token=d6996797-a144-4113-b4c3-155cca6c39a0" alt="Unsloth Desktop Agents settings interface example" width="563"><figcaption></figcaption></figure></div>
{% endstep %}
{% endstepper %}

### 🦙 DeepSeek-V4.1-Flash in llama.cpp ausführen

{% stepper %}
{% step %}
Wir müssen unseren speziellen llama.cpp-PR verwenden [hier](https://github.com/ggml-org/llama.cpp/pull/30817). Du kannst auch die folgenden Build-Anweisungen befolgen. Ändere `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` , wenn du keine GPU hast oder die Inferenz nur auf der CPU ausführen möchtest. **Für Apple-Mac-/Metal-Geräte** setze `-DGGML_CUDA=OFF` und fahre dann wie gewohnt fort – die Metal-Unterstützung ist standardmäßig aktiviert.

```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev git -y
git clone https://github.com/ggml-org/llama.cpp
git -C llama.cpp fetch origin pull/30817/head:deepseek41
git -C llama.cpp checkout deepseek41
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```

{% endstep %}

{% step %}
Um das Modell auszuführen, kannst du Folgendes tun:

```bash
pip install -U "huggingface_hub[cli]"
hf download unsloth/DeepSeek-V4.1-Flash-1017-GGUF \
    --local-dir unsloth/DeepSeek-V4.1-Flash-1017-GGUF \
    --include "*UD-Q2_K_XL*"
```

Bewahre alle sieben Shards im selben Ordner auf und gib bei `--model` den ersten Shard an. llama.cpp lädt die übrigen Shards automatisch.
{% endstep %}

{% step %}
Führen Sie es dann so aus:

```bash
./llama.cpp/llama-cli \
    --model unsloth/DeepSeek-V4.1-Flash-1017-GGUF/UD-Q2_K_XL/DeepSeek-V4.1-Flash-1017-UD-Q2_K_XL-00001-of-00007.gguf \
    --temp 1.0 \
    --top-p 1.0 \
    --top-k 0 \
    --min-p 0.0 \
    --chat-template-kwargs '{"reasoning_effort":75}' \
    --load-mode mmap \
    --lazy-mode on \
    --override-tensor "per_layer_token_embd.weight=CPU"
```

Dieses Beispiel lädt die Engram-N-Gramm-Tabelle bei Bedarf von der SSD. Lassen Sie `--load-mode mmap` und `--lazy-mode on` für das Auslagern auf die SSD aktiviert.
{% endstep %}
{% endstepper %}

### ⚡**DSpark**  – Speculative Decoding

DeepSeek-V4.1 umfasst **DSpark**, eine Architektur für spekulatives Decoding, die mehrere Tokens vorschlägt, bevor das Hauptmodell sie überprüft. Sie ist unabhängig von der Engram-N-Gramm-Lookup-Tabelle: **Engram stellt erlernten Speicher bereit; DSpark beschleunigt das Decoding**. Die ähnlich benannte Option für spekulatives N-Gramm-Decoding ist ebenfalls eine andere Funktion.

Verwenden Sie für DSpark das Hauptmodell zusammen mit einem passenden **V4.1-1017-Drafter** und einer Laufzeitumgebung mit DSpark-Unterstützung. Achten Sie darauf, dass die Versionen des Drafters und des Haupt-Checkpoints übereinstimmen, und planen Sie zusätzlichen Speicher für den Drafter ein. Die CLI- und Serverbeispiele in dieser Anleitung verwenden gewöhnliches Decoding.

**Mit DSpark lässt sich die Inferenz mit DeepSeek-V4.1-Flash-GGUF beim Decoding etwa um den Faktor 1,3 bis 1,5 beschleunigen!**

Wir stellen ein 8 GB großes Q8\_0-DSpark-Modul und eine vollständige BF16-Version mit 8,5 GB bereit.

### :checkered\_flag:Engram-Präzision mischen und anpassen

Sie können die Engram-Präzision für DeepSeek-V4.1 auch beliebig ändern.

| Engram-Präzision | Größe (GB) |
| ---------------- | ---------- |
| MXFP8 (Original) | 202,8 GB   |
| Q6\_K            | 161,3 GB   |
| Q5\_K            | 135,2 GB   |
| IQ4\_NL          | 110,6 GB   |

Öffnen Sie in Unsloth die Modellauswahl, bewegen Sie den Mauszeiger über das Modell und klicken Sie auf das Zahnradsymbol, um die Ausführungseinstellungen zu öffnen. Aktivieren Sie **Erweiterte Einstellungen**und wählen Sie unter **Speicher > Engram-Tabelle**eine Tabelle aus. Im Menü werden die Größe jeder Tabelle angezeigt und die Tabelle, die mit der Quantisierung ausgeliefert wird, als integriert gekennzeichnet. Unsloth lädt die ausgewählte Tabelle beim nächsten Laden des Modells herunter und überspringt die mit der Quantisierung ausgelieferte Tabelle, falls Sie sie noch nicht heruntergeladen haben. Fügen Sie in der Befehlszeile Folgendes hinzu: `--engram`:

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F0m93Cg9ndw5E6YpekLrw%2Fengram-table-deepseek.png?alt=media&amp;token=c10b14c7-f712-4fc7-9808-06e2b704f45d" alt="" width="375"><figcaption></figcaption></figure>

```bash
unsloth run --model unsloth/DeepSeek-V4.1-Flash-1017-GGUF:UD-IQ1_S --engram Q6_K
```

llama.cpp b12233 oder neuer kann eine Tabelle direkt mit `--ple` ([PR #31185](https://github.com/ggml-org/llama.cpp/pull/31185)), ohne `set_split.py` oder Umbenennen. Laden Sie die gewünschte Tabelle herunter und ergänzen Sie `--ple` Ihren üblichen Befehl um Folgendes. Beispiel: UD-IQ1\_S mit der Q6\_K-Tabelle:

```bash
hf download unsloth/DeepSeek-V4.1-Flash-1017-GGUF \
    --local-dir unsloth/DeepSeek-V4.1-Flash-1017-GGUF \
    --include "engram/*Q6_K*"
./llama.cpp/llama-server \
    --model unsloth/DeepSeek-V4.1-Flash-1017-GGUF/UD-IQ1_S/DeepSeek-V4.1-Flash-1017-UD-IQ1_S-00001-of-00005.gguf \
    --ple unsloth/DeepSeek-V4.1-Flash-1017-GGUF/engram/DeepSeek-V4.1-Flash-1017-engram-Q6_K.gguf_file
```

llama.cpp ignoriert dann die eigene Tabelle der Quantisierung, die zu deren Dateien gehört (`-00005-of-00005` bei UD-IQ1\_S; die [Engram-README-Datei](https://huggingface.co/unsloth/DeepSeek-V4.1-Flash-1017-GGUF/blob/main/engram/README.md) führt sie für jede Quantisierung auf). Wenn Sie diese Datei löschen oder mit `--exclude "UD-IQ1_S/*-00005-of-00005.gguf"`nicht herunterladen, sparen Sie 110,6 GB. Ohne `--ple`verwendet die Quantisierung wieder ihre eigene Tabelle oder startet nicht, wenn die Datei fehlt. Der oben genannte Build aus PR #30817 verfügt nicht über `--ple`; verwenden Sie damit die folgenden Schritte. llama.cpp b12233 und neuere Versionen lesen MXFP8-Tabellen, auch die in UD-Q3\_K\_XL, UD-Q4\_K\_XL und UD-Q8\_K\_XL, als einen anderen Typ (F8\_E4M3) und liefern ohne Fehlermeldung falsche Ausgaben. Verwenden Sie für MXFP8 daher den Build aus PR #30817.

Wenn Sie beispielsweise die dynamische 1-Bit-Quantisierung IQ1\_S heruntergeladen haben, die standardmäßig IQ4\_NL-Engram verwendet, können Sie sie durch die MXFP8-Variante ersetzen, indem Sie nur das MXFP8-Engram herunterladen unter <https://huggingface.co/unsloth/DeepSeek-V4.1-Flash-1017-GGUF/tree/main/engram> mit dem Namen `DeepSeek-V4.1-Flash-1017-engram-MXFP8.gguf_file` Gehen Sie dazu wie im folgenden Skript vor:

```bash
# 1. Tabelle und Skript herunterladen
hf download unsloth/DeepSeek-V4.1-Flash-1017-GGUF \
  --include "engram/*MXFP8*" "engram/set_split.py" --local-dir .

# 2. Als Shard 5 von 5 markieren (Tabellenplatz von UD-IQ1_S)
python engram/set_split.py engram/DeepSeek-V4.1-Flash-1017-engram-MXFP8.gguf_file 5 5

# 3. Die alte Tabelle beiseitelegen und die neue in den Namen des Tabellen-Shards umbenennen
mv UD-IQ1_S/DeepSeek-V4.1-Flash-1017-UD-IQ1_S-00005-of-00005.gguf UD-IQ1_S/engram-IQ4_NL.bak
mv engram/DeepSeek-V4.1-Flash-1017-engram-MXFP8.gguf_file \
   UD-IQ1_S/DeepSeek-V4.1-Flash-1017-UD-IQ1_S-00005-of-00005.gguf

# 4. Wie gewohnt ausführen
llama-server -m UD-IQ1_S/DeepSeek-V4.1-Flash-1017-UD-IQ1_S-00001-of-00005.gguf
```

## 📊 Benchmarks

### 📊 Quantisierungsanalyse

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FZbUjhpI7wJTjf3pM1uwu%2Fsize_vs_top1(1).png?alt=media&amp;token=4e133008-8026-4e93-baa7-d7f2e2b81ecc" alt=""><figcaption></figcaption></figure>

Die Ergebnisse werden mit der offiziellen Referenz von DeepSeek für wiki1100 und long17k verglichen. Ein niedrigerer KL-Wert bedeutet, dass die Wahrscheinlichkeiten für das nächste Token ähnlicher sind; ein höherer Top-1-Wert bedeutet, dass mehr Vorhersagen übereinstimmen.

DeepSeek kombiniert **MXFP4**, FP8 und BF16. Bei Q4 und Q8 bleiben **MXFP4** die Experten und dieselbe Engram-Tabelle erhalten; ihre Bezeichnungen geben nicht die Präzision jedes einzelnen Tensors an. Q4 speichert viele Nicht-Experten-Gewichte in Q8\_0; Q8 verwendet BF16.

Wir zeigen außerdem die Ergebnisse, wenn wir die Engram-Präzision von IQ4\_NL auf Q5\_K, Q6\_K und MXFP8 ändern, und stellen **eigenständige Engrams bereit, die sich frei kombinieren lassen.**

<details>

<summary>Klicken Sie hier für eine detaillierte Tabellenanalyse</summary>

| Quant        | Gesamtgröße | wiki1100 KL / Top-1 | long17k KL / Top-1 |
| ------------ | ----------- | ------------------- | ------------------ |
| UD-IQ1\_S    | 233,0 GB    | 0.457 / 82.8%       | 0.364 / 85.1%      |
| UD-IQ1\_M    | 250,4 GB    | 0.314 / 87.1%       | 0.241 / 88.2%      |
| UD-IQ2\_XXS  | 300,5 GB    | 0.203 / 90.5%       | 0.142 / 91.2%      |
| UD-Q2\_K\_XL | 334,8 GB    | 0.138 / 91.5%       | 0.0879 / 93.3%     |
| UD-IQ3\_XXS  | 394.7 GB    | 0.0625 / 94.6%      | 0.043 / 95.1%      |
| UD-IQ3\_S    | 423.6 GB    | 0.0316 / 96.0%      | 0.0195 / 96.8%     |
| UD-Q3\_K\_XL | 485.1 GB    | 0.0204 / 96.5%      | 0.0114 / 97.4%     |
| UD-Q4\_K\_XL | 500.7 GB    | 9.00e-03 / 98.2%    | 4.46e-03 / 98.5%   |
| UD-Q8\_K\_XL | 508.4 GB    | 4.76e-03 / 98.5%    | 2.81e-03 / 98.7%   |

</details>

**Eine Quantisierung wählen:** IQ1\_S spart im Vergleich zu Q8 etwa 54 % Speicherplatz auf der Festplatte. IQ1\_M benötigt zusätzlich 17,4 GB und verbessert die Top-1-Übereinstimmung um 4,3 Punkte bei wiki1100 und um 3,1 bei long17k. Die IQ3-Varianten erreichen eine Übereinstimmung von 94,6–96,8 %.

### **GGUF-KLD- und Top-1-%-Benchmarks**

Unsere Quantisierungen erreichen gegenüber der offiziellen F32-Referenz eine Top-1-Übereinstimmung von 82,8–98,5 % bei wiki1100 und von 85,1–98,7 % bei long17k. UD-Q4\_K\_XL spart im Vergleich zu UD-Q8\_K\_XL 7,7 GB, bei einer Abweichung der Übereinstimmung von 0,3 Prozentpunkten bei wiki1100 und 0,2 bei long17k. Q8 weist außerdem bei beiden Datensätzen eine geringere KL-Divergenz auf.

**Wir ändern außerdem die Präzision der Engram-Tabelle von IQ4\_NL zu Q5\_K, Q6\_K und MXFP8 und zeigen, wie sich dies auf den KLD auswirkt.**

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FdIFvyiUQafZ2upn6VdhJ%2Fsize_vs_kld(1).png?alt=media&amp;token=e5d14eab-9143-4d0a-b1a6-f5427d995808" alt=""><figcaption></figcaption></figure>

### **Offizielle Benchmarks**

DeepSeek gibt folgende Ergebnisse für **V4.1-Flash-1017** im Vergleich zur vorherigen Version von V4.1-Flash an. Dies sind offizielle Modellergebnisse und keine Messungen der GGUFs in diesem Leitfaden. Quelle: [DeepSeeks Modellkarte für 1017](https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash-1017).

| Benchmark                  | V4.1-Flash-1017 | V4.1-Flash   |
| -------------------------- | --------------- | ------------ |
| HLE ohne Tools             | 42.6 (44.0†)    | 36.8 (39.1†) |
| Terminal-Bench 4.0         | 42.3            | 31.2         |
| DeepSWE v1.1               | 77.0            | 74.2         |
| ProgramBench               | 29.1            | 20.3         |
| NL2Repo-Bench              | 68.2            | 65.4         |
| Automation-Bench v1.0.6    | 60.5            | 54.8         |
| Agents’ Last Exam          | 35.4            | 31.8         |
| Apex Bench v1.1            | 72.1            | 64.6         |
| Chartography (mit Tools)   | 83.0            | 78.9         |
| BabyVision (mit Tools)     | 92.5            | 89.6         |
| ZeroBench-main (mit Tools) | 51.0            | 49.0         |

† Textbasierte Teilmenge von HLE. DeepSeek verwendet für Terminal-Bench 4.0 das Claude-Code-Harness und für DeepSWE v1.1 Mini-SWE-V2. Die Ergebnisse hängen vom Evaluationsaufbau, dem Reasoning-Aufwand und dem Kontextbudget ab.

### Aufschlüsselung der GGUF-Benchmarks

**Bewertungsverfahren:**

Siehe [Dynamische 3.1 GGUFs](https://unsloth.ai/docs/de/grundlagen/dynamic-3.0-ggufs/dynamische-3.1-ggufs.md#graders-used-for-benchmarks)

**Infrastruktur- und Benchmarkprobleme sowie deren Behebung:**

Siehe [Dynamische 3.1 GGUFs](https://unsloth.ai/docs/de/grundlagen/dynamic-3.0-ggufs/dynamische-3.1-ggufs.md#infrastructure-and-benchmark-issues-and-fixes)

**DeepSWE-Konfiguration für Benchmarks:**

Siehe [Dynamische 3.1 GGUFs](https://unsloth.ai/docs/de/grundlagen/dynamic-3.0-ggufs/dynamische-3.1-ggufs.md#deepswe-setup-for-benchmarks)

**Terminal-Bench-Konfiguration für Benchmarks:**

Siehe [Dynamische 3.1 GGUFs](https://unsloth.ai/docs/de/grundlagen/dynamic-3.0-ggufs/dynamische-3.1-ggufs.md#terminal-bench-setup-for-benchmarks)

**Aufgrund von Problemen ausgeschlossene Terminal-Bench-Aufgaben:**

Siehe [Dynamische 3.1 GGUFs](https://unsloth.ai/docs/de/grundlagen/dynamic-3.0-ggufs/dynamische-3.1-ggufs.md#excluded-terminal-bench-tasks-due-to-issues)

#### Benchmark-Durchläufe pro Modell

Wir haben mehrere Durchläufe durchgeführt, um faire Ergebnisse zu erhalten: Terminal-Bench und DeepSWE jeweils dreimal pro Quantisierung, AIME 2025 64-mal pro Quantisierung, LiveCodeBench 12-mal pro Quantisierung und weitere. Einige Versuche mussten aufgrund von Infrastrukturproblemen (Zeitüberschreitungen, CPU-Überlastung usw.) wiederholt werden, da sie sonst als Fehlschläge gewertet würden. Insgesamt betraf dies nur wenige Fragen.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/de/modelle/deepseek-v4.1-flash.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
