base_model:

• meta-models/Muse-Spark-Open-816B-A42B
  base_model_relation: finetune
  license: other
  license_name: muse-model-license
  license_link: https://huggingface.co/meta-models/Muse-Spark-Open-816B-A42B/blob/main/LICENSE.md
  pipeline_tag: image-text-to-text
  library_name: gguf
  language:
• en
  tags:
• gguf
• llama.cpp
• muse
• muse-spark
• moe
• mixture-of-experts
• latent-moe
• multimodal
• abliterated
• uncensored

Muse-Spark-Open-816B-A42B-Abliterated-UD-IQ1_S-GGUF

An uncensored edit of Meta's Muse Spark Open (816B total / 42B active), produced by editing the
shipped Unsloth UD-IQ1_S GGUF directly, in place, with no BF16 requantize at any point.

That matters for a model this size. The 256 routed experts per layer are 156 GB of IQ1_S weights
that Unsloth's dynamic quantization spent real effort on, and a conventional abliterate-then-requantize
pipeline would need the 1.6 TB BF16 parent and a second quantization pass. Instead the refusal
projection is applied in place and quantized codes are re-picked under the original block scales,
so at λ=0 the output file is byte-identical to the input by construction. That is the self-test the
build gates on (verified on every edited tensor type: Q6_K, Q4_K, Q8_0 and F32). The edited shards are
the same length as Unsloth's, byte for byte.

Built with Muse Spark Open.

Files

Muse Spark Open is multimodal, so the projector ships alongside. The edit touched only text-model
tensors, so the projector is byte-for-byte Unsloth's mmproj-Q8_0.gguf (sha256
c3a0613bb2be1dde38faec3d1d1bf2c118013626ab9623936de500a656232ed3). Download all six files; point
llama.cpp at shard 1 and it finds the rest.

llama-server \
  -m Muse-Spark-Open-816B-A42B-Abliterated-UD-IQ1_S-00001-of-00005.gguf \
  --mmproj mmproj-Muse-Spark-Open-816B-A42B-Q8_0.gguf \
  -ngl 99 --n-cpu-moe 42 -c 32768 --jinja \
  --chat-template-kwargs '{"reasoning_effort":"low"}' --reasoning-format auto

You need a llama.cpp built from master at or after commit ba3c05f7 (Muse Spark support). Any build
that loads Unsloth's UD-IQ1_S loads this one: same architecture, same tensor layout, same file
lengths. The numbers below were measured on 2×H200 with every tensor in VRAM (-ngl 99), decoding at
54 tokens/s single-stream, identical to the stock file on the same box. The --n-cpu-moe 42 line
above is the 4×24 GB + 128 GB RAM layout; expect about 1 token/s there with a 24-core CPU, because
the IQ1_S expert matmuls land on the CPU.

reasoning_effort is a chat-template variable (low, medium, high, xhigh; the template
default is xhigh). Everything below was measured at low with a 4096-token budget (8192 on the
held-out StrongREJECT tail). Meta
recommends temperature 1.0, top_p 1.0, top_k disabled.

The edit

Read- and write-side projection over blocks 10-53 of 62, λ = 1.0, one direction per block.
309 tensors edited; the 256 routed experts of every block are untouched.

"Realised removal" is the fraction of the direction's component actually gone after the edited rows
were re-picked into the file's existing block scales; Q6_K rows clip the most, F32 rows take the
edit exactly.

The refusal direction was estimated separately at every block (61 directions, all-token mean over
128 harmful / 128 harmless prompt pairs rendered through the Muse chat template at
reasoning_effort=low). Each block's readers are projected against the direction measured at that
block's input and its writers against the one at its output. A single mid-network direction applied
to every block does nothing measurable on this model: the direction rotates from block to block
(mean cosine 0.43 between a block's own direction and the layer-24 one), so one vector removes the
wrong thing almost everywhere. Because Muse post-normalises each branch before the residual add,
the raw direction is rescaled through the branch's norm weights and residual gain before it is
projected out of each tensor.

Measured: stock vs this edit

Same llama.cpp build, same quant, same prompts, same sampling, same reasoning_effort=low. Refusal is
scored by a frozen model judge on the StrongREJECT rubric; "answered" means a non-empty final answer
and "capped" means the generation hit the token budget before finishing. Read answered and capped
before reading refusal.

Held-out StrongREJECT, prompts 150-303 (n=154), 8192-token budget. No arm of the sweep was ever
selected against these prompts.

ForbiddenQuestions, first 200 prompts (n=200), 4096-token budget. An independent harmful-prompt set.

XSTest safe prompts 100-199 (n=100), 4096-token budget. Benign prompts that superficially look
unsafe; the number is over-refusal, lower is better.

Capability. A 30-problem MATH slice, exact-match, 4096-token budget (HumanEval was not run on
this build).

The stock file already answers about one harmful prompt in seven on the StrongREJECT tail and two in five on ForbiddenQuestions, so the largest drop this quant can show is the stock refusal rate itself: 85 and 60 points. The observed drops are 83.8 and 60.0 points. The smallest difference these sample sizes can detect (80% power, two-sided α = 0.05 at the observed stock rate) is 13.0 points on the StrongREJECT tail and 13.9 on ForbiddenQuestions; both arms sit at 0% on the benign set, so there is no over-refusal change to size.

What this does not measure: anything above reasoning_effort=low, image or audio inputs, the BF16
parent, or any other quant. The IQ1_S experts are Unsloth's and are the same bytes as in the stock
file; the quantization's effect on capability is the same here as there.

Reproducibility

The released shards are the exact bytes that were scored above (sha256 in the file list). The same direction file, λ and block range reproduce the edit on the same machine; a rebuild on a different numpy/BLAS stack re-picks a small number of quantized codes differently at rounding boundaries, so verify against the published hashes rather than a local rebuild.
The edited shards keep every block scale from Unsloth's file; only quantized codes that the
projection moved were re-picked. The vision projector and shard 1 are unmodified.

License

Muse Model License (Meta), inherited from the parent. Built with Muse Spark Open. The usage policy in
the parent's license applies to this derivative. You are responsible for what you deploy.