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

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.

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.

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

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

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.

Per-semantic-category results (click to expand)

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.

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