---

license: mit

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

base_model_relation: quantized

pipeline_tag: image-text-to-text

language:

• en
• zh

tags:

• deepseek
• deepseek-v4.1
• gguf
• vector-quantization
• vq
• mixture-of-experts
• engram
• mtp
• speculative-decoding
• vision
• 1m-context
• uncensored
• abliterated
• dgx-spark
• gb10
• ds4
• ds4-dfm-rs

---

DeepSeek-V4.1-Flash-1017 UNCENSORED VQ GGUF

dealignai's uncensored DeepSeek-V4.1-Flash-1017, converted the day it was released and sized for one 128 GB DGX Spark.

Based on dealignai/DeepSeek-V4.1-Flash-1017-UNCENSORED-FP8.

The 510 GB FP8 checkpoint becomes a ~113.6 GB base GGUF that carries the

model's own three-tower MTP drafter, plus a ~1 GB vision sidecar and the

1017 Engram tables. Context stays at the native 1,048,576 tokens.

The conversion is the one that built

Baekpica/DeepSeek-V4.1-Flash-1017-VQ-GGUF:

YoungAi's published vq8sh14-q4k-mtpnative recipe without changes, with the

same bit allocation, codebooks, skeleton and drafter treatment as

wenzhouwu/YoungAi-DeepSeek-V4.1-Flash,

and the tools pinned to the same YoungAi

commits. Only the input changes, to dealignai's uncensored FP8 weights. The

target runtime is ds4-dfm-rs, which

already serves the V4.1 Flash artifact built with this recipe on DGX Spark.

> Expect some degradation from the FP8 model. This GGUF is a VQ

> quantization of dealignai's FP8 checkpoint, at about 1.6 bits per

> routed-expert weight. That is lossy: on V4.1 Flash the same recipe matches

> the FP8 model's next token 69–79% of the time. General quality and the

> uncensored behavior can both be worse than in the FP8 model, and dealignai

> itself warns that compliance can regress in low-bit quants made from its FP8

> bundle. Neither has been measured on this artifact yet.

> Status, 2026-10-18: the conversion is finished and uploaded. The base has the

> 1017 VQ release's exact tensor inventory and byte layout (1,000 tensors,

> 113,556,639,424 bytes) and passes the ds4-dfm-rs DeepSeek V4.1 loader check

> (bind: slots=1000 bound=1000 required-missing=0). Compared tensor by tensor

> with the 1017 VQ release, 54 of the 1,000 tensors differ, exactly the ones

> built from the weights dealignai edited. Serving on DGX Spark has not been

> measured for this artifact yet; the speed and fidelity figures below are

> V4.1 Flash numbers for the same recipe and are labelled as such.

At a glance

| | |

|---|---|

| Source | dealignai/DeepSeek-V4.1-Flash-1017-UNCENSORED-FP8 at c19ca5ca4eaeb79d29fdf08aea8327da95b1116a, which is deepseek-ai/DeepSeek-V4.1-Flash-1017 with dealignai's weight edit in layers 10–36; all 48 input shards SHA-256 checked |

| Recipe | YoungAi vq8sh14-q4k-mtpnative, unchanged |

| Routed experts | 8-dim VQ, one E4M3 codebook per layer shared by all 384 experts and gate/up/down, F16 row gains. Layers 0–13 use 13-bit indices (K=8192), layers 14–39 use 12-bit (K=4096). No calibration data. |

| Attention, shared experts, embedding, head | q4_K |

| MTP drafter | The model's three DSpark draft towers, embedded in the base GGUF. Tower experts are 12-bit VQ; other tower weights keep their native precision. |

| Vision | DeepSeek-ViT tower, aligner and per-layer bias_vl router biases, original BF16, in a separate sidecar GGUF |

| Engram | The 1017 n-gram tables (2 × 101.5 GB) in deepseek-engram/, unmodified, read in place through --engram-dir |

| Context | 1,048,576 tokens, from the model metadata. YoungAi measures the full 1M-token KV cache of this architecture at 0.89 GB. |

| Domain sidecar (zchain / GR-RB) | None |

| Runtime | ds4-dfm-rs on DGX Spark (CUDA). YoungAi ds4-server reads the same files. |

Use the 1017 Engram, not the V4.1 one

dealignai did not touch the Engram n-gram tables: its shards 47 and 48 are

DeepSeek's 1017 files, byte for byte, and deepseek-engram/ holds those

files, copied on the Hub from the pinned dealignai revision. They are the same

files as in the 1017 VQ release, so a directory that already holds the 1017

tables can be reused. The older deepseek-ai/DeepSeek-V4.1-Flash tables have

the same names and sizes but different contents, so an engine pointed at them

would load without any error and run a mismatched model. YoungAi's V4.1

install steps fetch exactly those older shards.

| Shard | DeepSeek-V4.1-Flash (SHA-256) | DeepSeek-V4.1-Flash-1017 and this release (SHA-256) |

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

| model-00047-of-00048.safetensors | 824db4881320407ac340736d14dcee5ecd748c27d0f5836b8127ecc2e3781b0f | 76a05106ece259be83d1bfea0dcb54f23377864ee60fd321690f35e6698a2af5 |

| model-00048-of-00048.safetensors | 976330f4954338e1ad8b508c32aa912032c7ad908959fd53c8307650fe4520ed | 9dc51433e195bc78b5ad846b68643cc0351d3b174e5e4309222d3b7402c83afd |

dealignai did not change the vision tower either, so this release's

DeepSeek-V4.1-Flash.vision.gguf is byte-identical to the 1017 VQ release's

(SHA-256 3a8b194a…). The older V4.1 sidecar is not: it has the same 306

tensors and size, but 532,623,100 of its 971,066,016 bytes differ, so copied

into this directory it would load silently and see images with the old tower.

The base GGUF has the same file name as in the 1017 VQ release but different

weights, so keep the two releases in separate directories; SHA256SUMS

catches a mix-up. YoungAi's V4.1 domain sidecars were solved against the

V4.1 Flash base and do not fit these weights, so do not mount them here.

Files

The layout and file names are the same as the 1017 and V4.1 Flash VQ

artifacts, so a directory or script set up for those serves this one after

only the directory path is changed. "UNCENSORED" is in the repository name,

not in the file names. Do not mix files between the directories;

SHA256SUMS catches it if that happens.

| Path | Contents | Size |

|---|---|---:|

| DeepSeek-V4.1-Flash-vq8sh14-q4k-mtpnative.gguf.part01-of-40 … part40-of-40 | Base GGUF, including the MTP drafter, as 40 byte-range parts with the V4.1 reference's sizes (24 × 2,838,915,986 B, then 16 × 2,838,915,985 B) | 113,556,639,424 B |

| DeepSeek-V4.1-Flash.vision.gguf | Vision sidecar for --vision-gguf | 971,066,016 B |

| deepseek-engram/model-00047-of-00048.safetensors | 1017 Engram shard (unmodified) | 101,535,150,936 B |

| deepseek-engram/model-00048-of-00048.safetensors | 1017 Engram shard (unmodified) | 101,537,926,640 B |

| SHA256SUMS | SHA-256 of the assembled base, every part and every other file | |

| RECIPE.md | Exact commands, flags and pinned tool commits | |

| SOURCE.md | Provenance and licenses | |

| LICENSE, LICENSE-DeepSeek | YoungAi tools (MIT, with the GGML notice) and DeepSeek weights (MIT) | |

| docs/img/ | The ds4-dfm-rs DGX Spark throughput graph shown below (V4.1 Flash, same recipe) | |

SHA-256 of the assembled base and the vision sidecar (all parts are in SHA256SUMS):

2680747eaec26d62c3f40c1a8fce5b931d210a709f71868bde5d68766bccf0a1  DeepSeek-V4.1-Flash-vq8sh14-q4k-mtpnative.gguf
3a8b194a011e630e8e49a51b5f4e9821e48a9e5674e678d52c0302d6b164698c  DeepSeek-V4.1-Flash.vision.gguf

The download is about 318 GB. Plan for about 114 GB more while the parts are

assembled, or use the append-and-delete loop below. At run time the base is

resident (about 106 GiB loaded for this recipe on V4.1 Flash). The Engram

tables are read in rows from disk, so keep them on a local SSD.

Quick start on DGX Spark

# 1. Download and verify (parts, vision sidecar, Engram, checksums)
hf download Baekpica/DeepSeek-V4.1-Flash-1017-UNCENSORED-VQ-GGUF --local-dir ds41-1017-unc
cd ds41-1017-unc
sha256sum -c --ignore-missing SHA256SUMS

# 2. Assemble the base. This loop needs only one extra part of free disk.
B=DeepSeek-V4.1-Flash-vq8sh14-q4k-mtpnative.gguf
for i in $(seq -w 1 40); do cat "$B.part$i-of-40" >> "$B" && rm "$B.part$i-of-40"; done
sha256sum -c --ignore-missing SHA256SUMS      # the assembled .gguf must report OK

# 3. Build ds4-dfm-rs and serve
git clone https://github.com/Baekpica/ds4-dfm-rs.git && (cd ds4-dfm-rs && make cuda-spark)
./ds4-dfm-rs/ds4-server --cuda -m "$B" \
    --engram-dir deepseek-engram \
    --vision-gguf DeepSeek-V4.1-Flash.vision.gguf \
    --mem-budget-mb 110000 --host 0.0.0.0 --port 8000

If you already have the 1017 Engram shards (from DeepSeek's 1017 checkpoint,

the dealignai checkpoint or the 1017 VQ release), add

--exclude "deepseek-engram/*" to the download and point --engram-dir at

that directory. The engine takes only the shard file names from the GGUF.

The server provides OpenAI-style /v1/chat/completions, /v1/completions

and /v1/responses, and Anthropic-style /v1/messages. The embedded drafter

is controlled with --mtp-mode off|auto|on. DeepSeek and dealignai recommend

temperature 1.0 and top_p 1.0; send them explicitly in each request,

because sampling on this path follows the request. dealignai also describes

the model as a heavy reasoner and suggests a large token budget. See the

ds4-dfm-rs DeepSeek V4.1 guide

for the full flag set and serving limits. Standard llama.cpp, Ollama and

Transformers loaders do not read this format.

Recipe

All of the following comes from YoungAi's V4.1 recipe and tools. See

RECIPE.md for the exact commands.

• Routed experts (40 layers × 384 experts × gate/up/down). Every 8

consecutive weights of a row become one index into a codebook, scaled by one

F16 gain per row (the row RMS). One codebook per layer is shared by all

384 experts and all three matrices. Codewords are stored as E4M3.

Layers 0–13 use K=8192 (13-bit indices, stored as a 12-bit stream plus a

separate 1-bit plane). Layers 14–39 use K=4096 (12-bit). That is 1.625 or

1.5 index bits per weight. Codebooks come from 8 Lloyd iterations on the

GPU over the weights alone, with no calibration text.

• Skeleton. Every FP8 projection outside the routed experts (attention,

shared experts, FP8 indexer and compressor projections) and the BF16

embedding and output head are requantized to q4_K (144 bytes per 256

weights, no importance matrix).

• MTP drafter. The three DSpark draft towers (128 experts each) use the

same VQ at K=4096, with one shared codebook per tower. The towers' other

weights are copied from the original checkpoint: FP8 projections with

their 32×32 scales and BF16 router, Markov and confidence heads stay as

shipped, and norms are widened losslessly to F32.

• Unchanged. Norms, routers and router biases, hyper-connection maps,

attention sinks, compressor and small projections, and the Engram

projections keep their shipped precision. The Engram tables are not in

the GGUF.

• Vision. The tower, aligner, image delimiter rows and the 40 per-layer

bias_vl router biases are copied from the dealignai checkpoint into the

sidecar GGUF: matrices stay BF16, small tensors are widened losslessly to

F32.

How YoungAi's base is made up, as YoungAi measured it on V4.1 Flash:

| Part | Format | GB |

|---|---|---:|

| Routed-expert indices | VQ-8, 14 layers × 13-bit + 26 layers × 12-bit | 104.90 |

| Row gains | F16 | 0.30 |

| Codebooks | 40 × E4M3 | 0.003 |

| Attention, shared experts, output head | q4_K | 4.96 |

| MTP draft towers | VQ-8, 12-bit | 2.56 |

| Everything else | as shipped | 0.85 |

What this base contains, read from the file with the ds4-dfm-rs inspector.

The tensor counts and byte totals per type are identical to the 1017 VQ

release and the V4.1 reference:

| Storage type | Tensors | GB |

|---|---:|---:|

| f32 (GGUF type 0) | 531 | 0.172 |

| q4_k (GGUF type 12) | 330 | 4.413 |

| i32 (GGUF type 26) | 1 | 0.001 |

| i64 (GGUF type 27) | 3 | 0.000 |

| bf16 (GGUF type 30) | 65 | 0.333 |

| vqblob (GGUF type 42) | 43 | 107.753 |

| fp8_32x32 (GGUF type 44) | 27 | 0.880 |

Weight-space fidelity of the routed experts, as reported by YoungAi's quantizer

on these weights (cosine between original and reconstructed expert weights;

this is not a model-quality measurement). dealignai's edit does not touch the

routed experts, so these figures, like the VQ data itself, are identical to

the 1017 VQ release:

| Layers | Index bits | Mean cosine | Range |

|---|---:|---:|---|

| 0–13 | 13 | 0.9253 | 0.9250–0.9253 |

| 14–39 | 12 | 0.9107 | 0.9101–0.9109 |

Reference numbers from V4.1 Flash (not this artifact)

These numbers were measured on the V4.1 Flash artifact built with the same

recipe, before the 1017 update and without dealignai's edit. They show what

the recipe and runtime have delivered so far. Measurements of this artifact

will be added here once they exist.

Speed, one DGX Spark, ds4-dfm-rs

!DeepSeek V4.1 Flash VQ prefill and decode on one DGX Spark, 2K–64K

*DeepSeek V4.1 Flash with this recipe and YoungAi's code GR sidecar, not this

artifact. Three fresh 2K–64K full-prefill sweeps on one DGX Spark,

temperature 0, automatic embedded MTP; curves are per-frontier medians and

bands the min–max of the three runs. Graph and record from

ds4-dfm-rs;

DeepSeek V4.1 Flash was ported to ds4-dfm-rs by JLFN

(#80) using YoungAi's VQ

artifacts.*

| 2K–64K sweep, 2026-10-13 | Prefill tok/s | Decode tok/s |

|---|---:|---:|

| Median of the three runs' means | 1,039.65 | 38.17 |

| 2K frontier (2,149 tokens) | 775.7 | 42.6 |

| 16K frontier (16,546 tokens) | 1,120.0 | 41.3 |

| 64K frontier (66,608 tokens) | 969.5 | 39.8 |

A later ds4-dfm-rs build (ae40aa1d,

record,

same artifact and sidecar) reached 1,222.4 tok/s prefill at 16K and, on short

prompts, 54.10 tok/s decode for code and 65.85 tok/s for a table.

Fidelity to the full-precision original, by YoungAi on V4.1 Flash

(technical notes §5.1).

"Same top-1" is how often the quantized model's next token matches the

original model's, teacher-forced on held-out text. This is the bare base

without any sidecar, which is how this release ships:

| Held-out text | Same top-1 | Mean KL |

|---|---:|---:|

| Code (30 languages) | 78.61% | 0.421 |

| English (WikiText-2) | 78.52% | 0.694 |

| Law | 72.90% | 0.578 |

| Finance | 71.73% | 0.612 |

| Science | 71.65% | 0.537 |

| Medicine | 69.08% | 0.602 |

Speed should be close to these figures, because decoding is bound by

memory bandwidth and this artifact reads the same bytes per token. Drafter

acceptance depends on the generated text and can differ. Fidelity has to be

measured again on this checkpoint.

What the UNCENSORED edit changes upstream

dealignai describes its checkpoint as DeepSeek-V4.1-Flash-1017 with the

refusal behavior removed by a weight-level edit: the patched tensors stay FP8

E4M3 at their native block size, and there is no fine-tune, adapter, chat

template or tokenizer change. Comparing the two Hub repositories file by file

(dealignai c19ca5c against DeepSeek 1bae0e1):

• 27 of the 48 weight shards differ: shards 13–39, which hold transformer

layers 10–36. Tensor names, dtypes, shapes and data offsets are unchanged.

The re-saved shards carry a {"format": "pt"} metadata entry, which makes

each header 32 bytes longer.

• The other 21 shards are byte-identical to DeepSeek's 1017 files: the

vision tower and aligner, the embedding and image delimiter rows, layers 0–9

and 37–39, the output head, the three MTP draft towers and both Engram

shards.

• config.json, model.safetensors.index.json, tokenizer.json,

tokenizer_config.json, encoding/*.py and inference/ match DeepSeek's

files byte for byte, except for one line of inference/kernel.py

(num_stages = 2, a race fix in DeepSeek's reference kernel), which only

affects that reference engine.

Within the edited layers, only two FP8 matrices changed. Byte for byte

against DeepSeek's shard, layer 20 differs in attn.wo_b (the attention

output projection) and ffn.shared_experts.w2 (the shared expert's down

projection), weights and block scales, while its other 33 tensors outside the

routed experts are identical. The converted files show the same thing for

all 27 layers: of the base GGUF's 1,000 tensors, 54 differ from the 1017 VQ

release, attn_output_b and ffn_down_shexp (q4_K) in each of layers 10–36,

816 MB of the 113.6 GB. The other 946 tensors are byte-identical, including

all 43 routed-expert and MTP VQ blobs, so the FP4 routed experts are

untouched, and the vision sidecar is byte-identical as well. Every byte that

differs from the 1017 VQ release comes from dealignai's edit.

dealignai's own scores for its FP8 checkpoint, greedy at temperature 0, from

the dealignai model card.

They describe the source model, not this quantization. dealignai scored the

base through DeepSeek's official API and the uncensored checkpoint through

DeepSeek's reference engine on 4 × H200, with the same prompt:

| Benchmark | V4.1-Flash-1017 | 1017 UNCENSORED |

|---|---:|---:|

| MMLU, 57 subjects × 20 questions, logit mode | 87.63% | 83.77% |

| HarmBench-320 at reasoning effort max, answers that complied | — | 320 / 320 |

DeepSeek's own scores for the original FP8 checkpoints, from the

1017 model card,

for the update this checkpoint starts from:

| Benchmark | V4.1-Flash | V4.1-Flash-1017 |

|---|---:|---:|

| Terminal-Bench 4.0 | 31.2 | 42.3 |

| ProgramBench | 20.3 | 29.1 |

| Apex Bench v1.1 | 64.6 | 72.1 |

| HLE w/o tools | 36.8 | 42.6 |

| Automation-Bench v1.0.6 | 54.8 | 60.5 |

| DeepSWE v1.1 | 74.2 | 77.0 |

Limits

• Quantizing the FP8 checkpoint to VQ is lossy, roughly 1.6 bits per

routed-expert weight, so expect some degradation against the FP8 model in

reasoning, knowledge and instruction following. On V4.1 Flash the recipe

agrees with the original's next token 69–79% of the time (table above). It

is not a drop-in equal of the FP8 model.

• dealignai notes that low-bit quants made directly from its FP8 bundle carry

quantization error on top of the uncensoring edit, and that compliance can

regress at low bits; it recommends redoing the edit at the target precision

for the best result. This release quantizes the FP8 bundle directly, so that

the recipe stays identical to the 1017 VQ release.

• dealignai measured MMLU 3.86 points below the base for its FP8 checkpoint.

This quantization adds its own loss on top of that.

• No quality, compliance or GB10 speed measurement has been published for

this artifact yet.

• YoungAi reports that this weight recipe under-weights stop decisions

(</think>, EOS), so long thinking segments can fail to close. Its server

therefore defaults to non-thinking mode. The same caveat should be assumed

here until this artifact is measured.

• No domain sidecar is shipped. YoungAi's V4.1 sidecars do not apply.
• The custom VQ format needs ds4-dfm-rs or YoungAi's engine.

Disclaimer

The source model had its refusal behavior removed by dealignai's weight

edit; see its card.

It can comply with harmful requests that the original model refuses, and it

can produce content that is incorrect, offensive, dangerous or illegal. It is

meant for research such as refusal-mechanism study, red-teaming and

robustness evaluation. dealignai's terms for the source model apply here

too: be 18 or older, use it only in compliance with the law where you are,

and accept full responsibility for everything it generates. Add your own

safety and moderation layers before any deployment. There is no warranty of

any kind.

Credits and sources

This release runs other people's work on a new checkpoint. The method and the

uncensoring edit are theirs.

• dealignai

(@dealignai): the uncensored checkpoint

this release is based on,

dealignai/DeepSeek-V4.1-Flash-1017-UNCENSORED-FP8,

MIT. Its weights, Engram shards and vision tower are the input to this

conversion. dealignai credits @jordanschenck

for the compute used to build it.

• YoungAi by Wenzhou Wu (吴文周,

fodelf /

wenzhouwu), MIT. Taken from it without

modification:

- the vq8sh14-q4k-mtpnative recipe: 8-dim VQ with per-layer shared E4M3

codebooks, 13-bit shallow layers in the 12+1 bit-plane layout, q4_K

skeleton and VQ draft towers (YoungAi

docs/TECHNICAL.md §4.1,

docs/113.md);

- the quantizer gguf-tools/quantize/v41_quantize and the GGUF converter

v41_to_gguf at

7fb26cc,

the commit ds4-dfm-rs's V4.1 port is pinned to;

- the vision sidecar mode v41_to_gguf vision at

e4ea078;

- the Engram and tokenizer constant generators

gguf-tools/scripts/v41_engram_consts.py and v41_tokenizer_consts.py;

- the DQVL v3 VQ payload format, and the file layout and serving flags of

the reference artifact

wenzhouwu/YoungAi-DeepSeek-V4.1-Flash.

Its notice is kept in LICENSE.

• antirez/ds4 (DwarfStar) by Salvatore

Sanfilippo, the DeepSeek V4 engine YoungAi started from.

• llama.cpp / GGML: the GGUF

container and the q4_K layout. The GGML copyright notice is part of

LICENSE.

• ds4-dfm-rs: the runtime. Its

DeepSeek V4.1 support was ported by JLFN

(#80, vision in

#83).

• DeepSeek-AI: the model, its

Engram tables and the reference inference code, MIT

(LICENSE-DeepSeek).

Done here: running the YoungAi pipeline on dealignai's checkpoint with the

Engram and vision weights that come with it, verifying the output and

packaging it. No algorithm or format is changed. RECIPE.md

records the build environment.

License

MIT. The weights derive from dealignai/DeepSeek-V4.1-Flash-1017-UNCENSORED-FP8

(MIT), which derives from DeepSeek-V4.1-Flash-1017 (MIT,

LICENSE-DeepSeek). The quantization tools and recipe are

YoungAi's (MIT, LICENSE, which includes the GGML notice). This is

the same license file layout as the V4.1 reference artifact.