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

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.