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.