StillDeadcode/swift1.5-qwen3.8-27b-fp8

Swift 1.5 Qwen3.8-27B FP8 + DFlash2 — radiance container

ukisai/Swift-1.5-Qwen3.8-27b — UkisAI's reasoning-efficient finetune of Qwen3.8-27B — quantised from its bf16 checkpoint to block FP8 into a single .rad container for the radiance inference engine (AMD RDNA4, ROCm), with its vision tower and the z-lab/Qwen3.8-27B-DFlash2 block-diffusion drafter merged in for speculative decoding.

The source model's card describes how it was trained, how it was evaluated and what it is for.

Needs radiance 1.2.3 or newer (the drafter's MXFP4 linears and rescored 2-bit head).

File	swift1.5-qwen3.8-27b-fp8.rad — 28.67 GiB
Weights	the finetune's bf16 linears as E4M3 with a bf16 scale per 128×128 block, rounded to nearest: the same tensors in the same form as Qwen's own Qwen3.8-27B-FP8 release; the lm_head block FP8 too; norms, embedding, the delta net's a/b projections and the vision tower bf16
Speculator	DFlash2, its linears OCP-MXFP4 from its bf16 release; its vocabulary head as 2-bit codes, whose top 32 candidates the engine rescores against the model's own FP8 head. It was trained on the base Qwen3.8-27B and drafts for this finetune too: drafts are verified, so they change the speed and never the output
Vision	the 27-block vision tower, bf16: images and video in chat requests
Context	262,144 tokens trained

Testing

Mean relative error of the FP8 weights against the bf16 checkpoint: about 2.7% per block, the rounding error of E4M3. Not measured as KL divergence against the bf16 model.

Before upload it was served on one Radeon AI PRO R9700 (--tp 1, 32K context): arithmetic, a multi-step word problem, a tool call, an image description and four concurrent requests all answered correctly, with 45–82% of the DFlash2 drafts accepted.

Serve

radiance --model swift1.5-qwen3.8-27b-fp8.rad --tp 2 --max-model-len 200000 --kv-cache-dtype fp8 \
    --max-num-seqs 8 --host 0.0.0.0 --port 8000

On a single 32 GB card the weights fit with a shorter context and the embedding table in host RAM:

radiance --model swift1.5-qwen3.8-27b-fp8.rad --tp 1 --max-model-len 32768 --kv-cache-dtype fp8 \
    --max-num-seqs 4 --embedding-placement ram --host 0.0.0.0 --port 8000

The server speaks the OpenAI API (/v1/chat/completions, /v1/completions), with tool calls and structured output, and image_url / video_url parts in chat messages. The drafter's depth is chosen automatically (--num-speculative-tokens N states one, 0 turns speculation off).

How this file was made

rad-convert ukisai/Swift-1.5-Qwen3.8-27b --draft-model z-lab/Qwen3.8-27B-DFlash2 \
    --recipe q38-27b-fp8block-df2.recipe \
    --set quantization_config.quant_method=fp8 --set quantization_config.fmt=e4m3 \
    --set "quantization_config.weight_block_size=128 128" \
    --set quantization_config.activation_scheme=dynamic -o swift1.5-qwen3.8-27b-fp8.rad

The --set keys state the format the container is in, as Qwen's FP8 checkpoint's own config does, so the FP8 model is what serves it; a radiance newer than 1.2.4 is needed to convert this way. The recipe (q38-27b-fp8block-df2.recipe in this repository); everything it does not name is the checkpoint's bf16:

blk.*.attn_qg.weight rtn codes=fp8_e4m3 block=128x128 scale=bf16
blk.*.attn_k.weight rtn codes=fp8_e4m3 block=128x128 scale=bf16
blk.*.attn_v.weight rtn codes=fp8_e4m3 block=128x128 scale=bf16
blk.*.attn_output.weight rtn codes=fp8_e4m3 block=128x128 scale=bf16
blk.*.ssm_inz.weight rtn codes=fp8_e4m3 block=128x128 scale=bf16
blk.*.ssm_out.weight rtn codes=fp8_e4m3 block=128x128 scale=bf16
blk.*.ffn_gate_up.weight rtn codes=fp8_e4m3 block=128x128 scale=bf16
blk.*.ffn_down.weight rtn codes=fp8_e4m3 block=128x128 scale=bf16
output.weight rtn codes=fp8_e4m3 block=128x128 scale=bf16
dflash.draft_head.weight rtn codes=u2 zero=u8 group=128 scale=f16 rule=search
dflash.fc.weight rtn codes=fp4_e2m1 group=32 scale=e8m0
dflash.blk.*.attn_q.weight rtn codes=fp4_e2m1 group=32 scale=e8m0
dflash.blk.*.attn_k.weight rtn codes=fp4_e2m1 group=32 scale=e8m0
dflash.blk.*.attn_v.weight rtn codes=fp4_e2m1 group=32 scale=e8m0
dflash.blk.*.attn_output.weight rtn codes=fp4_e2m1 group=32 scale=e8m0
dflash.blk.*.ffn_gate_up.weight rtn codes=fp4_e2m1 group=32 scale=e8m0
dflash.blk.*.ffn_down.weight rtn codes=fp4_e2m1 group=32 scale=e8m0

License

Copyright 2026 UkisAI. Swift Contribution licensed under the Swift Open License v1.0 (https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-27b/blob/main/LICENSE). Derivative of Qwen3.8-27B, Copyright 2026 Alibaba Cloud, Apache License 2.0.

This repository carries the Swift Open License v1.0 (LICENSE), the base model's Apache License 2.0 (LICENSE-APACHE-2.0) and UkisAI's NOTICE, unchanged. Under the Swift Open License, commercial use of the Swift contribution by an organisation with US$1,000,000 or more in annual revenue needs a separate license from UkisAI; read LICENSE for the terms.

Changes made here: the finetune's weights were converted to block FP8 and, with the DFlash2 drafter's weights (z-lab) and the tokenizer and chat template, written into the single swift1.5-qwen3.8-27b-fp8.rad file. No weight was trained or otherwise changed. This conversion is not made or endorsed by UkisAI.