Model reference · open weights

Simple-Attention-Sparsification

LLMs tencent Text gen 1 build Licence not stated 0 dl/mo

Simple-Attention-Sparsification is an open-weight language model from tencent. Simple-Attention-Sparsification (BF16) weighs 216 MB; the smallest configuration that runs it is RTX 3060 12 GB.

For self-hosting, compare this build's requirements below with the GPU you plan to rent.

  • Simple-Attention-Sparsification is a text-generation method by Tencent that learns to rank and select KV blocks for each query using continuous gates optimized end-to-end.
  • The release includes router-only checkpoints for Qwen3-4B, Qwen3-8B, and Qwen3-14B base models, which are not standalone language models and require the corresponding frozen Qwen3 backbone for inference.
  • The gate checkpoints range from 33.0M to 42.0M parameters, with sizes of 64 MiB or 81 MiB, and use a default sparse decode budget of 2,048 tokens.

Summary of the tencent/Simple-Attention-Sparsification model card, 2026-10-01

What it is

Released bytencent
Released2026-09-14
VRAM216 MB for the weights

What it runs on

Memory and cards for Simple-Attention-Sparsification (BF16)

216 MBweights, file size
762 MBruntime overhead, at least

How much memory each request adds isn't estimated yet for this architecture. The weights need at least the cards below, plus room for the context.

CardWeights alone
RTX 3060 12 GBfits
RTX 4060 Ti 16 GBfits
RTX 3090 24 GBfits
RTX 4090 24 GBfits
RTX 5090 32 GBfits
L40S 48 GBfits
A100 80 GBfits
H100 80 GBfits
RTX PRO 6000 Blackwell 96 GBfits
DGX Spark (GB10) 128 GB unifiedfits
H200 141 GBfits
B200 180 GBfits

From the model card

What tencent says about Simple-Attention-Sparsification

Read the model card

SAS learns to rank and select KV blocks for each query. Unlike methods that train a sparse-attention selector by distilling dense attention scores, SAS adds continuous gates to the selected blocks so that the language-modeling loss can optimize context ranking end to end.

Released checkpoints

DirectoryBase modelGate parametersGate checkpoint size
Qwen3-4B-AttnGatesQwen3-4B33.0M64 MiB
Qwen3-8B-AttnGatesQwen3-8B33.0M64 MiB
Qwen3-14B-AttnGatesQwen3-14B42.0M81 MiB

Each directory is an SGLang-compatible AttnGates package containing:

  • attn_gate_weights.pth: the learned gate-router weights;
  • config.json: the base-model reference and seerattn_* configuration;
  • tokenizer and chat-template files copied from the corresponding Qwen3 model.

[!IMPORTANT] These are router-only checkpoints, not standalone language models. The Qwen3 backbone was frozen during training and is not included. Standard transformers.AutoModelForCausalLM.from_pretrained() cannot directly run these directories. Inference requires the corresponding Qwen3 base model and the seer_attn backend in our sglang-blocksparse fork.

Checkpoint configuration

All three checkpoints use the same sparse-attention setup:

SettingValue
KV block size64 tokens
Training Top-K31 historical blocks
Gate hidden size128
Query projectionQproj
Key block poolingmax + min + average
Q/K normalizationenabled
Gate RoPEenabled
Training sequence length32,768 tokens
Training dataOpenR1-Math-220k

Only the gate routers were optimized; all base-model parameters remained frozen. The released setup uses a 2,048-token sparse decode budget by default. The same checkpoints can be evaluated with 1,024-, 2,048-, or 4,096-token budgets without retraining.

Inference

1. Set up SAS and the sparse SGLang backend

git clone https://github.com/Tencent-Hunyuan/Simple-Attention-Sparsification.git
cd Simple-Attention-Sparsification

git submodule update --init --recursive

# Install the SAS environment.
curl -fsSL https://pixi.sh/install.sh | bash  # skip if pixi is already installed
pixi install

# Build the environment used by the sparse inference server.
cd third_party/sglang-blocksparse
pixi install
cd ../..

Download this Hugging Face repository and point GATES to the directory that matches the desired base-model size.

2. Launch a server directly

The following example serves the Qwen3-4B gate checkpoint:

export GATES=/path/to/downloaded-repo/Qwen3-4B-AttnGates
export SGLANG_SEER_TOKEN_BUDGET=2048
export CUDA_VISIBLE_DEVICES=0

cd third_party/sglang-blocksparse
pixi run python -m sglang.launch_server \
  --model-path "$GATES" \
  --served-model-name qwen3-sas-4b \
  --attention-backend seer_attn \
  --tool-call-parser qwen \
  --trust-remote-code \
  --tp-size 1 \
  --port 30000

config.json points to the corresponding public Qwen3 repository, so the base model is downloaded separately when needed. For offline use, download the base model in advance and replace the base_model value in the gate checkpoint's config.json with its local path.

To use another checkpoint, change GATES and the served model name:

# Qwen3-8B
export GATES=/path/to/downloaded-repo/Qwen3-8B-AttnGates

# Qwen3-14B
export GATES=/path/to/downloaded-repo/Qwen3-14B-AttnGates

The server exposes an OpenAI-compatible API at http://127.0.0.1:30000/v1.

3. Run the official evaluation wrappers

The code repository also provides wrappers that start the server, run a benchmark, and stop the server automatically:

cd /path/to/Simple-Attention-Sparsification

export GATES=/path/to/downloaded-repo/Qwen3-4B-AttnGates
export MODE=seer_4b
export BUDGET=2048
export TP=1
export DP=8

# MATH, GPQA-Diamond, and AIME 2024/2025
export TASK=math,gpqa,aime24,aime25
bash scripts/eval/run_reasoning.sh

# LongBench-E
bash scripts/eval/run_longbench.sh

Use MODE=seer_8b or MODE=seer_14b with the matching gate directory for the other model sizes.

[!NOTE] Evaluating on BFCL and VitaBench requires additional benchmark-specific environments and dependencies. Please follow the setup instructions in the code repository before running scripts/eval/run_bfcl.sh or scripts/eval/run_vitabench.sh.

Citation

If you find SAS or these checkpoints useful, please cite:

@misc{li2026sassimpleattentionsparsification,
  title         = {SAS: Simple Attention Sparsification via End-to-End Optimization of Context Ranking},
  author        = {Zhiwei Li and Lei Zhu and Hao Gu and Xiang Hu and Yan Wang and Haitao Mi and Sirui Han and Leo Liang and Zhijiang Guo},
  year          = {2026},
  eprint        = {2609.13141},
  archivePrefix = {arXiv},
  primaryClass  = {cs.CL},
  url           = {https://arxiv.org/abs/2609.13141}
}

Acknowledgements

This release builds on Qwen3, SeerAttention-R, VeOmni, and sglang-blocksparse, our fork of SGLang providing the seer_attn inference backend.

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

How it works

How language models work

Your prompttext / messagesTransformerattention over tokensNext-token loopgenerate + streamResponsetext · tool callsA language model reads your tokens and predicts the next one, again and again, streaming the reply back.
© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms