juiceb0xc0de/Qwen3.5-9B-Base

A brain atlas for Qwen/Qwen3.5-9B-Base, a 32-layer hybrid that runs linear attention on 24 layers and full attention on the other 8. This is not a chat dataset or a benchmark. It is an internal-mechanics map built by running activations through a corpus of prompts and scoring what each layer, component, head, and feature direction is doing.

This is a base model, before any instruction tuning. That makes it a useful thing to have a map of: whatever structure shows up here was put there by pretraining alone, and anything built on top of these weights inherits it. If you want to know how a hybrid divides labour between its eight attention layers and its twenty-four linear ones, where a base model keeps its output vocabulary, or how much of it tolerates surgery, this is the dataset.

What was run

• Model: Qwen/Qwen3.5-9B-Base
• Corpus: 8,965 diverse prompts across 17 buckets
• Layers probed: all 32
• Full-attention layers: 3, 7, 11, 15, 19, 23, 27, 31, with per-head capture (attn, heads, q, k, v)
• Linear-attention layers: the other 24, captured as linattn_qkv, linattn_z, and linattn_out
• MLP components on every layer: mlp, gate, up
• Contrast: authentic against corporate register
• Passes: activation census, feature taxonomy, per-head analysis, OV-circuit SVD, logit lens, coactivation, code-analysis, register contrast, Sub-Zero surgery with capability fence across code, math, reasoning, factual, and multilingual

Architecture notes

Property	Value
Hidden size	4,096
Layers	32 (24 linear attention + 8 full attention)
Intermediate size	12,288
Full-attention interval	every 4 layers, at 3, 7, 11, 15, 19, 23, 27, 31
Query heads	16
KV heads	4
GQA group size	4 query heads per KV head
Head dimension	256
Attention output gate	enabled
Partial rotary factor	0.25
Linear-attention key heads / value heads	16 / 32, both 128-dimensional
Linear-attention conv kernel	4
Vocabulary	248,320
Tied embeddings	no
Max position embeddings	262,144 (rope type default)
MTP layers	1 (not probed)
Vision tower	27 layers, 1,152-wide (not probed)
Training stage	base, no instruction tuning

Three structural facts shape how the tables should be read.

The layer types are not interchangeable and the census reflects that. A linear-attention layer carries six components and 53,248 coordinates; a full-attention layer carries eight and 55,296. The features row count closes exactly against that split at 24 × 53,248 + 8 × 55,296 = 1,720,320, and head_idx // 4 equals kv_head on all 128 rows of ov_circuits.

The q component is 8,192 wide where 16 heads at 256 dimensions would give 4,096. That is the attention output gate: q_proj emits the query and its gate concatenated, so half those coordinates are gating signal rather than query. The per-head pass split the width by head dimension and produced 32 rows per layer for a 16-head model, so per_head holds 256 q rows across 8 layers where 128 would be right. The upper 16 per layer are gate coordinates.

The linear-attention components pack differently from attention. linattn_qkv is 8,192 wide, consistent with 16 key heads and 16 query heads at 128 dimensions plus 32 value heads at 128; linattn_z at 4,096 is the value-path gate; linattn_out at 4,096 is the projection back into the residual stream. These are the projections around the recurrence, not the recurrence itself.

What the tables contain

Table	Rows	What it gives you
features	1,720,320	feature taxonomy + activation stats per (layer, component, feature_idx)
compliance_behaviour_features	1,720,320	authentic-vs-corporate contrast per feature
coactivation	18,423	feature-pair correlations
logit_lens	8,704	promoted/suppressed output tokens per feature
code_analysis	6,240	entangled vs selective role labels
compliance_behaviour_per_head	448	per-head register separation
per_head	448	per-head selectivity
subzero_capability	330	66 DAS axes × 5 capability domains
ov_circuits	128	16 heads × 8 full-attention layers
subzero_svs	72	retained bouncer singular vectors per projection
layers	32	layer metadata and completion flags
subzero_layer	32	classifier accuracy and SV summary per layer
sae_features	0	not run

Key findings

1. The activation distribution has a populated middle

Across all 1,720,320 coordinates, activation rate spreads out rather than collecting at the ends.

Band	Coordinates	Share
Rate ≤ 0.05	394,125	22.91%
Rate 0.05 to 0.90	1,104,387	64.20%
Rate ≥ 0.90	221,808	12.89%

Almost two thirds of the model sits in the context-dependent middle, where a coordinate fires on some prompts and not others. That band is where selectivity can live, and it is the largest population in the model by a wide margin.

The taxonomy says the same thing with four labels instead of three bands: partial_shared at 36.54%, broadly_shared at 27.63%, non_activated at 22.91%, all_shared at 12.89%.

Hold that shape while reading the rest of this card. Most findings below are about which components own that middle and what they do with it.

2. The gate is the sparse specialist and the most legible component in the model

Census statistics by component, sorted by how much of each sits quiet:

Component	Activation rate	Mean activation	Quiet coords	Mean F-stat
q	0.263	-1.0776	58.6%	43.8
gate	0.187	-0.0696	50.8%	49.7
linattn_z	0.422	-0.4242	44.4%	49.6
linattn_qkv	0.502	0.0022	21.1%	46.1
up	0.500	-0.0010	9.6%	53.2
linattn_out	0.501	0.0002	6.8%	44.1
mlp	0.500	-0.0000	3.9%	32.3

The three gating components sit at the top and everything else clusters near a 0.50 rate with a resting activation of zero. q, gate, and linattn_z are the only components with a strongly negative resting bias, which is what a pre-sigmoid gate looks like from the census side. The mlp output is at the other extreme, almost never quiet at 3.9%.

The gate is not only sparse. It is the most selective component under code-analysis at 95.7% selective against 65.8% for k, it holds 376 of the 488 domain-specific directions the taxonomy resolved anywhere in the model, and it is the strongest logit-lens component at a mean F-stat of 311.4, running 1.91× the mlp path and 2.40× linattn_out.

Sparse, negatively biased, selective, specialized, and legible at the output are one behavior described five ways.

3. Every axis the surgery pass tested cleared the capability fence

66 DAS axes against five capability domains, 330 rows, and all 330 passed.

Domain	Rows	Passed	Mean damage	Max damage
code	66	66	0.0093	0.0915
multilingual	66	66	0.0084	0.0329
reasoning	66	66	0.0076	0.0508
factual	66	66	0.0068	0.0722
math	66	66	0.0062	0.0328

There is no failing population to compare against, because there are no failures. Mean damage across the whole pass is 0.0077 nats per token and the single worst measurement anywhere is 0.0915, on the code domain.

The pass reached six projection families and every one of them cleared at 100%:

Projection	Rows	Mean damage
linattn_in_proj_qkv	10	0.0123
gate_proj	115	0.0090
up_proj	65	0.0080
down_proj	115	0.0063
linattn_in_proj_z	20	0.0057
linattn_out_proj	5	0.0037

Damage does creep upward with depth, from 0.0058 across layers 0-7 to 0.0140 across layers 24-31, and the largest single axis is layer 31 up_proj axis 0 at a mean of 0.0424. Even that one clears every domain.

Read this as a statement about the 66 directions that were tested, which is what a fence measures. What it says is that the register-separating directions this pass found are not load-bearing for code, math, reasoning, factual recall, or multilingual ability at the scale the fence probes. It does not say the model is broadly editable, because most of the model was never a candidate.

4. Two query heads in every full-attention layer do almost no induction

Induction across the 128 head-circuits averages 0.855, and 109 of 128 score above 0.8. Nineteen do not, and they are not scattered.

Every one of the 16 head-circuits scoring below 0.5 belongs to kv_head 0. Inside that group the split is by head index:

Head	KV group	Mean induction	Range
0	0	0.222	0.107 to 0.350
1	0	0.993	0.905 to 1.075
2	0	0.133	0.050 to 0.259
3	0	1.013	0.958 to 1.070

Heads 0 and 2 sit near the floor in all eight attention layers. Heads 1 and 3, reading the same keys and values, sit near the top. The two populations never overlap at any layer.

A gentler version of the same alternation runs model-wide:

KV group	Even heads	Odd heads
0	0.177	1.003
1	0.894	0.992
2	0.881	1.002
3	0.886	1.008

Odd-indexed heads average 1.001 and even-indexed heads 0.710 across the whole table. In groups 1 through 3 that gap runs 0.10 to 0.12. In group 0 it is 0.83.

Two effects are worth separating. The gentle even/odd alternation is present everywhere and is small enough to be a property of how the metric interacts with head ordering. The collapse in group 0 is a different magnitude entirely, it reproduces in all eight layers independently, and it says the first KV group runs two heads doing something other than copy-and-continue while its other two do little else. Naming that something would need an ablation, which this atlas does not have.

5. Induction is spread evenly across all eight attention layers

Layer	3	7	11	15	19	23	27	31
Mean induction	0.890	0.832	0.866	0.843	0.843	0.863	0.846	0.860

The spread from highest to lowest layer is 0.058. There is no induction layer and no induction band; every full-attention layer carries about the same amount.

Only one layer in four gets full attention, and each of those eight does comparable copy-and-continue work rather than the job being handed to a specialist pair. The 24 linear-attention layers are invisible to this measurement, so this describes how the attention budget is spent, not how sequence mixing divides across the whole model.

induction_score exceeds 1.0 on 36 of 128 head-circuits and peaks at 1.114, so it is not normalized to a unit interval and should be read as a relative score.

6. Attention routing narrows sharply in the last two attention layers

Layers	Heads	QK effective rank	QK concentration	OV effective rank
3 through 23	96	45.0	0.122	99.6
27 and 31	32	22.7	0.245	77.9

QK effective rank halves and spectral concentration doubles at layers 27 and 31. The OV path narrows too, but far less, from 99.6 to 77.9.

Across the whole table the OV path runs at 36.8% of the 256-dimensional head and QK at 15.4%. The transform stays broad while the routing decision stays narrow, and in the last two attention layers the routing gets narrower still while induction holds steady at 0.846 and 0.860.

Effective rank does not transfer across architectures without normalizing by head dimension, so treat these as fractions rather than raw numbers.

7. Head redundancy is about the coordinate, not the group

In the heads component a feature index is head*256 + d, so an offset that is a multiple of 256 is the same within-head dimension in a different head, and a GQA group spans 1,024 coordinates.

The stored pairs let both factors be separated:

Pair type	Pairs	Mean correlation
Matched coordinate, same group	866	0.888
Unmatched coordinate, same group	58	-0.082
Unmatched coordinate, cross group	231	0.131

Two heads in the same KV group, compared at the same within-head dimension, correlate at 0.888. Two coordinates in the same group that are not the same dimension sit slightly below zero.

That is the useful control. The redundancy is not a property of sharing a KV projection in general, it is specific to matched coordinates, and same-group pairs at mismatched coordinates are no more related than anything else in the table. Heads in a group are running close to the same computation in the same coordinate frame rather than merely occupying nearby real estate.

By component, gate is the most internally correlated at 0.748, then heads at 0.688 and linattn_z at 0.407, while linattn_qkv, up, v, and k all sit within a few hundredths of zero.

8. The logit lens is gate-driven, strengthens with depth, and carries concepts across scripts

Layers	0-7	8-15	16-23	24-31
Mean F-stat	153.1	189.7	238.9	254.2

By component, gate leads at 311.4, then up at 233.8, heads at 193.3, mlp at 163.4, attn at 135.6, and linattn_out at 129.9.

The strongest features carry coherent token families, and several are coherent across writing systems rather than across spellings:

• Layer 23 gate 5067, the strongest in the pass at 698.5, promotes concepts, 概念, concept, Concepts, 概念的, 的概念, Concept
• Layer 28 gate 8180 promotes 模型, model, 模型的, Model, models, モデル, tying Chinese, English, and Japanese into one direction
• Layer 23 gate 2763 promotes supervision, supervised, Superv, 监督, supervise, 的监督, 監督, spanning simplified and traditional Chinese
• Layer 21 gate 3530 promotes 神经, pretrained, Speech, neural, 训练, Transformer, neuron
• Layer 28 gate 8531 promotes AI, ai, 人工智能, Net, embedding, algorithm

The machine-learning vocabulary features are the ones worth noticing. Layer 21 gate 3530 and layer 28 gate 8531 have each pulled a technical domain into a single direction across two languages.

Not every high scorer is like this. Layer 8 gate 6538 scores 651.9 while promoting 不愁, 事半功倍, 篇小说, lox, swire, =com with no shared theme, and the layers 0-7 band is largely of that kind. Check the token list before treating any single direction as a steering target.

9. Register separation is flat across depth and led by the query path

Mean F-stat on the authentic-versus-corporate contrast, by component:

Component	Mean F-stat	Max F-stat
q	113.4	1,747.0
k	106.6	1,381.1
linattn_z	104.6	1,741.4
up	101.7	1,695.0
gate	90.9	1,789.5
mlp	88.2	1,504.3
heads	86.6	1,659.3

The spread from strongest to weakest component is 27 points, and the query projection leads. By depth the axis rises quickly and then holds:

Layer	0	4	8	14	19	23	27	31
Mean F-stat	53.3	110.0	102.8	109.1	98.2	82.3	88.3	89.7

Layer 0 is the only low point at 53.3. Separation roughly doubles by layer 4 and then sits between 82 and 110 for the remaining twenty-eight layers with no strong trend. The single strongest direction is layer 5 gate 11295 at 1,789.5.

Only two components carry a directional lean, and they are both gates: q splits 40.5% authentic-leaning against 59.5% corporate-leaning, and linattn_z splits 40.7% against 59.3%. Every other component sits within a point of even. Both leaning components have strongly negative resting activation, so the sign of a delta there is not the same measurement it is on a component centered at zero.

10. The register direction is decodable at 98.5% everywhere

subzero_layer fits a linear classifier for the register contrast at each of the 32 layers:

Statistic	Value
Mean classifier accuracy	0.985
Range across 32 layers	0.969 to 1.000

Accuracy is flat and high. At least one layer separates the two register conditions perfectly.

Set that against finding 9, where per-feature F-stat varies by a factor of two across depth. The two are not in conflict, and the gap between them is the useful part. A linear probe over the full residual width finds the register distinction at any layer. What changes with depth is how much of that distinction has collected into individual coordinates.

If you want a named direction to edit, depth matters and layers 4 through 18 hold the concentration. If you only want to detect register, any layer works.

Domain-specific directions follow a different depth profile again. All 488 of them sit in layers 2 through 31, concentrating in the twenties: layer 24 holds 50, layer 20 holds 47, and layer 19 holds 46.

What Sub-Zero is measuring

The Sub-Zero pass is not a generic "find all important directions" sweep. It looks for directions that separate corporate style from authentic style, then uses DAS rotation and a capability fence to check whether removing those directions damages code, math, reasoning, factual, or multilingual ability. The rows in subzero_capability are domain-by-domain damage scores for those candidate axes, not a census of every load-bearing direction in the model.

On this run the candidate stage retained 72 singular vectors across 26 of the 32 layers, and 66 axes reached the fence. Finding 3 describes those 66 and nothing else.

Important caveats

• A 100% pass rate is a statement about the candidates, not the model. 66 axes cleared the fence and none failed, which means this pass produced no negative result to calibrate against. With no failing population, the damage numbers have no contrast case, and "every tested axis passed" is not the same claim as "this model is safe to edit." Most of the model was never a candidate.
• 72 singular vectors were retained but only 66 axes were fenced. Six retained directions have no subzero_capability rows. They are in subzero_svs and carry classifier and Wanda scores, but they were not damage-tested, so nothing in finding 3 covers them.
• The SSM recurrence is not probed. linattn_qkv, linattn_z, and linattn_out are the projections around the gated linear-attention path, not the recurrent state, the convolution, or the decay terms. On a model where 24 of 32 layers mix sequence information through that path, a large share of the machinery is outside what this atlas sees, and every finding here describes the MLP, attention, and linear-attention projection surfaces only.
• per_head reports 32 q heads for a 16-head model. q_proj is 8,192 wide because the attention output gate concatenates the query and its gate, and the per-head pass split that width by head dimension. The upper 16 rows per layer are gate coordinates, not query heads.
• model_meta.json is unpopulated. Every geometry field in it is null. The architecture table above was derived from the source model config and cross-checked against the component widths in the database, not read from that file.
• ov_circuits.compliance_score and ov_circuits.layer_comp_strength are NULL on all 128 rows. They carry no information for this run.
• induction_score is not bounded at 1. It exceeds 1.0 on 36 of 128 head-circuits and peaks at 1.114. Treat it as a relative ranking within this table.
• coactivation stores a selected subset of feature pairs, not a full census. Finding 7 rests on 1,155 head pairs, and the same-group unmatched-coordinate cell holds only 58 of them. That control is the load-bearing comparison in the finding and it is the smallest cell in the table, so treat it as directional. The redundancy result is correlational and a strong merging signal, not proof that removal is free, which would need a fenced ablation run.
• Only 488 domain-specific directions resolved out of 1,720,320 features, 376 of them in gate. The corpus buckets are general-purpose categories. Before reading that as a statement about how specialized this model is, read it as a statement about what a general-purpose corpus can see. Answering the specialization question needs a corpus split along axes the model actually distinguishes, and that is a follow-up run rather than a conclusion.
• The early-layer logit lens is largely incoherent. The layers 0-7 band averages 153.1 but its top features promote token lists with no shared semantics. Logit lens near the embedding partly measures token identity rather than output commitment. Finding 8 rests on the deeper bands.
• Coactivation buckets describe the prompt mix. Dominant buckets come out business at 13.4% and introspection at 11.0%, with 25.0% carrying no bucket at all. Those proportions reflect the corpus and the pair-selection step, not the model.
• One behavioral axis only. This run scored the authentic-versus-corporate register contrast. Nothing here speaks to content domain, refusal, or reasoning depth.
• The vision tower and the MTP head are absent. The config carries a 27-layer, 1,152-wide vision encoder and one multi-token-prediction layer. The text-only load path drops both, so neither appears anywhere in this atlas.
• The census aggregates per prompt, not per token. Activation rate is the fraction of the 8,965 prompts on which a coordinate fires, so finding 1 is a statement about prompt-level consistency rather than token-level sparsity.
• Effective rank is not comparable across model families without normalizing by head dimension. This model's heads are 256-dimensional.
• Damage is in nats per token, measured on the fence probes, not on any public benchmark.
• No SAE features. The sae_features table exists but is empty for this run.
• No downstream benchmark is implied. The atlas describes what the tensors do on this corpus, not whether the model is good at your task.

How to use

atlas.sqlite is the primary query surface. PRAGMA integrity_check returns ok, and the features row count closes exactly against the model geometry at 24 linear-attention layers × 53,248 coordinates plus 8 full-attention layers × 55,296.

import sqlite3
import pandas as pd

conn = sqlite3.connect("atlas.sqlite")

# two thirds of this model lives in the middle: which components own it?
df = pd.read_sql_query("""
    SELECT component,
           ROUND(AVG(activation_rate), 4)                                  AS mean_rate,
           ROUND(100.0*AVG(activation_rate <= 0.05), 2)                    AS pct_quiet,
           ROUND(100.0*AVG(activation_rate > 0.05
                       AND activation_rate < 0.90), 2)                     AS pct_middle
    FROM features
    GROUP BY component
    ORDER BY pct_middle DESC
""", conn)

The per-layer JSON under layers/ and the pooled summaries under cross_layer/ mirror the same data if you would rather not open the database.

-- the two heads in every attention layer that skipped induction class
SELECT head_idx,
       kv_head,
       COUNT(*)                       AS layers,
       ROUND(AVG(induction_score), 3) AS mean_induction
FROM ov_circuits
GROUP BY head_idx
ORDER BY mean_induction
LIMIT 6;

License

Apache 2.0, matching the source model.

Contact / more

• Model: https://huggingface.co/Qwen/Qwen3.5-9B-Base
• Atlas code: https://github.com/JuiceB0xC0de/qwip_atlas
• Follow: https://huggingface.co/juiceb0xc0de