license: mit language: en base_model: dealignai/DeepSeek-V4.1-Flash-1017-UNCENSORED-FP8 base_model_relation: quantized tags:

• deepseek
• uncensored
• abliterated
• multimodal
• image-text-to-text
• 1m-context
• gguf
• maya
• iq4

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 RAM to match the context you want — about 430 GB for a full 1M run. 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

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

One server per GPU set. A second instance on the same cards dies with cudaSetDevice: out of memory — that cost us a whole night of chasing a phantom hardware fault. Stop the running one first, and check with nvidia-smi that the VRAM is actually released.

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

Measured on this exact config (2×3090): 33.3 tok/s on short prompts, 26.3 tok/s decode at 860K context, prefill 305–550 tok/s. 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-Q4-K-IQ4-MAYA-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.

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.

Vision note

The projector is unquantized and independent of the text weights, so vision quality is unchanged by this release. It is slow on CPU-only paths — fine for a single image, not for bulk captioning.

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: taken from our Q4_K/UNCENSORED release (BF16, unquantized, identical projector).
• 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
• 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