---

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

| file | bytes | what it is | sha256 |

|---|---|---|---|

| Muse-Spark-Open-816B-A42B-Abliterated-UD-IQ1_S-00001-of-00005.gguf | 13,079,896 | shard 1 (metadata, unmodified) | c7e327f6d210ef2bfa3e312bc831468e61a5d4f8d1d9714a6f6d6d8f6b7d5b70 |

| Muse-Spark-Open-816B-A42B-Abliterated-UD-IQ1_S-00002-of-00005.gguf | 49,907,804,224 | shard 2 | b5385fb3ac905b97b37ee2caf939c96fafa3e60e2c213f36d1a60c742847dda7 |

| Muse-Spark-Open-816B-A42B-Abliterated-UD-IQ1_S-00003-of-00005.gguf | 49,627,378,848 | shard 3 | e0ee06bd4119ec7c3c049f867e578d7c5b5bc64d421e62c7852e8304cf29a60f |

| Muse-Spark-Open-816B-A42B-Abliterated-UD-IQ1_S-00004-of-00005.gguf | 49,414,954,496 | shard 4 | 360b1c1f9bd5e605b0beb9b2e70103d16b1c7e2bb1e0fa05aee1676a2c11c9dd |

| Muse-Spark-Open-816B-A42B-Abliterated-UD-IQ1_S-00005-of-00005.gguf | 26,676,356,928 | shard 5 | f9d352b8d15a4ca49d2af3c9aff155566717db4d5cf7db5d108ff6cc3bae51f5 |

| mmproj-Muse-Spark-Open-816B-A42B-Q8_0.gguf | 2,183,868,768 | vision projector, Unsloth's, unmodified | c3a0613bb2be1dde38faec3d1d1bf2c118013626ab9623936de500a656232ed3 |

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.

| what it is | tensor | stored type | realised removal (mean over 44 blocks) |

|---|---|---|---|

| attention output (writes the residual) | blk.N.attn_output.weight | Q6_K | 0.69 |

| FFN latent up-projection (writes the residual) | blk.N.ffn_latent_up.weight | Q8_0 | 0.92 |

| attention query / key / value (read the residual) | blk.N.attn_q/k/v.weight | Q6_K / Q8_0 / Q8_0 | 0.68 / 0.95 / 0.90 |

| FFN latent down-projection (reads the residual) | blk.N.ffn_latent_down.weight | Q8_0 | 0.91 |

| expert router (reads the residual) | blk.N.ffn_gate_inp.weight | F32 | 1.00 (exact) |

| token embedding | token_embd.weight | Q4_K | 0.05 |

"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.

| | refusal | answered | capped |

|---|---|---|---|

| Unsloth UD-IQ1_S (stock) | 85.06% | 144/154 | 10 |

| this edit | 1.30% | 154/154 | 0 |

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

| | refusal | answered | capped |

|---|---|---|---|

| Unsloth UD-IQ1_S (stock) | 60.00% | 195/200 | 5 |

| this edit | 0.00% | 200/200 | 0 |

XSTest safe prompts 100-199 (n=100), 4096-token budget. Benign prompts that superficially look

unsafe; the number is over-refusal, lower is better.

| | over-refusal | answered | capped |

|---|---|---|---|

| Unsloth UD-IQ1_S (stock) | 0.00% | 100/100 | 0 |

| this edit | 0.00% | 100/100 | 0 |

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

this build).

| | MATH-30 correct | answered | capped |

|---|---|---|---|

| Unsloth UD-IQ1_S (stock) | 26/30 | 30 | 0 |

| this edit | 25/30 | 30 | 1 |

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.