reg-bigram-log-prob: probes for bigram log probability (WikiText-103)

Linear probes of the NeurIPS 2026 paper Geometrically Disentangling Concept Learning from the Language Modeling Loss (Wang, Mallinar, Belkin, Warstadt) for the task BigramLogProb (bigram_lp in the code at https://github.com/YpLarryWang/concept-energy). These are the probes behind the paper's numbers. They are part of the disentangle-concept-learning release: one dataset of AGOP matrices (agop) and one dataset of probes for each of the paper's 12 tasks (cls-*, reg-*).

At every layer and checkpoint there are 3 real probes and 3 control probes. The paper's Concept Energy (CE) is the mean Optimization Engagement (OE) of the real probes with the AGOP of the same layer and checkpoint minus the mean OE of the control probes, and its decodability (selectivity) is the mean score of the real probes minus the mean score of the control probes. probes.csv gives the OE and score of every probe.

Probes

Linear regression, nn.Linear(d, 1) with bias, trained with mean squared error. Per layer and checkpoint: 3 real probes (seeds 1001-1003) and 3 control probes (label seeds 42-44, probe seeds 4042-4044). The control task follows Hewitt and Liang (2019): every n-gram type gets a target drawn at random from the token-level targets of the same set (training or test), so the control targets follow n-gram identity rather than the statistic. Score: held-out $R^{2}R^2$ on the test set (baseline: the test-set mean); a control probe is scored on its own control targets.

Language models

Pythia-410M (24 layers, hidden size 1024) and Pythia-1B (16 layers, hidden size 2048), at 19 checkpoints: steps 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1000, 2000, 4000, 8000, 16000, 32000, 64000, 128000 and 143000. Layer L is the output of transformer block L, before the final layer norm. Layers are numbered from 0 (0-23 for Pythia-410M, 0-15 for Pythia-1B); the paper's figures number them from 1, so layer 8 here is layer 9 there.

Data

Target, in natural log:

$$y=\log p(w_t\mid w_{t-1})y\; =\; \backslash log\; p(w\_t\; \backslash mid\; w\_\{t-1\})$$

Counts come from WikiText-103 (wikitext-103-v1: train, validation and test) with the Pythia tokenizer, unsmoothed: unigram counts over all non-empty, URL-free lines (117,342,850 tokens); bigram and trigram counts within the lines that pass the sentence filter (at least 4 tokens, 2 of them with a letter, no URL; 115,466,924 bigram positions).

Probe samples come from 20,000 filtered WikiText-103 lines outside the AGOP corpus, each truncated to 256 tokens. The probe reads the last token $w_{t}w\_t$ of the n-gram, with its line as context (one forward pass per line, batches of 32 lines). This task reads the first 50,000 token positions, from the first 456 lines. The training and test sets are split by bigram type: the bigram types that occur at least twice among these positions are shuffled (seed 42), and 80% of them go to the training set and the rest to the test set, so no test bigram occurs in training; bigrams that occur only once are not used. Test bigrams are then dropped unless their first token also occurs as the first token of some training bigram and their last token as the last token of some training bigram. This leaves 16,685 training samples and 2,815 test samples.

Centering

Inputs: the training-set mean of the layer's representations (float64) is subtracted from all inputs (input_mean).

Targets: each run's targets (real or control) are centered by their own training-set mean (target_offset); held-out $R^{2}R^2$ is computed on the centered targets.

Training

Adam (learning rate 1e-3, weight decay 1e-4 on weights and bias, default betas), batch size 256, 10 epochs; the weights after the last epoch are kept. The weights start from the PyTorch default initialization, and the probe seed fixes both the initialization and the shuffling order.

Precision

The language model runs in float16. Its block outputs are cast to float32, centered in float64 and cast back to float32. Probes are trained in float32 on a GPU, and W and b are stored in float32 without rounding.

Files

pythia-410m/step<checkpoint>.safetensors     all 24 layers of one checkpoint
pythia-1b/step<checkpoint>.safetensors       all 16 layers of one checkpoint
probes.csv                                   one row per probe: model, checkpoint, layer, run, seed, init_seed, k, oe, score, score_kind
PROVENANCE.json                              format version, and the SHA-256 of the AGOP file used for each layer and checkpoint
SHA256SUMS

Each safetensors file holds:

key	shape	dtype	content
W	[layers, 6, 1, d]	float32	probe weights
b	[layers, 6, 1]	float32	probe biases
input_mean	[layers, d]	float64	mean subtracted from the inputs
target_offset	[layers, 6]	float64	mean subtracted from each run's targets

Axis 1 is the run, listed in the metadata (runs): real_1001, real_1002, real_1003, control_42, control_43, control_44. The metadata also gives the format version (schema).

In probes.csv, run is real or control, seed is the probe seed of a real probe and the label seed of a control probe, init_seed is the seed of the probe's initialization and shuffling order, k is the dimension of the probe's subspace, oe is its OE in bits, and score is its held-out $R^{2}R^2$ on the test set; score_kind names the score.

Usage

Read one checkpoint and compute the Optimization Engagement (OE) of one probe with the AGOP of the same model, checkpoint and layer (repo disentangle-concept-learning/agop). No language model is needed:

import json
import numpy as np
from huggingface_hub import hf_hub_download
from safetensors import safe_open
from safetensors.numpy import load_file

path = hf_hub_download('disentangle-concept-learning/reg-bigram-log-prob', 'pythia-410m/step512.safetensors', repo_type='dataset')
arrays = load_file(path)
with safe_open(path, 'np') as f:
    meta = f.metadata()
runs = meta['runs'].split(',')
G = load_file(hf_hub_download('disentangle-concept-learning/agop', 'pythia-410m/step512.safetensors', repo_type='dataset'))['layer8']

layer, run = 8, runs.index('real_1001')
w = arrays['W'][layer, run, 0].astype(np.float64)         # [d]; k = 1: the normalized weight vector
oe = np.log2(G.shape[0] * (w @ G @ w) / (w @ w) / np.trace(G))

oe equals the oe column of probes.csv for this probe (model pythia-410m, checkpoint 512, layer 8, run real, seed 1001).

Apply the probe to block-8 outputs h (float32, one row per item, 1024 columns) of Pythia-410M at step 512, read at the last token of each n-gram in its WikiText-103 line:

x = (h.astype(np.float64) - arrays['input_mean'][layer]).astype(np.float32)    # centering as in training
centered = x @ arrays['W'][layer, run, 0] + arrays['b'][layer, run, 0]         # [n], prediction of the centered target
prediction = centered + arrays['target_offset'][layer, run]                     # in nats, like the target

License and attribution

Derived from WikiText-103 (text from Wikipedia, CC BY-SA 3.0) and the Pythia models (Apache-2.0). We release the probes under CC BY-SA 4.0.

Please cite:

@inproceedings{wang2026geometrically,
  title     = {Geometrically Disentangling Concept Learning from the Language Modeling Loss},
  author    = {Wang, Yupei and Mallinar, Neil and Belkin, Mikhail and Warstadt, Alex},
  booktitle = {Advances in Neural Information Processing Systems},
  year      = {2026}
}