DeepSeek-V4.1-Flash-1017 — UNCENSORED · IQ4-MAYA

Uncensored 552B MoE with 1M-token context, vision and tool support — requantized to a mixed Q4_K/IQ4 weight map and packed for Project Maya.

Built from dealignai/DeepSeek-V4.1-Flash-1017-UNCENSORED-FP8 — the permanent weight-level abliteration of deepseek-ai/DeepSeek-V4.1-Flash-1017. The abliteration is dealignai's work; this repo is a quantization release only.

This is a Maya pack, not a vanilla GGUF drop. The tensor map, split geometry and sampling defaults in ds4.txt are what Maya's DeepSeek engine reads; the same shards also load in llama.cpp, but Project Maya is where it runs the way it was built to.

⚠️ Read this first

• MTP is included and it is a wash. The DSpark drafter ships as dspark.bin / dspark.json. On our hardware it is within noise on short prompts (+2.7 %) and 11 % slower at 1M context. We serve and benchmark without it. Nothing breaks if you skip it.
• It is a 4-bit quant of an FP8 abliteration. dealignai warns that naively quantizing their FP8 bundle can let compliance regress at low bits. We measured it instead of assuming: 98 % compliant on HarmBench-320, which is the point of this file. Mathematics is where the missing bits show — see Benchmarks.

Files

Shard sizes are deliberately uneven — shard 00001 carries the metadata and the small tensors, the bulk rides in the middle shards.

Per-group quantization (measured from the actual files)

Attention, indexer and shared experts are pinned at 8-bit, norms stay F32 — a 4-bit release lives or dies on those.

Running it with Project Maya

Project Maya is the engine this pack is made for: it keeps the experts your conversation actually uses on the GPU, the next ones in RAM and the rest on NVMe, and it serves an OpenAI- and Anthropic-compatible API with vision, thinking tiers and tool calls. Setup and every engine option are in Maya's own docs — docs/SETUP.md, docs/SETTINGS.md.

You need an NVIDIA GPU with compute capability 7.0 or newer (more VRAM = faster), a fast NVMe with ~480 GB free, CUDA 12.x, and about 256 GB RAM for the model. The 1M context barely moves that on this model, and a second parallel session costs under a gigabyte — Maya pins the free RAM for its expert tier, so ~6 GB stays for everything else. Below is the procedure we run on this pack.

1. Build Maya

git clone https://github.com/mw00/project-maya.git && cd project-maya
./setup.sh            # answer no to its own model download; it builds the engines

2. Build the pack beside the files — once, about a minute, no weights copied:

python3 tools/ds4/pack_gguf.py --model /path/to/this/repo --vision /path/to/this/repo \
  --drafter /path/to/this/repo/dspark.json --out /path/to/this/repo/maya-ds4

ds4.txt, tensors.txt and tokenizer/ land in maya-ds4/. Leave out --drafter if you don't want the MTP block in the pack at all. The guided alternative is ./maya.sh --setup --model-dir /path/to/this/repo, which does this step plus the config for you.

3. Server environment

python3 -m venv .venv && .venv/bin/pip install jinja2 numpy pillow

4. Config — maya-ds4.json, this is ours (two GPUs, 1M, no drafter):

{
  "exe": "./build/maya-ds4",
  "args": ["--pack", "/path/to/this/repo/maya-ds4", "--max-context", "1048576", "--tp", "2",
           "--vision", "on", "--dspark", "none", "--threads", "on", "--mmap-experts", "off"],
  "cwd": "/path/to/project-maya",
  "gpu": [0, 1],
  "tokenizer": "/path/to/this/repo/maya-ds4/tokenizer",
  "model_name": "deepseek-v4.1-flash-1017-iq4",
  "sampling": { "temperature": 1.0, "top_p": 1.0 },
  "reasoning_effort": "high",
  "port": 9876, "host": "0.0.0.0"
}

5. Start

.venv/bin/python -m serve.server --engine strata --config maya-ds4.json --host 0.0.0.0 --port 9876

Add --parallel 2 if you want two conversations answered at once — it costs under a gigabyte. Wait for the ready: line — loading ~470 GB takes minutes. The API is then at /v1/chat/completions and /v1/messages (Claude Code: ANTHROPIC_BASE_URL=http://<host>:9876), with a chat page on the same port. Set "api_key" in the config before exposing it.

6. Keep it up — a unit that survives a reboot:

[Unit]
Description=DeepSeek-V4.1-Flash-1017 IQ4-MAYA (Maya)
After=network-online.target

[Service]
WorkingDirectory=/path/to/project-maya
ExecStart=/path/to/project-maya/.venv/bin/python -m serve.server --engine strata \
  --config maya-ds4.json --host 0.0.0.0 --port 9876
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target

systemctl enable --now maya-ds4

Four things carry the speed: --mmap-experts off (a cold mmap of the experts is ~30× slower), --threads on, --tp matching your card count, and on RTX 3090 the gpu-unlock kernel module. On a multi-socket board add --numa numactl with numactl --cpunodebind=0 --membind=0 — about +25 % prompt speed.

gpu-unlock writes the card's speed selector to the full BF16 rate before the NVIDIA driver binds it, which lifts the matmul-heavy prefill rather than decode. It loads from the initramfs, needs a cold boot (power off, not reboot) and does nothing unless the kernel command line opts in with gpu_unlock.targets=. We run it on both 3090s.

Measured on this exact config (2×3090, unlock active): 33.3 tok/s on short prompts, 26.3 tok/s decode at 860K context, prefill 825 tok/s on a 5.6K prompt. The 305–550 tok/s prefill figure elsewhere on this page is from before the unlock and over 860K context — long context prefill is slower than a 5.6K one, so read them as a range, not a comparison. A single 5090 is comparable on short prompts and slower at 1M.

llama.cpp

The shards are ordinary GGUF, so a llama.cpp build with DeepSeek-V4.1 support runs it too:

llama-server -m DeepSeek-V4.1-Flash-1017-UNCENSORED-MTP-Maya-Q4_K-IQ4_XS-00001-of-00011.gguf \
  --mmproj DeepSeek-V4.1-Flash-mmproj-BF16.gguf -c 1048576 --alias deepseek-1017

You lose the expert tiering — llama.cpp wants the experts in RAM/VRAM up front.

Benchmarks

Same harness, temperature 0, single run per item, no retries on wrong answers.

Per category, at max effort (counts out of the category's own rows):

HarmBench verdicts by semantic category

Two rows produced answers the judge could not place and are counted separately (UNCLEAR in the headline); they are not included in the per-category table above.

There is no weak category here: four of the seven are clean sweeps, and the five non-compliant answers are single rows scattered over illegal and harmful rather than a pattern. That is the opposite shape of an abliteration that was tuned per topic — this one held everywhere.

MTP / DSpark A/B

Prefill over 860K tokens runs at ~305–550 tok/s; the table measures decode. The drafter costs more than it saves once the KV cache is large.

Other formats

This repo is llama.cpp- and Maya-shaped on purpose. If you would rather run an ExLlamaV3 (EXL3) server, dealignai publishes an uncensored EXL3 at 2.9 bpw: dealignai/DeepSeek-V4.1-Flash-1017-EXL3-2.9bpw-UNCENSORED (about 416 GB). Note the order of operations differs: that one was abliterated on top of LibertAI's 2.9 bpw EXL3, while ours is an FP8 abliteration requantized afterwards — same model, same intent, not the same weights.

The honest caveat: the bpw numbers are not directly comparable — EXL3 mixes per-layer precision in its own scheme, so its nominal 2.9 is not "2.9 of the same thing" our 5.04 measures. We have not benchmarked the EXL3 build, so treat it as an alternative to try, not as a verified drop-in.

Vision note

The projector is unquantized and independent of the text weights, so vision quality is unchanged by this release. With Maya 1.1.29 and later the tower is not parked in VRAM either: it stays in RAM or on the SSD and is only paged onto the GPU while an image is being read, so it costs model room only during that read. It is GPU-computed, not a CPU path — on the 2×3090 pair a small image measured 8.3 s cold (the tower paging in) and 1.3 s / 0.9 s warm. Fine for interactive use and for single images; bulk captioning is still bounded by that page-in, not by CPU.

Provenance

• Abliterated base: dealignai/DeepSeek-V4.1-Flash-1017-UNCENSORED-FP8, built by dealignai; compute by @jordanschenck.
• Engine: Project Maya by Peasant Smith (@mw00), co-maintained by @needmorevram — the pack format, the DeepSeek engine and the flags above are theirs.
• Pipeline: FP8 → Q8_0 bridge → IQ4-MAYA requant with our own packer; per-group map as tabled above.
• mmproj: projector originally from pfeifferj/DeepSeek-V4.1-Flash-GSQ-RCO-GGUF (BF16, unquantized), with an img_pad embedding row appended so the engine can mark image boundaries; also carried in our earlier Q4_K release.
• Built, benchmarked and tested by: Adolphsson.

License

Lineage

• Original base model: deepseek-ai/DeepSeek-V4.1-Flash-1017 (MIT)
• Source model: dealignai/DeepSeek-V4.1-Flash-1017-UNCENSORED-FP8 (MIT) — the CRACK abliteration
• Vision projector: pfeifferj/DeepSeek-V4.1-Flash-GSQ-RCO-GGUF (mmproj only, BF16) — the same upstream projector, patched with the img_pad row
• Direct contribution (this repo): requantization to IQ4-MAYA, the Maya pack, the A/B numbers and the benchmark suite. The uncensored behaviour was created by dealignai, not here.

Weights stay MIT at every step. Quantization changes the numbers, not the provenance.

Full text: LICENSE · Upstream attribution: NOTICE