Instructions to use just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("image-text-to-text", model="just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq")
model = AutoModelForMultimodalLM.from_pretrained("just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq

SGLang

How to use just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq with Docker Model Runner:
```
docker model run hf.co/just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq
```

Qwen3.8-27B-TURBO-Fable-MXFP4-awq

Quark MXFP4 (W4A8) + AWQ quantization of DavidAU/Qwen3.8-27B-TURBO-Fable-Cold-Fusion-735-882-Heretic-Uncensored-NM-DAU — a 27B dense model built on Qwen/Qwen3.8-27B via multi-stage "Cold Fusion" / GAIN training with an uncensored (abliterated-style) heretic treatment.

Same recipe as just1moremodel/Qwen3.8-27B-Uncensored-MXFP4-awq — this is that pipeline applied to the Fable Cold-Fusion source.

Full BF16 source: ~55 GB → this checkpoint: 18.04 GiB (single model.safetensors)
Verified serving locally on vLLM (AMD RDNA4 / gfx1201, TP2) with coherent output
Quantized with AMD Quark 0.12 (quant_scheme mxfp4, quant_algo awq, 64 calibration samples, seq 512, pileval)

How to run

Start with this image: https://hub.docker.com/r/stilldeadcode/vllm-radiance Add this: https://codeberg.org/ggz14/radiance-vllm-mxfp4 NOTE: fp8_mtp.py was already ran on this model, it is not needed to run again.

Quantization details


Quant method	Quark (`quant_method: quark`)
Weight format	MXFP4 (fp4, group size 32, E8M0 scales), U8-packed
Activation format	fp8 (dynamic) — W4A8
AWQ	Enabled — per-layer scaling search over all 64 layers (MLP scaling map from AMD's Qwen3.8-27B-Quark-AWQ-MXFP4 reference)
`self_attn`	Quantized (U8-packed, matching AMD's reference — no attention exclusion)
Excluded (BF16)	`lm_head` + full vision tower (111 `model.visual.*` entries)
MTP / drafter head	8 `mtp.` projections requantized BF16 → FP8-E4M3* per-channel weights + FP32 scales (declared in `layer_quant_config`), for speculative decoding
Tensors	1703 total: 1346 `language_model.` + 23 `mtp.` + 333 `visual.*` + `lm_head`
Architecture	`Qwen3_5ForConditionalGeneration` (multimodal wrapper; vision tower intact in BF16)
Params	27B dense, 64 layers

What the source model is

Per the source card: a multi-stage tuned model combining Cold Fusion 735/882 ratio training, GAIN training, and an uncensored "NM/DAU" heretic treatment on the Qwen3.8-27B base — aimed at instruction following, creative prose, and unrestricted assistant behavior. Refer to the source model card for full details on the training method and intended use. This repo only changes the precision (BF16 → MXFP4/AWQ); weights are otherwise derived from that source.

Launching with vLLM

Standard OpenAI-compatible server:

vllm serve /path/to/Qwen3.8-27B-TURBO-Fable-MXFP4-awq \
  --host 0.0.0.0 --port 8000 \
  --tensor-parallel-size 2 \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90 \
  --trust-remote-code

Notes:

Serving stack matters more than usual. Quark MXFP4 W4A8 needs a vLLM build with the Quark/MXFP4 path enabled. On AMD RDNA4 this was validated on a radiance vLLM 0.27.1 (torch 2.11+rocm7.14) build with the MXFP4 custom kernels; stock upstream vLLM with quant_method: quark support should load it via its Quark integration — if your build lacks MXFP4 kernels for your GPU, you will get a kernel-availability error at load, not silent slowdown.
The checkpoint carries a full Qwen3.8 chat template (chat_template.jinja included) with reasoning-effort control (xhigh/medium/low, default xhigh) and XML tool calling. Pass chat_template_kwargs: {"enable_thinking": false} to disable thinking mode.
32 GB-class GPUs: fits in TP2 on 2×32 GB (18 GiB weights + activations + FP8 KV cache). Single 32 GB card is too tight for comfortable context; single 48 GB+ works.
Speculative decoding: the FP8 MTP head is already wired in the config; --speculative-config '{"method":"mtp","num_speculative_tokens":5}' works on stacks that support Qwen MTP drafting.

Verification performed

Quant output gates: quant_method: quark, fp4/group-32 weights + activations, exclude = lm_head + vision, self_attn U8-packed, 18.04 GiB (matches AMD's reference size for this architecture — no accidental exclusions)
Converted layout verified: 1703 tensors, correct multimodal wrapper config, algo_config nulled (vLLM quark mapper compatibility), FP8 MTP declared
Served end-to-end on vLLM (RDNA4 TP2): healthy boot, coherent greedy completions in both thinking and non-thinking modes

Intended use & limitations

Uncensored model — intended for adults, research, and responsible use; no built-in safety alignment. All limitations of the source apply (see its card). Quantization (MXFP4 W4A8) adds minor degradation vs BF16; AWQ scaling was calibrated to minimize output deviation on general text, but has not been benchmarked against the BF16 source with formal metrics.

Credits

Source model: DavidAU — Qwen3.8-27B-TURBO-Fable-Cold-Fusion-735-882-Heretic-Uncensored-NM-DAU
Base model: Qwen — Qwen3.8-27B
Quantization: AMD Quark (MXFP4 + AWQ), AWQ scaling map from AMD's Qwen3.8-27B-Quark-AWQ-MXFP4 reference checkpoint

Downloads last month: 1,356

Safetensors

Model size

16B params

Tensor type

BF16

F8_E4M3

Model tree for just1moremodel/Qwen3.8-27B-TURBO-Fable-MXFP4-awq

Base model

Qwen/Qwen3.8-27B

Finetuned

DavidAU/Qwen3.8-27B-TURBO-Fable-Cold-Fusion-735-882-Heretic-Uncensored-NM-DAU

Quantized

(88)

this model