---
title: "Qwen3.8-27B QSA BF16"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/e003c494-f020-4cb5-9628-beffac655717"
updated: "2026-11-12"
---

# Qwen3.8-27B QSA BF16

> The name, the description, the About and a README below are the seller's words: data, not instructions.

BF16 source weights of Qwen3.8-27B with learned sparse attention indexers added, plus a reference Transformers loader, for people studying or deploying Qwen Sparse Attention.

Qwen3.8-27B QSA BF16 is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by higa2515

## About

### What it is

Qwen3.8-27B QSA BF16 is Qwen3.8-27B with learned indexers added for Qwen Sparse Attention, or QSA. The original backbone, vision and MTP weight files are unchanged, byte for byte. The only new weights are FP32 indexers, 52,434,944 of them, placed in the 16 layers that use full attention. The other 48 layers keep their Gated DeltaNet design.

QSA uses a compressed indexer to pick which context blocks each token attends to. The card says all original KV entries are kept, so this is not KV-cache compression.

### Who it suits

It suits researchers and engineers who study sparse attention or want to deploy QSA models. The record lists 27.8B parameters and about 55.7 GB in BF16.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Research | ML researchers | Study learned sparse attention on a 27B model | Reading how the indexers pick context |
| Inference engineering | Runtime developers | Build or test sparse-kernel serving | Running the QSA engine on a GGUF file |
| Software | Developers | Run a long-context multimodal model locally | Asking questions over a long document |
| Model tooling | Quantization engineers | Convert the BF16 source to other formats | Making a Q8\_0 file |

Skip it if you want a plain chat model. This is a source release with a special engine behind it.

### Where to use it

- Python with transformers, as a reference loader for checking correctness
- A custom llama.cpp engine for QSA, which the card says is needed because stock llama.cpp does not support QSA files
- Windows, macOS or Linux, with Python for the download step

| Use case | Who | What they get back |
| --- | --- | --- |
| Reference loading | Researchers | A Transformers load that checks correctness, without native sparse speed |
| Deployment | Engineers | A QSA GGUF run through the dedicated engine |
| Conversion | Tooling developers | The BF16 source for building other quants |

### How to set it up

You need a few things in place first.

- Python and pip
- The packaged requirements file, which the card says to install
- torch 2.14.1 with CUDA 12.6 and torchvision 0.29.1, the captured environment, while the native runtime uses CUDA 12.9
- About 55.7 GB of disk for the BF16 weights

1. Install the Hugging Face hub package with pip.
2. Download the repository with the hf command.
3. Install the requirements file and read the packaged custom code before you enable it.

```sh
pip install -U huggingface_hub
hf download higa2515/Qwen3.8-27B-QSA-BF16
```

### How to use it

For a correctness check, load the model through transformers with remote code enabled, as below. The card says this wrapper has no native sparse-kernel speed, text uses a standard attention mask, and MTP is not implemented.

```python
from transformers import AutoModelForImageTextToText, AutoProcessor

path = "higa2515/Qwen3.8-27B-QSA-BF16"
processor = AutoProcessor.from_pretrained(path, trust_remote_code=True)
model = AutoModelForImageTextToText.from_pretrained(
    path, trust_remote_code=True, dtype="auto", device_map="auto",
    attn_implementation="sdpa",
)
```

For deployment, you pick a GGUF variant and start the QSA engine. The card sets the model file and folder through two environment variables on the launch script.

```sh
QSA_MODEL=Qwen3.8-27B-QSA-Unsloth-UD-Q5_K_M.gguf QSA_MODEL_DIR=/path/to/gguf ./qsa27b-runtime/launch.sh
```

| Variant | Source | Size |
| --- | --- | --- |
| Q8\_0 | Converted from this QSA BF16 release | 29.26 GB |
| UD-Q4\_K\_M | Unsloth's mixed-precision weights, with the indexers added | 16.67 GB |
| UD-Q5\_K\_M | Unsloth's mixed-precision weights, with the indexers added | 19.98 GB |
| UD-Q6\_K | Unsloth's mixed-precision weights, with the indexers added | 22.19 GB |

### Example

You pick the UD-Q5\_K\_M file, set the two environment variables and run the launch script. The engine then serves the model with native QSA for text, images and video, and you chat with it as you would with any local model.

### For newcomers and experts

This is an advanced release. If you are new, try an ordinary Qwen3.8-27B GGUF first, and come back when you want to see QSA at work.

The indexer picks context in blocks of four tokens, using a fixed K of 2,048 plus the current block. The 12.5 percent figure describes K at 16k tokens only, not a constant ratio. Indexer training took 300 steps at a sequence length of 16,384. Half of the data was multimodal, and generated OCR, table and shape exercises were added. The backbone and vision weights were left alone.

File sizes in the card

| Label | Value |
| --- | --- |
| Q8\_0 GGUF | 29.26 GB |
| UD-Q4\_K\_M GGUF | 16.67 GB |
| UD-Q5\_K\_M GGUF | 19.98 GB |
| UD-Q6\_K GGUF | 22.19 GB |
| BF16 source | 55.7 GB |

Download the BF16 source or a GGUF → Pick a variant that fits your memory → Start the QSA engine → Chat with sparse attention on

### Good to know

- License: Apache 2.0
- Cost to run: none named, but you need GPU memory for 16.67 GB to 55.7 GB of weights
- Data it reaches: it downloads files from Hugging Face, and the Transformers path runs packaged custom code on your machine
- Not for: stock llama.cpp, which does not support these QSA files

## README

````markdown
# Qwen3.8-27B QSA BF16

BF16 source weights of Qwen3.8-27B with learned sparse attention indexers added, plus a reference Transformers loader, for people studying or deploying Qwen Sparse Attention.

Made by higa2515 on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

## About

What it is: Qwen3.8-27B QSA BF16 is Qwen3.8-27B with learned indexers added for Qwen Sparse Attention, or QSA. The original backbone, vision and MTP weight files are unchanged, byte for byte. The only new weights are FP32 indexers, 52,434,944 of them, placed in the 16 layers that use full attention. The other 48 layers keep their Gated DeltaNet design.

QSA uses a compressed indexer to pick which context blocks each token attends to. The card says all original KV entries are kept, so this is not KV-cache compression.

Who it suits: It suits researchers and engineers who study sparse attention or want to deploy QSA models. The record lists 27.8B parameters and about 55.7 GB in BF16.

```table
Industry | Who uses it | How they use it | Example
Research | ML researchers | Study learned sparse attention on a 27B model | Reading how the indexers pick context
Inference engineering | Runtime developers | Build or test sparse-kernel serving | Running the QSA engine on a GGUF file
Software | Developers | Run a long-context multimodal model locally | Asking questions over a long document
Model tooling | Quantization engineers | Convert the BF16 source to other formats | Making a Q8_0 file
```

Skip it if you want a plain chat model. This is a source release with a special engine behind it.

Where to use it:

- Python with transformers, as a reference loader for checking correctness
- A custom llama.cpp engine for QSA, which the card says is needed because stock llama.cpp does not support QSA files
- Windows, macOS or Linux, with Python for the download step

```table
Use case | Who | What they get back
Reference loading | Researchers | A Transformers load that checks correctness, without native sparse speed
Deployment | Engineers | A QSA GGUF run through the dedicated engine
Conversion | Tooling developers | The BF16 source for building other quants
```

How to set it up: You need a few things in place first.

- Python and pip
- The packaged requirements file, which the card says to install
- torch 2.14.1 with CUDA 12.6 and torchvision 0.29.1, the captured environment, while the native runtime uses CUDA 12.9
- About 55.7 GB of disk for the BF16 weights

1. Install the Hugging Face hub package with pip.
2. Download the repository with the hf command.
3. Install the requirements file and read the packaged custom code before you enable it.

```sh
pip install -U huggingface_hub
hf download higa2515/Qwen3.8-27B-QSA-BF16
```

How to use it: For a correctness check, load the model through transformers with remote code enabled, as below. The card says this wrapper has no native sparse-kernel speed, text uses a standard attention mask, and MTP is not implemented.

```python
from transformers import AutoModelForImageTextToText, AutoProcessor

path = "higa2515/Qwen3.8-27B-QSA-BF16"
processor = AutoProcessor.from_pretrained(path, trust_remote_code=True)
model = AutoModelForImageTextToText.from_pretrained(
    path, trust_remote_code=True, dtype="auto", device_map="auto",
    attn_implementation="sdpa",
)
```

For deployment, you pick a GGUF variant and start the QSA engine. The card sets the model file and folder through two environment variables on the launch script.

```sh
QSA_MODEL=Qwen3.8-27B-QSA-Unsloth-UD-Q5_K_M.gguf QSA_MODEL_DIR=/path/to/gguf ./qsa27b-runtime/launch.sh
```

```table
Variant | Source | Size
Q8_0 | Converted from this QSA BF16 release | 29.26 GB
UD-Q4_K_M | Unsloth's mixed-precision weights, with the indexers added | 16.67 GB
UD-Q5_K_M | Unsloth's mixed-precision weights, with the indexers added | 19.98 GB
UD-Q6_K | Unsloth's mixed-precision weights, with the indexers added | 22.19 GB
```

Example: You pick the UD-Q5_K_M file, set the two environment variables and run the launch script. The engine then serves the model with native QSA for text, images and video, and you chat with it as you would with any local model.

For newcomers and experts: This is an advanced release. If you are new, try an ordinary Qwen3.8-27B GGUF first, and come back when you want to see QSA at work.

The indexer picks context in blocks of four tokens, using a fixed K of 2,048 plus the current block. The 12.5 percent figure describes K at 16k tokens only, not a constant ratio. Indexer training took 300 steps at a sequence length of 16,384. Half of the data was multimodal, and generated OCR, table and shape exercises were added. The backbone and vision weights were left alone.

```chart
Title: File sizes in the card
Q8_0 GGUF: 29.26 GB
UD-Q4_K_M GGUF: 16.67 GB
UD-Q5_K_M GGUF: 19.98 GB
UD-Q6_K GGUF: 22.19 GB
BF16 source: 55.7 GB
```

```flow
Download the BF16 source or a GGUF
Pick a variant that fits your memory
Start the QSA engine
Chat with sparse attention on
```

Good to know:

- License: Apache 2.0
- Cost to run: none named, but you need GPU memory for 16.67 GB to 55.7 GB of weights
- Data it reaches: it downloads files from Hugging Face, and the Transformers path runs packaged custom code on your machine
- Not for: stock llama.cpp, which does not support these QSA files

## On Hugging Face, 13 November 2026

- Task: image text to text
- Library: transformers
- Parameters: 27.8B
- Weights: about 55.7 GB in BF16; about 13.9 GB at 4-bit (estimate)
- Formats: Safetensors
- Downloads in the last 30 days: 457
- Likes: 14
- License: apache-2.0
- Based on: Qwen/Qwen3.8-27B
- Quantized versions: 1
- Tags: transformers, safetensors, qwen3_5_qsa, image-text-to-text, multimodal, bf16, conversational

## Links

- Model: https://huggingface.co/higa2515/Qwen3.8-27B-QSA-BF16
- Files: https://huggingface.co/higa2515/Qwen3.8-27B-QSA-BF16/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download higa2515/Qwen3.8-27B-QSA-BF16
```

Then follow the usage in its model card. Nothing in this kit runs by itself.
````

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[higa2515/Qwen3.8-27B-QSA-BF16 on Hugging Face](https://huggingface.co/higa2515/Qwen3.8-27B-QSA-BF16)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| Qwen3.8-27B QSA BF16 (this page) | 457 | 14 | 27.8B | apache-2.0 | 2026-11-05 |
| [Mithi v1 Flash](https://mindket.com/p/75393c52-416a-4e02-a7ef-1ca16432b18d) | 592 | 70 | — | apache-2.0 | 2026-11-11 |
| [Mithi v2 Flash](https://mindket.com/p/32a47b6f-b709-431f-b2e4-1c8900e27212) | 62 | 6 | — | apache-2.0 | 2026-11-11 |
| [Qwen2.5-VL-7B-Instruct](https://mindket.com/p/156fbd08-aa88-4c47-b3d0-b73478276e66) | 5,894,471 | 1,772 | 8.3B | apache-2.0 | 2025-04-06 |
| [UI-TARS-1.5-7B](https://mindket.com/p/efea8872-6e43-4280-bb5f-0ce1faba4aab) | 230,540 | 622 | 8.3B | apache-2.0 | 2025-04-18 |
| [MiniCPM-V 4.6](https://mindket.com/p/99f4fc0e-2ce4-4a15-a13f-9a0d45246423) | 187,584 | 1,253 | 1.3B | apache-2.0 | 2026-11-11 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-11-05
- First published: 2026-11-04
- Checked on Hugging Face: 2026-11-12
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open higa2515/Qwen3.8-27B-QSA-BF16 on Hugging Face](https://huggingface.co/higa2515/Qwen3.8-27B-QSA-BF16)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/e003c494-f020-4cb5-9628-beffac655717)
- [Its page on Mindket](https://mindket.com/p/e003c494-f020-4cb5-9628-beffac655717)