Swift-Qwen3.8-27b-int4-AMD

AMD Quark AWQ INT4 (W4A16) edition of Swift. The following introduction describes the base Swift results; release-specific details are below.

Swift-Qwen3.8-27B is UkisAI's reasoning-efficient derivative of Qwen3.8-27B, using 58.3% fewer thinking tokens while maintaining near-identical performance (<1% loss) and as a result getting a x1.95 speed-up on several tasks.

AMD Quark INT4 release

This is the INT4 W4A16 quantization of Swift for AMD hardware workflows, produced with AMD Quark. It uses Quark's PyTorch workflow and native Hugging Face safetensors export: signed symmetric INT4 weights, groups of 128, and BF16 activations.

The full-precision companion is Swift-Qwen3.8-27b-BF16-AMD.

Quark supports preparing models for AMD deployment. This checkpoint was quantized and validated on an NVIDIA H100; AMD/ROCm serving and throughput have not yet been validated. Serving needs a runtime that supports this native Quark INT4 format. The Quark project and installation guide describe its supported CUDA and ROCm environments.

Checkpoint validation

Perplexity uses the same eight non-overlapping 512-token Wikitext-2 test windows. The 4.15% perplexity increase is a small sanity result, not a full accuracy benchmark. The packed checkpoint was independently reloaded, including its final configuration and index, and reproduced the evaluation NLLs exactly. All floating tensors are finite; 349 preserved vision/output-head/MTP tensors match the source exactly. Vision inference and MTP decoding were not exercised in this validation. See quantization_report.json.

The Swift benchmarks and speed demonstration below are reproduced from the base Swift model card. They do not measure this Quark export or AMD hardware.

Training approach

We built Swift by identifying reasoning-marker tokens that, in our analysis, trigger overthinking in Qwen’s reasoning rollouts. We then fine-tuned Qwen by penalizing usage of those tokens while it reasons.

Swift produces shorter reasoning traces. In our testing, we also observe fewer overthinking errors.

For maximum gains, Swift also includes a transfer component derived from BottleCap AI's ThinkingCap-Qwen3.6-27B.

Evaluation scope

All results below compare the Qwen3.8-27B BF16 base with the same base plus the Swift adapter.

Benchmarks

Efficiency across and versus reasoning efforts

Qwen3.8's reasoning_effort setting lets users choose how much the model thinks. For Swift to be useful across these settings, it needs to reduce thinking while keeping accuracy close to the base. We therefore tested xhigh, medium, and low: thinking-token savings persist at every level.

The efficiency also holds up against the base's own lower effort settings. On GPQA-Diamond (198 questions, 5 seeds, 990 paired calls), Swift at xhigh is compared with the base at xhigh and at medium:

Swift retains the accuracy of xhigh while using about half the tokens, although it uses about double the tokens of medium.

Quantized models

Quantized deployment is the intended use for Swift: lower-memory weights paired with shorter reasoning. The INT4 evaluations below retain token savings across GPQA, IFBench, and AIME. On AIME, Swift matches or improves accuracy and reduces output-cap failures by 31–33%.

Each row compares the same quantized base with and without the Swift adapter. GPQA and AIME use five seeds; IFBench uses four samples per prompt and strict scoring. Output caps: GPQA 100,000; IFBench 81,920; AIME 32,768. GPQA and IFBench use saved historical base runs. AIME uses template-default effort and counts truncated answers as incorrect. Its shorter cap makes it a separate comparison from the BF16 table.

How to use

PyTorch with AMD Quark

Install the GPU-specific PyTorch and Quark packages from the official installation guide. Validation used Python 3.12, PyTorch 2.11.0+cu128, Transformers 5.2.0, AMD Quark 0.12.post1+cu128.torch2.11, Accelerate 1.15.0, and Safetensors 0.8.0. For AMD, select the corresponding supported ROCm environment.

Download this repository and run the included loader:

hf download ukisai/Swift-Qwen3.8-27b-int4-AMD --local-dir Swift-Qwen3.8-27b-int4-AMD
python Swift-Qwen3.8-27b-int4-AMD/load_quark.py \
  --model Swift-Qwen3.8-27b-int4-AMD \
  --prompt "What is 17 multiplied by 23? Answer with only the number."

load_quark.py imports the packed weights through Quark's PyTorch API. The included quark_compat.py handles the public Quark 0.12 dense-Qwen reload path. The model uses the qwen3_5 Transformers architecture identifier. recipe.py records the AWQ configuration. The example disables thinking for a short deterministic smoke check.

Serving

A serving engine must support native Quark W4A16 signed INT4 with reorder packing and this Qwen architecture. As of September 14, 2026, vLLM's native Quark INT4 support PR remains open. Stock vLLM compatibility and AMD performance are not established by the PyTorch validation above. The preserved MTP head also needs compatible runtime support before speculative decoding can be used.

For standard BF16 serving instructions, see the BF16 companion. The base Swift card also documents the UkisAI API and other Swift formats; that API is separate from this downloadable Quark checkpoint.

License and access

Swift weights are distributed under the Swift Open License v1.0. 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 for terms.

Citation

@misc{swift-qwen3.8-27b,
  title  = {Swift-Qwen3.8-27B},
  author = {UkisAI},
  year   = {2026},
  url    = {https://huggingface.co/ukisai/Swift-Qwen3.8-27b}
}

Acknowledgements

We acknowledge the NVIDIA Innovation Lab for providing access to 8× NVIDIA H100 GPUs to train Swift.