license: other license_name: swift-open-license-1.0 license_link: https://ukisai.com/contact base_model: ajgazin/Swift-1.5-Qwen3.8-27B-Uncensored-MTP base_model_relation: quantized library_name: transformers language:

• en
• zh pipeline_tag: image-text-to-text tags:
• awq
• compressed-tensors
• int4
• uncensored
• abliterated
• mtp
• speculative-decoding
• intel
• arc
• intel-arc
• xpu
• vllm
• qwen3.8
• swift

Swift-1.5-Qwen3.8-27B-Uncensored-AWQ-Int4-asym-G128-MTP-Int4

AWQ W4A16 (asymmetric (per-group zero points), group size 128) quantization of ajgazin/Swift-1.5-Qwen3.8-27B-Uncensored-MTP, with UkisAI's own AWQ recipe for Swift 1.5 — the recipe.yaml published with ukisai/Swift-1.5-Qwen3.8-27b-W4A16-AWQ — and the MTP draft head kept, so native speculative decoding works. Built for Intel Arc / vLLM XPU; a compressed-tensors checkpoint, so stock vLLM loads it too.

Why this recipe

Swift 1.5's selling point is short reasoning. Quantization can quietly undo that, and the recipe decides how much. Measured on GPQA-Diamond under Swift 1.5's published protocol (EvalScope, temperature 1.0, top-p 0.95, top-k 20, xhigh), each pair compared question by question (95% interval of the per-question reasoning-length ratio):

The scores sit within noise throughout; the reasoning length does not. All of the extra reasoning came from the GPTQ recipe, none from the abliteration, and this AWQ recipe adds none. Hence this checkpoint: the AWQ recipe on the abliterated model.

This checkpoint:

Not yet measured on this checkpoint. The figures above are for ukisai's AWQ of the original Swift 1.5 and for the abliteration in BF16. The recipe is the same, and the abliteration added no reasoning length, so the expectation is about 1.0x Swift 1.5 BF16. It is an expectation, not a measurement.

The MTP draft head

ukisai's recipe ignores mtp.*, but transformers never instantiates the draft head at all, so llm-compressor writes a checkpoint without one. ukisai re-attached the 15 BF16 tensors afterwards — and left them out of ignore, so the checkpoint's single Linear config group covers them: vLLM builds the drafter as W4A16 and cannot load BF16 weights into it. This build re-attaches them too, and then either lists them in ignore or packs them. MTP draft head: int4. The 8 drafter linears are rounded to int4 (round-to-nearest, asymmetric, group 128) and packed in the body's own format by requant-mtp-int4.py; the 15 norms stay BF16. Its note: mtp.* linears RTN int4 g128 asym (compressed-tensors pack-quantized, library-checked) from BF16 by quantize/requant-mtp-int4.py (805c132); rel err 0.1071. On two Arc Pro B70s, the same int4 drafter on ukisai's AWQ accepted 3.309 tokens per step against 3.316 for our GPTQ checkpoint's int4 drafter (30 runs each, same prompts): unchanged. The target verifies every draft token, so the drafter can only cost speed, never change the output.

greglechin/Swift-1.5-Qwen3.8-27B-Uncensored-AWQ-Int4-asym-G128-MTP-BF16 is the same body with the BF16 drafter, for stacks that reject this one.

Provenance

Qwen/Qwen3.8-27B                          (base)
  └─ ukisai/Swift-1.5-Qwen3.8-27b                 (Swift 1.5, reasoning-efficient finetune)
       └─ ajgazin/Swift-1.5-Qwen3.8-27B-Uncensored-MTP
            (uncensored, orcarouter rank-1 refusal direction projected out, BF16)
              └─ this repo   (AWQ W4A16 asym g128, int4 MTP drafter, 19 GB)

Quantization

ukisai's manifest records a tokenized sha256 for their calibration set; their preprocessing is not published and none of the variants tried reproduces it, so the calibration set here is equivalent in kind, not provably identical.

Serving (vLLM)

vllm serve /model \
  --kv-cache-dtype fp8 \
  --speculative-config '{"method":"mtp","num_speculative_tokens":5}' \
  --chat-template /model/chat_template.jinja

compressed-tensors is detected from the config. On Intel Arc, Qwen3.8 MTP needs a patched vLLM: the build used here is github.com/greglechin/vllm-xpu. Asymmetric int4 runs about 8% slower on prefill than symmetric there; decode was within noise of our symmetric GPTQ build (35.7 against 36.7 steps/s).

Limitations — please read

• Calibration is English chat (ultrachat_200k). Code-heavy or non-English use may quantize slightly worse than general chat.
• This is an uncensored model. It will attempt requests an aligned model declines. You are responsible for how you use it.
• Uncensoring is inherited, not verified here. All refusal-removal properties come from the upstream ablation; this repo only changes numeric precision, and no refusal testing was run on it.
• The upstream publishes a KL divergence and states what it did not measure. It reports KL 0.0884 against ukisai/Swift-1.5-Qwen3.8-27b on first-token distributions over 100 harmless prompts, and 23/100 refusals, both under Heretic's built-in evaluation with the reference rows measured the same way. Its refusal direction is recovered from orcarouter's published weights rather than fitted fresh, and it verifies that recovery by reproducing orcarouter's 131 edited tensors to 99.75% bit-identical. What it explicitly does not evaluate: general benchmarks, refusal behaviour in thinking mode, whether Swift 1.5's shorter reasoning traces survive, and MTP acceptance — which on a speculative-decoding deployment is the number that decides decode throughput. Measure acceptance on your own traffic before promoting this over a checkpoint you have already gated.

Licence

Not Apache-2.0. These weights inherit the Swift Open License v1.0 from ukisai/Swift-1.5-Qwen3.8-27b. Personal, research, educational, evaluation and commercial use are free for individuals and organizations with annual recurring revenue, including affiliates, of up to US$1,000,000. Above that threshold, commercial use requires a separate Swift Enterprise License — contact UkisAI.

Credits

• Qwen — base model
• UkisAI — Swift 1.5, and the AWQ recipe used here
• ajgazin — directional ablation
• llm-compressor — quantization