juiceb0xc0de/Qwen3.5-2B-Base

A brain atlas for Qwen/Qwen3.5-2B-Base, a 24-layer hybrid that runs linear attention on 18 layers and full attention on the other 6. 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, so whatever structure shows up here was put there by pretraining alone and anything built on these weights inherits it. If you want to know what a hybrid looks like when it only gets six attention layers to work with, where the model keeps its output vocabulary, or which directions in it are load-bearing, this is the dataset.

What was run

• Model: Qwen/Qwen3.5-2B-Base
• Corpus: 8,965 diverse prompts across 17 buckets
• Layers probed: all 24
• Full-attention layers: 3, 7, 11, 15, 19, 23, with per-head capture (attn, heads, q, k, v)
• Linear-attention layers: the other 18, 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	2,048
Layers	24 (18 linear attention + 6 full attention)
Intermediate size	6,144
Full-attention interval	every 4 layers, at 3, 7, 11, 15, 19, 23
Query heads	8
KV heads	2
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 / 16, both 128-dimensional
Linear-attention conv kernel	4
Vocabulary	248,320
Tied embeddings	yes
Max position embeddings	262,144 (rope type default)
MTP layers	1 (not probed)
Vision tower	24 layers, 1,024-wide (not probed)
Training stage	base, no instruction tuning

Three structural facts shape how the tables should be read.

The full-attention layers are narrower than the linear ones. A linear-attention layer carries six components and 28,672 coordinates; a full-attention layer carries eight and 27,648. Eight heads at 256 dimensions is 2,048, exactly the residual width, so the attention block contributes less captured surface than the linear-attention block it replaces. The features row count closes exactly against that split at 18 × 28,672 + 6 × 27,648 = 681,984, and head_idx // 4 equals kv_head on all 48 rows of ov_circuits.

The q component is 4,096 wide, twice the 2,048 that 8 heads at 256 would give. That is the attention output gate: q_proj emits the query and its gate concatenated. The per-head pass split that width by head dimension and produced 16 rows per layer for an 8-head model, so per_head holds 96 q rows across 6 layers where 48 would be right, and the upper 8 per layer are gate coordinates.

The linear-attention components pack differently. linattn_qkv is 6,144 wide, consistent with 16 query, 16 key, and 16 value heads at 128 dimensions each; linattn_z at 2,048 is the value-path gate; linattn_out at 2,048 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	681,984	feature taxonomy + activation stats per (layer, component, feature_idx)
compliance_behaviour_features	681,984	authentic-vs-corporate contrast per feature
coactivation	13,461	feature-pair correlations
logit_lens	6,528	promoted/suppressed output tokens per feature
code_analysis	4,680	entangled vs selective role labels
subzero_capability	540	108 DAS axes × 5 capability domains
subzero_svs	142	retained bouncer singular vectors per projection
compliance_behaviour_per_head	168	per-head register separation
per_head	168	per-head selectivity
ov_circuits	48	8 heads × 6 full-attention layers
layers	24	layer metadata and completion flags
subzero_layer	24	classifier accuracy and SV summary per layer
sae_features	0	not run

Key findings

1. The activation distribution has a populated middle

Across all 681,984 coordinates, activation rate spreads out rather than piling at the ends.

Band	Coordinates	Share
Rate ≤ 0.05	186,388	27.33%
Rate 0.05 to 0.90	371,162	54.42%
Rate ≥ 0.90	124,434	18.25%

More than half the model sits in the context-dependent middle, where a coordinate fires on some prompts and not others. That is where selectivity can live, and it is the largest population.

The taxonomy says it with four labels: partial_shared at 30.76%, non_activated at 27.33%, broadly_shared at 23.65%, all_shared at 18.25%.

2. Two components carry all the gating behavior, and the gate is the specialist

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

Component	Activation rate	Mean activation	Quiet coords	Mean F-stat
q	0.257	-1.1075	61.9%	42.8
gate	0.176	-0.0804	60.0%	50.2
linattn_z	0.563	-0.0033	33.0%	45.8
linattn_qkv	0.500	0.0020	27.3%	41.7
up	0.501	0.0012	13.6%	52.9
linattn_out	0.502	-0.0003	11.8%	46.0
mlp	0.500	0.0001	6.7%	36.8

Only q and gate show the pre-sigmoid signature of a gate: low firing rate and a strongly negative resting activation. linattn_z is nominally the value-path gate but does not behave like one here, sitting at a 0.563 firing rate with a resting activation of -0.0033 and 48.4% of its coordinates saturated. Whatever gating it performs is not visible as sparsity in this capture.

The gate is also the most selective component under code-analysis at 92.1% selective against 61.1% for k, it holds 65 of the 85 domain-specific directions the taxonomy resolved anywhere in the model, and it is the strongest logit-lens component at a mean F-stat of 257.1, running 1.72× the mlp path and 2.08× linattn_out.

3. Two of the eight query heads do almost no induction

Induction across the 48 head-circuits averages 0.753. Twelve circuits score below 0.5, and every one of them belongs to kv_head 0.

With only two KV groups, the split is stark:

KV group	Mean induction
0	0.594
1	0.913

Inside group 0 the split is by head index:

Head	Mean induction	Range
0	0.183	0.060 to 0.305
1	1.013	0.885 to 1.105
2	0.159	0.109 to 0.262
3	1.021	0.988 to 1.082

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

The same alternation appears in group 1 but much gentler, at 0.854 for even heads against 0.972 for odd. In group 0 the gap is 0.85.

The gentle even/odd alternation is small enough to be a property of how the metric interacts with head ordering. The collapse in group 0 is a different magnitude, reproduces in all six layers independently, and 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 needs an ablation this atlas does not have.

4. Induction is modest and does not vary much by layer

Layer	3	7	11	15	19	23
Mean induction	0.786	0.766	0.735	0.762	0.722	0.749

The spread from highest to lowest layer is 0.064, and the trend across depth is a mild decline. Only 34 of 48 head-circuits score above 0.8.

With six attention layers rather than a full stack, each one carries comparable copy-and-continue work rather than the job being handed to a specialist pair. The 18 linear-attention layers are invisible to this measurement, so this describes how the attention budget is spent and not how sequence mixing divides across the model.

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

5. The last attention layer's OV path collapses

Layer	OV effective rank	OV concentration	QK effective rank
3	90.6	0.041	30.5
7	80.9	0.057	46.1
11	96.3	0.050	32.5
15	82.9	0.049	25.8
19	86.9	0.030	20.8
23	38.4	0.130	23.0

Layer 23 runs its OV transform on 38.4 effective dimensions where every other attention layer uses between 80.9 and 96.3, and its spectral concentration is more than double the next highest. It is less than half the width of any other layer in the model on this measurement.

The QK path does not do the same thing. Layer 23 sits at 23.0, in line with layers 15 and 19, so the narrowing is specific to the value transform rather than to routing.

Across the whole table the OV path runs at 31.0% of the 256-dimensional head and QK at 11.6%. The final attention layer is doing a much lower-rank value transform than anything before it, which is what a layer that has stopped moving information around and started committing to an output looks like.

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

6. 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 separate the two factors:

Pair type	Pairs	Mean correlation
Matched coordinate, same group	791	0.920
Unmatched coordinate, same group	55	0.019
Unmatched coordinate, cross group	56	-0.275

Two heads in the same KV group, compared at the same within-head dimension, correlate at 0.920. Two coordinates in the same group that are not the same dimension sit at 0.019, essentially unrelated.

That is the control that matters. The redundancy is specific to matched coordinates and is not a general property of sharing a KV projection. Heads in a group run close to the same computation in the same coordinate frame.

The cross-group figure is negative at -0.275, but it rests on 56 pairs and should be read as directional rather than as a measured anti-correlation.

By component, heads is the most internally correlated at 0.791, then gate at 0.727, q at 0.578, and linattn_z at 0.481, while everything else sits within a few hundredths of zero.

7. Register separation peaks at layer 8 and decays through the back half

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

Layer	0	4	6	8	11	15	19	23
Mean F-stat	22.1	85.4	104.9	106.7	71.4	56.7	51.9	60.3

Layer 0 is the floor at 22.1. Separation climbs by a factor of 4.8 to a peak of 106.7 at layer 8, then falls through the rest of the network to a low of 51.9 at layer 19 before a small recovery.

By component the attention family leads at the projections and trails at the output:

Component	Mean F-stat	Max F-stat
k	80.5	1,083.8
v	77.5	881.3
up	75.2	1,396.9
linattn_z	75.1	1,081.4
gate	66.5	1,356.0
mlp	66.4	1,139.3
heads	61.1	1,222.6
attn	61.1	1,053.3

The key and value projections separate the two registers at roughly 1.3× the rate of the attention output. The single strongest direction is layer 6 linattn_qkv 1971 at 1,554.0, and eight of the ten strongest sit in layers 4 through 9, the same band where the layer-wise average peaks.

Only two components carry a directional lean, and both are mild: q splits 53.6% authentic-leaning and gate 51.7%. Every other component sits within a point of even.

8. The register direction is decodable at 98.4% everywhere

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

Statistic	Value
Mean classifier accuracy	0.984
Range across 24 layers	0.969 to 1.000

Accuracy is flat and high, and at least one layer separates the two conditions perfectly.

Set that against finding 7, where per-feature F-stat varies by a factor of nearly five across depth. The two do not conflict. A linear probe over the full residual width finds the register distinction at any layer; what changes with depth is how much of it has collected into individual coordinates.

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

9. The fence decision does not track damage

The surgery pass tested 108 DAS axes against five domains. 104 axes pass all five and 4 fail all five, with no axis splitting.

The two populations overlap on measured damage:

Statistic	Value
Worst peak damage among passing axes	0.1425
Mildest peak damage among failing axes	0.0368
Passing axes with peak damage above that mildest failure	15

Fifteen axes cleared the fence while doing more measured harm than an axis that was rejected. The worst passing axis, layer 12 gate_proj axis 0 at a peak of 0.1425, does roughly four times the damage of the mildest rejection.

frozen mirrors fence_passed exactly and adds no information, and no column in subzero_capability separates the groups. The atlas records the verdict without recording the criterion.

Damage is small throughout in absolute terms. The largest single measurement anywhere in the pass is 0.1748 nats per token, on layer 2 gate_proj axis 0, and mean damage across all 540 rows is 0.0144. By projection, gate_proj has the lowest pass rate at 84.2% and the highest mean damage at 0.0305; up_proj, down_proj, linattn_out_proj, and linattn_in_proj_qkv all pass at 100%.

Use damage to rank directions by measured harm and treat fence_passed on this run as a decision you cannot reconstruct. The failing population is 4 axes, which is thin enough that the pattern should be checked on a larger pass before it is leaned on.

10. The logit lens strengthens with depth, but F-stat does not predict readability

Layers	0-7	8-15	16-23
Mean F-stat	142.9	170.4	227.0

By component, gate leads at 257.1, then up at 198.6, heads at 159.2, mlp at 149.4, linattn_out at 123.6, and attn at 111.5.

Some features carry clean, coherent token families:

• Layer 18 gate 244 promotes classification, recognition, Classification, classify, Recognition, classifications, classifier
• Layer 14 up 3830 promotes manual, Manual, manual, manually, 手动, اليد, manuale, tying English, Chinese, Arabic, and Italian into one direction
• Layer 22 gate 2536 promotes cold, chilling, 冷, Cold, disturbed, disturbing, 黑暗
• Layer 16 gate 888 promotes coefficients, coefficient, coeff, Coeff
• Layer 21 gate 3914 promotes author, 历史和, 历史, 和历史, 历史上的, Histor, ист

Most of the top scorers are not like this. The single highest-scoring feature in the pass, layer 20 gate 257 at 555.2, promotes Blanca, circulation, kala, VT, èse, 待, #### with no shared theme, and several features scoring above 450 are similarly unreadable.

The practical consequence is narrow. A high logit-lens F-stat on this model does not mean the direction is interpretable, so read the token list before treating anything here as a steering target. The pass is a source of candidates, not a ranked list of them.

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.

The candidate stage retained 142 singular vectors across 23 of the 24 layers, and 108 axes reached the fence. Finding 9 describes those 108 and nothing else.

Important caveats

• fence_passed cannot be reconstructed from the damage columns, and finding 9 is the evidence. 15 axes cleared the fence while doing more measured harm than the mildest rejected axis. frozen mirrors fence_passed and adds nothing. Rank directions by damage; do not treat the pass/fail label as a damage threshold.
• The failing population is 4 axes. Every statistic about rejection in finding 9 rests on those four. The passing statistics are much better supported at 104.
• 142 singular vectors were retained but only 108 axes were fenced. Thirty-four retained directions have no subzero_capability rows and were never damage-tested.
• 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 18 of 24 layers mix sequence information through that path, a large share of the machinery is outside what this atlas sees.
• per_head reports 16 q heads for an 8-head model. q_proj is 4,096 wide because the attention output gate concatenates the query and its gate. The upper 8 rows per layer are gate coordinates, not query heads.
• model_meta.json is unpopulated. Every geometry field in it is null. The architecture table was derived from the source model config and cross-checked against component widths in the database.
• ov_circuits.compliance_score and ov_circuits.layer_comp_strength are NULL on all 48 rows. They carry no information for this run.
• induction_score is not bounded at 1. It exceeds 1.0 on 10 of 48 head-circuits and peaks at 1.105.
• coactivation stores a selected subset of feature pairs, not a full census. Finding 6 rests on 902 head pairs, and both control cells hold only 55 and 56 pairs. Treat those contrasts as directional, particularly the negative cross-group figure. The redundancy result is correlational, a merging signal rather than proof that removal is free, which would need a fenced ablation run.
• Only 85 domain-specific directions resolved out of 681,984 features, 65 of them in gate, spread across layers 4 through 22. The corpus buckets are general-purpose categories. Read that as a statement about what a general-purpose corpus can see before reading it as a statement about the model.
• linattn_z does not behave like a gate in this capture. It carries a near-zero resting activation and a 0.563 firing rate. Whether that reflects the component's role or something about how it was captured is not answerable from this atlas alone.
• Only six full-attention layers exist, so findings 3, 4, 5, and 6 rest on 48 head-circuits total. Per-layer attention statistics have six points behind them.
• Coactivation buckets describe the prompt mix. Dominant buckets come out business at 18.2% and introspection at 8.6%, with 29.4% carrying no bucket at all. Those proportions reflect the corpus and the pair-selection step.
• 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 24-layer, 1,024-wide vision encoder and one multi-token-prediction layer. The text-only load path drops both.
• 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 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 18 linear-attention layers × 28,672 coordinates plus 6 full-attention layers × 27,648.

import sqlite3
import pandas as pd

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

# only two components in here actually gate: which ones, and how hard?
df = pd.read_sql_query("""
    SELECT component,
           ROUND(AVG(activation_rate), 4) AS act_rate,
           ROUND(AVG(mean_act), 4)        AS resting,
           ROUND(100.0*AVG(activation_rate <= 0.05), 2) AS pct_quiet
    FROM features
    GROUP BY component
    ORDER BY act_rate
""", 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 last attention layer stops spreading its value transform
SELECT layer_id,
       ROUND(AVG(ov_eff_rank), 1)      AS ov_rank,
       ROUND(AVG(ov_spectral_conc), 3) AS ov_conc,
       ROUND(AVG(qk_eff_rank), 1)      AS qk_rank
FROM ov_circuits
GROUP BY layer_id
ORDER BY layer_id;

License

Apache 2.0, matching the source model.

Contact / more

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