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

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.

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.

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:

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:

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:

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

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:

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:

DeepSeek's own scores for the original FP8 checkpoints, from the 1017 model card, for the update this checkpoint starts from:

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.