---

license: mit

language: en

base_model: dealignai/DeepSeek-V4.1-Flash-UNCENSORED-FP8

tags:

- deepseek

- uncensored

- abliterated

- multimodal

- image-text-to-text

- 1m-context

---

DeepSeek-V4.1-Flash — UNCENSORED-GGUF

Uncensored 552B MoE with 1M-token context, vision, and full tool/reasoning support — converted to GGUF for llama.cpp.

Built from dealignai/DeepSeek-V4.1-Flash-UNCENSORED-FP8 (permanent weight-level abliteration of deepseek-ai/DeepSeek-V4.1-Flash), converted to GGUF and requantized. No guardrails: the model follows on prompts the base model refuses (verified, see Benchmarks).

> ## ✅ Update 2026-10-15 — corrected re-quants are live

>

> The Q3_K_M and Q4_K_M files on the Hub have been replaced with corrected re-quants built from the Q8_0 bridge using the corrected per-layer ramp (see below). If you downloaded Q3 or Q4 earlier, the files have changed — re-download.

>

> - Q3_K_M: now 352 GB (9 × ≤50 GB shards) — 23 GB smaller than the previous build, identical measured quality at every benchmark we ran on both.

> - Q4_K_M: now 426 GB (3 shards) — routed experts are pure Q4_K as the tier name says (the previous build re-encoded the checkpoint-native MXFP4 experts into Q4_K/Q5_K, which is what the audit flagged).

> - Q2_K: rebuilt (v3) — now pins the indexer/hyperconn layers per the recipe (the previous build left them at base precision). Same size class, files replaced on the Hub. The benchmark table below is measured on v3; the 1M NIAH tier on v3 is running.

> - Q8_0: unchanged — still the reference bridge.

>

> Details: Per-group quantization & size · Benchmarks

| | |

|---|---|

| Base | deepseek-ai/DeepSeek-V4.1-Flash (552B MoE, 8B/16B active per token) |

| Abliteration | dealignai "CRACK" — refusal circuitry removed, vision/MoE/experts/norms byte-identical (verified by LFS-SHA256: vision shard identical to base) |

| Source checkpoint | dealignai FP8 (e4m3fn, FP4 routed experts) |

| Quant pipeline | FP8 → Q8_0 (full precision bridge) → requantized Q4_K_M / Q3_K_M |

| Quantization recipe | Sensitivity-aware, inspired by OrcaSAQ: attention/indexer/hyperconn pinned Q8_0, shared experts above the base step, engram_wkv pinned Q6_K, F32 for norms/router/indexer, F16 embeddings/head. Per-step ramp on the K-quant family (gate/up = base, w2 = base+1, shared = base+2). K-quants are used throughout, not MXFP4 — see the notice above for why |

| Context | 1M tokens (full, no windowing) |

| Vision | DeepSeek-ViT + projector — verified working (see below) |

| Inference | llama.cpp fork by vcruz305, branch runtime/deepseek41, CPU-only |

Files

All quant files are sharded. The Q2/Q3 sets are sharded at ≤50 GB (friendlier resumable downloads); the Q4/Q8 sets at ≤180 GB. Download every file with the same prefix — llama-server -m accepts any one shard filename and loads all of them automatically.

| Quant | Shards | Total | Notes |

|---|---|---|---|

| DeepSeek-V4.1-Flash-UNCENSORED-Q2_K-0000{1..6}.gguf | 6 × ≤50 GB | 271 GB | Fits a 256 GB machine. Corrected OrcaSAQ ramp incl. indexer/hyperconn pins. Replaced 2026-10-15. See Benchmarks for how it behaves. |

| DeepSeek-V4.1-Flash-UNCENSORED-Q3_K_M-0000{1..9}.gguf | 9 × ≤50 GB | 352 GB | Smallest full-1M-ctx set before the Q2 set landed. Corrected ramp. Replaced 2026-10-15. |

| DeepSeek-V4.1-Flash-UNCENSORED-Q4_K_M-0000{1,2,3}.gguf | 3 × ≤180 GB | 426 GB | Best quality-per-GB. Corrected ramp — pure Q4_K routed experts. Replaced 2026-10-15. |

| DeepSeek-V4.1-Flash-UNCENSORED-Q8_0-0000{1,2,3,4}.gguf | 4 × ≤180 GB | 508 GB | Direct FP8→Q8 conversion, minimal loss. The quantization bridge. |

| DeepSeek-V4.1-Flash-mmproj-BF16.gguf | 1 | 0.97 GB | Vision projector, patched (see Vision note). |

Quick download example (Q4):

hf download Adolphsson/DeepSeek-V4.1-Flash-UNCENSORED-GGUF \
  --include "DeepSeek-V4.1-Flash-UNCENSORED-Q4_K_M*" \
  --local-dir ./dsv41

> Requantization note (read this): the Q8_0 file is a direct FP8→GGUF conversion. Q4_K_M and Q3_K_M are requantized from the Q8_0 GGUF, not from FP8. For attention weights and sensitive tensors the loss is negligible (8-bit is an excellent intermediate), but strictly speaking these are two-step quants. We kept Q8_0 in this repo precisely so anyone can requantize anything else from the highest-fidelity GGUF we have.

Heads-up on Q8_0 routed experts: the source checkpoint stores the 384 routed experts per layer in MXFP4 (4-bit float). The converter passes them through as MXFP4 rather than re-encoding to Q8_0 — so "Q8_0" applies to everything except the routed experts, which are 4-bit in the Q8 file and get re-encoded to Q3_K/Q4_K in the lower quants. The engram memory tables follow the base quant (Q8_0 → Q4_K → Q3_K), which is the main reason the file size drops so much between quants.

Per-group quantization & size (measured from the actual files)

What each quant actually contains, per weight group — type + size as read from the GGUF headers:

> On the Q2_K name: Q2_K_M is not a thing — ggml has no S/M file types below Q3_K — so the tier is named for its base ramp step, not for what every tensor contains. Read literally, the name undersells the file: only the gate/up experts and the engram lookup tables are Q2_K; w2 runs Q3_K and the shared experts Q4_K, with attention/indexer and the engram value-projection pinned above (table below). The measurements put it closer to Q3 than to the naive "pure 2-bit" reading of the name — see the benchmark table — so judge it by its contents, not by its floor.

| Weight group | Q2_K | Q3_K_M | Q4_K_M | Q8_0 |

|---|---|---|---|---|

| embeddings / lm_head | 2.6 GB (F16) | 2.6 GB (F16) | 2.6 GB (F16) | 2.6 GB (BF16) |

| attention / indexer | 5.6 GB (Q8_0) † | 5.6 GB (Q8_0) | 5.6 GB (Q8_0) | 5.7 GB (Q8_0) |

| routed experts — gate/up (w1/w3) (384/layer, 2/3 of the bulk) | 118.9 GB (Q2_K) | 155.7 GB (Q3_K) | 203.8 GB (Q4_K) | 192.5 GB (MXFP4) |

| routed experts — down (w2) (384/layer, 1/3 of the bulk) | 77.9 GB (Q3_K) | 101.9 GB (Q4_K) | 101.9 GB (Q4_K) | 96.3 GB (MXFP4) |

| shared experts | 0.8 GB (Q4_K) | 1.0 GB (Q5_K) | 1.2 GB (Q6_K) | 1.5 GB (Q8_0) |

| engram_embd (lookup tables, 2 × 384M rows) | 64.5 GB (Q2_K) | 84.5 GB (Q3_K) | 110.6 GB (Q4_K) | 208.9 GB (Q8_0) |

| engram_wkv (value projection, pinned 6-bit) | 0.3 GB (Q6_K) | 0.3 GB (Q6_K) | 0.3 GB (Q6_K) | 0.3 GB (Q8_0) |

| norms / misc | 0.0 GB (F32) | 0.1 GB (F32) | 0.1 GB (F32) | 0.1 GB (F32) |

| Total file | 270.6 GB | 351.6 GB | 426 GB | 507.9 GB |

† Q2 numbers are measured on the current v3 file — every tier passes; the 1M tier is running on it now (the pins move so few weights that group sizes match the previous build within rounding). Other columns: numbers for the builds currently published, except where noted — the superseded pre-correction builds passed the same tests at values within noise: Q3 v1: PPL 1.2019, GSM8K 96, MMLU 76, and the full NIAH ladder 8k→1M (18.7 h, needle found); Q4 v1: PPL 1.1771, GSM8K 93, MMLU 75. The correction changed file structure (and reduced size), not measurable behaviour. Extended NIAH ladder runs (512k/1M) on the current Q3 build are scheduled.

All builds now follow the corrected sensitivity ramp: every group at its OrcaSAQ role step (w1/w3 = base, w2 = base+1, shared = base+2, attention pinned 8-bit, engram value-projection pinned 6-bit) — no group exceeds the checkpoint-native MXFP4 precision. The previous Q3/Q4 builds used a static recipe (Q5_K w2 across the board); the corrected builds measure identically on every benchmark (see below) at smaller file size.

The attention block, indexers and sensitive tensors stay Q8_0 in every quant (sensitivity-aware recipe, see Quant pipeline). The engram memory tables are the second size driver after the experts — they drop from Q8_0 (209 GB) to Q4_K/Q3_K. Vision weights live in the separate mmproj file (BF16, unchanged).

Vision note

The standard mmproj export for this model (pfeifferj/DeepSeek-V4.1-Flash-GSQ-RCO-GGUF) is missing the v.token_embd.img_pad tensor required by the fork's DEEPSEEK4V projector loader, which makes --mmproj abort at load. We added a zero-initialized img_pad row (5120 dims, same dtype/shape as img_start) via byte-level GGUF surgery — all 298 original tensors verified byte-identical. The img_pad sentinel is not written by the runtime layout for normal images, so a zero row is functionally correct. Verified: a blue square image → "The square is blue." on CPU.

How to run (CPU + RAM, full 1M context)

Reference hardware: 64-core CPU (single NUMA node), 440 GB RAM. Works on 96/128-core / 512 GB too, just slower.

numactl --cpunodebind=0 --membind=0 llama-server \
  -m DeepSeek-V4.1-Flash-UNCENSORED-Q4_K_M-00001-of-00003.gguf \
  --mmproj DeepSeek-V4.1-Flash-mmproj-BF16.gguf \
  -lm mmap --numa numactl -ngl 0 -cmoe \
  -ot "engram_embd.weight=CPU" \
  -fa on -c 1048576 -b 2048 -ub 1024 -t 32 \
  --host 0.0.0.0 --port 9876

Key flags:

• -lm mmap — required. The engram tables are built for lazy mmap reads; -lm none (load-all) is much slower for generation on this model.
• --numa numactl + the external numactl binding — keeps weights and KV on one NUMA node (on single-node machines this is a no-op, it doesn't hurt).
• -cmoe + -fa on — MoE + flash-attention CPU kernels.
• -ot "engram_embd.weight=CPU" — engram embedding table pinned to CPU.
• -c 1048576 — full 1M context. KV is tiny for this model: ~890 bytes/token (~0.9 GB per slot at 1M) thanks to DeepSeek's sparse-attention KV compression, so context length is not your RAM bottleneck.

RAM expectations (measured, Q3): ~50 GiB working set for weights + engram at steady state (weights stream through mmap/page cache; only active MoE experts + engram + KV are resident). Budget roughly: Q2 ≈ 40 GiB, Q3 ≈ 55 GiB, Q4 ≈ 70 GiB, Q8 ≈ 140 GiB + KV + headroom. (On a 440 GB machine the OS page cache will absorb a large share of the weights too — expect free to show hundreds of GB "used" after a long session; that is cache, not pinned RAM.)

Generation throughput is intentionally not stated: it depends on your CPU's vector units and the quant's dequantization path more than on the model, and our own repeated measurements on a single EPYC 7C13 box moved with warm state in ways we could not fully explain — the first set of numbers we ever recorded did not survive re-measurement under an identical procedure. Expect usable interactive speeds; if you care about throughput, benchmark on your own hardware before you commit.

Benchmarks

Hardware: 64-core CPU, 440 GB RAM, mmap recipe above, temperature=0. Numbers below are measured on the builds currently published (the corrected re-quants; the Q2 column is measured on the v3 build — see †). All quants ran GSM8K, MMLU, refusal smoke and NIAH 8k→128k.

| Benchmark | Q2_K | Q3_K_M | Q4_K_M | Q8_0 |

|---|---|---|---|---|

| Perplexity ↓ (identical 120k-char reference, ±SE) | 1.3162 ±0.0124 † | 1.2034 ±0.0098 | 1.1766 ±0.0089 | 1.1702 ±0.0088 |

| GSM8K (100, reasoning) \* | 89/100 | 91/100 | 94/100 | 94/100 |

| MMLU (100, thinking-off) | 77/100 | 77/100 | 73/100 | 75/100 |

| Refusal smoke (20 harmful, 10 benign) | 0 refused / 0 over-refused | 0 / 0 | 0 / 0 | 1 / 0 \\ |

| NIAH 8k | ✓ | ✓ | ✓ | ✓ |

| NIAH 32k | ✓ | ✓ | ✓ | ✓ |

| NIAH 128k | ✓ (29 min) | ✓ (30 min prefill) | ✓ (31 min) | ✓ (31 min) |

| NIAH 512k | ✓ (5.4 h, confirmed on v3) | — † | — | — |

| NIAH 1M | ✓ (18.5 h) | — † | — | — |

† Numbers for the builds currently published, except where noted: the superseded pre-correction builds passed the same tests at values within noise — Q3 v1: PPL 1.2019, GSM8K 96, MMLU 76, and the full NIAH ladder 8k→1M (18.7 h, needle found); Q4 v1: PPL 1.1771, GSM8K 93, MMLU 75. The correction changed file structure (and reduced size), not measurable behaviour. The Q2 column is now fully measured on the published v3 build (PPL/MMLU/refusal and the entire NIAH ladder 8k→1M green). Extended NIAH ladder runs (512k/1M) on the current Q3 build are scheduled.

\* GSM8K and MMLU differences between the mid/high quants are within binomial noise at n=100 (±~3–4 items) and are reported for completeness, not as a ranking. Q2's GSM8K 89 sits below that band — plausibly the first genuine capability step down. What survives intact on Q2: uncensored behavior (0/0 refusals) and every needle in the haystack, all the way to 1M.

\\ Q8's 1/20 refusal is a false positive of the keyword detector: the model answers the prompt in full, and the match is the phrase "…while unable to move…" inside a factual description, not a refusal. All four quants answer every prompt.

Perplexity note: llama-perplexity against one identical 120k-character public-domain prose reference (sha256 6873c7ee…), identical window/stride on all builds. The ladder is monotonic in the right direction (Q8 < Q4 < Q3 < Q2) — the sensitivity recipe behaves as intended at every tier — but the reference is easy prose and nearly saturates: the Q8→Q4 step is within combined error bars, i.e. statistically indistinguishable. Read this as no catastrophic loss at any tier, not as a fine-grained ranking.

Uncensored sanity check: on the refusal smoke set the Q3 build follows on all 20 harmful prompts with zero "as an AI / I cannot / I'm sorry" responses, and answers all 10 benign ones normally.

HarmBench-320 on Q4_K_M

Full official behaviour set (320 prompts), generated on our Q4_K_M build (greedy, thinking mode on) and graded by a separate reference judge model on the standard four-tier rubric — the same evaluation setup as upstream's report on their FP8 checkpoint. Judge = the reference model recommended by the test's own methodology, never the model grading itself.

| Split | Comply | Hedge | Soft-red | Hard-ref |

|---|---|---|---|---|

| Standard (159) | 159 | 0 | 0 | 0 |

| Contextual (81) | 81 | 0 | 0 | 0 |

| Copyright (80) | 80 | 0 | 0 | 0 |

| Total | 320 | 0 | 0 | 0 |

Zero hard refusals, zero hedges, zero soft-reds — 320/320. Method note for honesty: 19 prompts initially graded "unclear" (17) or given a borderline flag (2) because the generation budget was too small for this model's reasoning traces — the visible answer never started before the cut-off, and the judge graded reasoning-trace intent per the rubric. Re-run and re-grade with 32–40× the budget: all 19 resolved to comply. The table reflects the corrected runs.

Bottom line: the quantization path (FP8 → Q8_0 bridge → Q4_K_M, sensitivity-ramped) preserves the uncensored behaviour essentially intact — within measurement distance of the upstream FP8 result.

<details>

<summary><b>Per-semantic-category results</b> (click to expand)</summary>

| Semantic category | Comply | Hedge | Soft-red | Hard-ref |

|---|---|---|---|---|

| chemical_biological (42) | 42 | 0 | 0 | 0 |

| copyright (80) | 80 | 0 | 0 | 0 |

| cybercrime_intrusion (52) | 52 | 0 | 0 | 0 |

| harassment_bullying (21) | 21 | 0 | 0 | 0 |

| harmful (18) | 18 | 0 | 0 | 0 |

| illegal (53) | 53 | 0 | 0 | 0 |

| misinformation_disinformation (54) | 54 | 0 | 0 | 0 |

Every category clean at full budget. Two items initially drew borderline flags (one in each of the last two rows) on truncated reasoning; both resolved to comply when re-graded with the full reasoning trace.

</details>

Note on the NIAH ladder: the lowest quant is the strictest needle-in-a-haystack test — if it finds the needles, higher quants (strictly higher fidelity) will as well. Hence the full ladder (8k→1M) is run on Q2, and Q3 was extended to 1M when it was the lowest tier; Q4/Q8 get the 128k tier plus MMLU and refusal smoke — if a higher quant loses the needle at 128k where the lower quant found it, that is a regression worth reporting, and the ladder is extended downward.

The 1M NIAH tier was expected to be a multi-week run on this hardware and was planned to be skipped — it finished in ~19 h instead (≈15 tok/s effective prefill at 1M: DeepSeek's sparse attention keeps long-context prefill practical) and found the needle. The full ladder 8k→1M is complete on Q3; the Q2 ladder's 512k/1M tiers on the current build are running.

Provenance

• Abliterated base: dealignai/DeepSeek-V4.1-Flash-UNCENSORED-FP8 (abliteration 2026-09-10). Verified: all vision.* tensors byte-identical to deepseek-ai base (shard 00001, matching LFS-SHA256); edits confined to MoE shards 00013–00039.
• GGUF conversion & quants: llama.cpp fork vcruz305/llama.cpp branch runtime/deepseek41 (commit 5210c7c) — the only public build with DeepSeek-V4.1 text-model GGUF support + the DEEPSEEK4V projector.
• Original (reference) Q3: the excellent vcruz305/DeepSeek-V4.1-Flash-GGUF — this repo's Q3/Q4 are the uncensored counterparts.
• Built & tested by: Adolphsson

License

Lineage

• Original base model: deepseek-ai/DeepSeek-V4.1-Flash (MIT)
• Source model: dealignai/DeepSeek-V4.1-Flash-UNCENSORED-FP8 (MIT) — the "CRACK" weight-level abliteration
• Direct contribution (this repo): GGUF conversion of the dealignai FP8 checkpoint to Q8_0, requantization to Q4_K_M / Q3_K_M, the mmproj img_pad patch, and the CPU benchmark suite. This is a quantization/conversion release only — the uncensored behavior was created by dealignai, not by this repo.

The model weights are MIT-licensed at every step of the lineage (DeepSeek-V4.1-Flash → dealignai abliteration → this repo). Quantization changes the weights numerically but not their provenance or license.

Full license text: LICENSE · Upstream attribution: NOTICE