Alibaba’s Qwen‑Scope: A Brain‑Computer Interface for Qwen‑3.5‑27B

Overview

Qwen‑Scope is a sparse autoencoder (SAE) attached to the hidden layers of the Qwen‑3 / Qwen‑3.5 series. It maps each 5120‑dimensional activation vector to an 81920‑dimensional sparse representation, activating only 50 features per forward pass. Each active feature corresponds to a human‑readable semantic concept (e.g., “financial text”, “code comment”, “apologetic tone”). The released checkpoint SAE-Res-Qwen3.5-27B-W80K-L0_50 is trained for Qwen‑3.5‑27B and covers all 64 layers.

Core specifications

Base model: Qwen‑3.5‑27B

SAE width ( d_sae): 81920

Hidden dimension ( d_model): 5120

Expansion factor: 16×

Top‑K: 50

Mount point: Residual Stream

Covered layers: 0–63 (64 layers)

File format: PyTorch .pt dictionary

Capabilities

Controllable inference : raising the activation of a target feature (e.g., “polite” or “code”) steers model output more reliably than prompt engineering.

Evaluation sample distribution analysis : comparing feature activation distributions across two datasets reveals train‑test gaps.

Data classification & synthesis : using active features as clustering signals enables automatic labeling of large corpora, outperforming keyword methods.

Model training optimization : monitoring features during training can detect early drift.

Architecture

Qwen‑Scope is a Top‑K SAE that keeps exactly 50 non‑zero features per forward pass. Each layer’s checkpoint file layer{n}.sae.pt stores a Python dict with four tensors: W_enc – shape (81920, 5120) – encoder weight W_dec – shape (5120, 81920) – decoder weight b_enc – shape (81920,) – encoder bias b_dec – shape (5120,) – decoder bias

The repository contains files layer0.sae.pt … layer63.sae.pt, enabling analysis of any specific layer.

Installation

Qwen‑Scope consists of weight files and a small hook‑injection script; it requires only torch and transformers. pip install torch transformers Download the Qwen‑3.5‑27B base model and the SAE files from:

https://huggingface.co/Qwen/SAE-Res-Qwen3.5-27B-W80K-L0_50

Usage Example

The end‑to‑end demo follows five steps: load the base model, load the SAE for a chosen layer, hook the residual stream, run a forward pass, and extract sparse feature activations.

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

# 1. Load base model
model_name = "Qwen/Qwen3.5-27B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float32)
model.eval()

# 2. Load SAE for target layer (0–63)
LAYER = 0
sae = torch.load(f"layer{LAYER}.sae.pt", map_location="cpu")
W_enc = sae["W_enc"]          # (81920, 5120)
b_enc = sae["b_enc"]          # (81920,)

def get_feature_acts(residual: torch.Tensor) -> torch.Tensor:
    """residual: (..., 5120) → sparse feature activation (..., 81920)"""
    pre_acts = residual @ W_enc.T + b_enc
    topk_vals, topk_idx = pre_acts.topk(50, dim=-1)
    acts = torch.zeros_like(pre_acts)
    acts.scatter_(-1, topk_idx, topk_vals)
    return acts

# 3. Hook residual stream
captured = {}
def _hook(module, input, output):
    hidden = output[0] if isinstance(output, tuple) else output
    captured["residual"] = hidden.detach().cpu()
hook = model.model.layers[LAYER].register_forward_hook(_hook)

# 4. Forward pass
text = "The capital of France is"
inputs = tokenizer(text, return_tensors="pt")
with torch.no_grad():
    model(**inputs)
hook.remove()

# 5. Extract feature activations
residual = captured["residual"]          # (1, seq_len, 5120)
feature_acts = get_feature_acts(residual)  # (1, seq_len, 81920)
last_token_acts = feature_acts[0, -1]
active_idx = last_token_acts.nonzero(as_tuple=True)[0]
print(f"Active features : {active_idx.tolist()}")
print(f"Feature values  : {last_token_acts[active_idx].tolist()}")

The script prints the indices and values of the 50 active features, each representing a semantic unit.

A Gradio demo can be launched with:

python app.py \
    --model Qwen/Qwen3.5-27B \
    --model-name-sae-trained-from qwen3.5-27b \
    --model-name-analyzing-now qwen3.5-27b \
    --sae-path Qwen/SAE-Res-Qwen3.5-27B-W80K-L0_50 \
    --top-k 50 \
    --num-layers 64 \
    --sae-width 81920 \
    --d-model 5120 \
    --server-port 7860

Open localhost:7860 in a browser to explore feature responses.

Note: the same SAE can be used to analyze checkpoints from the post‑training stage; retraining a new SAE for a fine‑tuned model is not mandatory.

Practical Observations

Advantages

Full‑layer coverage (64 layers) enables vertical analysis of model functionality.

Top‑K design fixes sparsity at 50, offering predictable engineering behavior compared with L1‑sparse SAEs.

Mounted on the residual stream, which carries high‑speed information in Transformers, making explanations more generally applicable.

Gradio integration lowers the entry barrier relative to research‑grade codebases.

Drawbacks

Disk consumption: each layer’s weights (~(81920×5120)×2 plus biases) occupy gigabytes in full precision; 64 layers require substantial storage.

GPU memory: the 27B base model already stresses memory; adding SAE inference likely exceeds a single RTX 4090, recommending A100/H100 for research.

Narrow use case: primarily useful for interpretability, controllable generation, or training‑data analysis; not needed for standard deployment.

Training framework not released: only weights are provided, so reproducing or extending the SAE requires custom implementation.

Conclusion

Qwen‑Scope provides a complete, large‑scale open‑source SAE collection for Qwen‑3.5‑27B, suitable for researchers studying large‑model interpretability, advanced controllable generation, or training‑data analysis. For typical chatbot or RAG applications, the tool offers little benefit.