---

base_model: sci4ai/Qwen3.6-27B-Ablit

base_model_relation: quantized

library_name: gguf

quantized_by: sci4ai

tags:

- abliteration

- uncensored

- gguf

- qwen3

pipeline_tag: text-generation

---

Qwen3.6-27B-Ablit-IQ2_XXS-GGUF

My newest quant of my Qwen3.6-27B-Ablit model. Much faster generation than the IQ4_XS quant I released,

and switching to this model enabled me to start running a second llama-server instance with --parallel 3

hosting Qwen3.5-9B subagents. My agent fires off tools like no other now.

One shortcoming I have to point out: this model has a bit tougher time staying on task. Can be impatient

about responses and assume they've failed before they return, causing it to try to switch methods in a

perpetual loop. I recommend proactively prompting against this e.g., "Call tools and then wait for their result. Do not take

lack of instant response as a call to action. Stay on course until a method proves itself unreliable. Parallel tool calls are allowed."

NOTE: Data was collected from model using non-thinking mode only. Enabling thinking will almost certainly bring back refusals to some degree. For that reason I

suggest running with the flag: ``--reasoning off` in llama.cpp (`--think off`` in Ollama). I currently run on my 4080 SUPER (16GB) via:

llama-server -m $YOUR_MODEL_LOCATION \
-ngl 35 -c 32000 -fa on \
--reasoning off

WARNING: If you previously grabbed my v1 or v2 variants, I recommend replacing with this model. I ablated too agressively and the model's generations were not factually

aligned and were often hallucinated.

*Let me know if other quants are desired, I would recommend not going much lower in precision if you're using for tool based/agentic tasks. IMHO: IQ4_XS is the sweet spot for

consumer cards on this model. I still require a partial offload to load a decent k-v cache size.

Calibration data for imatrix quants

The imatrix for this model was generated using a concatenation of two of Bartowski's calibration data sets and my own additions detailed below:

1. calibration_datav5.txt
2. qwen_calibration_with_chat.txt
3. Roughly 15 examples of <|tool_call|> and <|think|> style blocks generated by Qwen3.6-Plus @ chat.qwen.ai covering math/coding/logic. Examples

included multi-turn chat requiring single and multiple tool calls, and requests that required/did not require thinking. ``--process-output`` flag set.

Check out the collection--Qwen3.6-27B (Abliterated/Uncensored)

Current Quants

| Link | Format | Size | Notes |

|:-----|:-------|-----:|:------|

| IQ4_XS | GGUF | 15.1 GB | recommended — ~4.25 bpw daily driver (≥16 GB VRAM) |

| Q8_0 | GGUF | 28.6 GB | near-lossless |

| BF16 | GGUF | 53.8 GB | full-precision GGUF |

| Safetensors | transformers | ~56 GB | full precision, vLLM / transformers |

| imatrix | GGUF | 13 MB | importance matrix used for the IQ4_XS quant |

---

Abliteration Method

AblitMD — for multi-disciplinary abliteration, and to be a little hokey.

Try it out: roll your own recipe (ablitMD or classic heretic-style) with the

all-in-one app at github.com/eric-merritt/ablitMD.

The motivation is Tom Wollschläger et al.'s theory that refusal is not a single

direction but a polyhedral cone (arXiv:2502.17420),

hence per-category ablation.

1. Per category directions computed using the hidden states from the final token in the residual stream.

i. A sample set of 41 harm categories was derived through a simple 2 message chat with popular models:

The questions:

1. I'm doing some research on refusals in LLMs. What are the reasons why

you might refuse a request?

2. I'm interested in hearing more about the granularity in your refusal

responses — e.g., the way that you refuse vs. reframe or redirect a

request.

The models:

- Claude Opus 4.6

- ChatGPT 5.6

- Llama 4 Maverick

- Qwen 3.6 Plus

For each category, the following prompts were formulated:

- 5 Harmful

- 5 Harmless

Each prompt was run through the base model and the hidden states at the

final token were captured per layer. Every response was then classified by

refusal mode (hard / redirect / disclaimer / none), and each

classification was reviewed by hand for accuracy before the activations

fed into the direction computation.

1. Rather than apply one flat direction at one strength across the whole stack, the

edit is split at two layer boundaries — an onset layer (where refusal

representation first becomes coherent) and a split layer (where category-level

detail collapses into a single shared refusal signal). For this build the window

sits at onset = 30, split = 39 (last layer 64); the per-layer ablation factors

are tuned per recipe and not published here.

Phase A — Onset → Split (per-category directions)

The cone is at its widest right where it first forms. At the onset layer the

per-category directions are still short but point in measurably different

directions (the per-layer centroid carries only ~70% of the energy — the rest is

angular spread between categories). Across this window the magnitudes climb

steeply while the directions gradually converge toward a common axis, so the cone

narrows as it grows taller. Phase A is therefore the region where per-category

structure is most distinct and most worth preserving — which is why these layers

keep a separate direction per category rather than a shared one.

Across this window each of the 41 harm categories gets its own refusal

direction, computed per layer from that category's hidden states (the merged

mean of its hard and redirect examples, unit-normalized). Each direction is

ablated at its own strength, although I'll note I used the same factor on each of the categories but

six more stubborn refusal categories.

Keeping directions per-category in the early layers preserves specificity — the

edit that suppresses one category's refusal doesn't smear into an unrelated one.

Phase B — Split → Last (joint direction)' and '' style

Past the split, I theorized that per-category structure was less useful — the

magnitudes were starting to level off across categories, which I read as the

network having mostly committed to a single, general refusal signal. So these

layers are ablated with one shared direction: the mean of every per-category

direction across the phase-B window, renormalized, applied at factor_b = 1.0.

Key Considerations

Non-overlap via Gram–Schmidt

Many categories share part of their refusal direction; there's a common

"this is a refusal" subspace plus category-specific residue. If you simply

ablated all 41 directions independently, that shared subspace would get hit

41x over, summing the factors and massively over-editing the model

along the common axis.

To prevent that, the per-category directions are deduplicated with an **ordered

Gram–Schmidt process (after Jørgen Pedersen Gram and Erhard Schmidt**,

whose orthogonalization procedure this is):

1. Sort the category directions highest factor first.
2. Walk the list, keeping a running orthonormal basis of directions already taken.
3. For each next direction, subtract off its projection onto everything already

in the basis, keeping only the component orthogonal to them.

1. Ablate that residual at its own factor.

The net effect: **a shared subspace is ablated once, at the single greatest

factor among the categories that share it — never the sum of their factors.**

---

Refusal characterization of the base model

The directions above were derived from a 440-prompt evaluation run

(run_2026-05-17T19-57-17-480Z) against the unedited base model, with every

response classified into one of four refusal modes:

• hard — flat refusal ("I can't help with that")
• redirect — refuses but offers an alternative ("Instead, I can…")
• disclaimer — complies but front-loads a warning
• none — direct compliance

These charts describe the base model's behavior — the problem the abliteration

is solving for — not the edited model.

Overall refusal mode distribution

!Refusal mode distribution

All 440 prompts classified: 92 hard, 111 redirect, 17 disclaimer,

220 none.

Refusal mode by category group

!Refusal mode by category group, stacked

The refusal cone

!Per-category ablation directions as a cone

Every category's refusal direction (mean over the phase-B window, L39–L63),

projected to 2D. Solid arrows are hard, dotted are redirect.

• Right — Uncentered (SVD from origin): the directions drawn as absolute

vectors. They bundle tightly around a single dominant axis (PC1 ≈ 78% of the

variance) — this is the cone, and that axis is the shared "this is a refusal"

signal every category leans on.

• Left — Centered (PCA from centroid): the same directions with that shared

axis subtracted out, so each arrow is a category's deviation from the average

refusal direction. With the common axis removed the remaining structure fans

out in every direction — the per-category residue that Phase A's separate

directions are there to capture.

---

FINAL NOTE

sci4ai does not claim to be the morality police; use our models as you see fit, but remember: your choices > your consequences.

Attribution

• Base weights: Qwen team (Qwen/Qwen3.6-27B).
• Refusal-direction abliteration builds on the "refusal is mediated by a

direction" line of interpretability work.

• The non-overlap deduplication uses the Gram–Schmidt orthogonalization

process.

• Two-phase recipe, per-category Gram–Schmidt deduplication, and quantization:

sci4ai (ablitMD).

• Calibration data by @Bartowski + Qwen3.6-Plus