cls-dep-relation: probes for dependency relation (30 classes, UD English EWT)

Linear probes of the NeurIPS 2026 paper Geometrically Disentangling Concept Learning from the Language Modeling Loss (Wang, Mallinar, Belkin, Warstadt) for the task DependencyRelation (dep_relation 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 softmax classifier, nn.Linear(d, K) with bias, trained with cross-entropy. 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 word type gets one fixed random label, drawn with the class shares of the real training labels, so the control labels follow word identity rather than the concept. Score: test accuracy; a control probe is scored on its own control labels.

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

UD English EWT v2.17, every non-punctuation word; label: relation to the head with the subtype stripped. The official training and test splits are used, keeping the sentences with at least 4 tokens, at least 2 of them containing a letter, and no URL-like token. Classes with at least 100 training and 10 test words are kept: K = 30; train: 176,696 words (10,765 sentences); test: 20,691 words (1,585 sentences). Every word is read at its last sub-word token, with its whole sentence as context (one forward pass per sentence, batches of 32 sentences; model inputs are truncated to 256 tokens, beyond which no probed word lies).

Centering

Inputs: the mean of the layer's training representations (float64) is subtracted from the training and test inputs (input_mean).

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, 30, d]	float32	probe weights
b	[layers, 6, 30]	float32	probe biases
input_mean	[layers, d]	float64	mean subtracted from the inputs

The class names, in the order of axis 2, are in the file metadata (classes).

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 test accuracy, on the control labels for a control probe; 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/cls-dep-relation', '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']

classes = json.loads(meta['classes'])                 # K class names, the order of axis 2 of W
layer, run = 8, runs.index('real_1001')
W = arrays['W'][layer, run].astype(np.float64)            # [K, d]
k = len(classes) - 1                                      # top K - 1 right singular vectors of the class-centered weights
U = np.linalg.svd(W - W.mean(0), full_matrices=False)[2][:k].T
oe = np.log2(G.shape[0] * np.trace(U.T @ G @ U) / (k * 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 sub-word token of each word, with its whole sentence as context:

x = (h.astype(np.float64) - arrays['input_mean'][layer]).astype(np.float32)    # centering as in training
logits = x @ arrays['W'][layer, run].T + arrays['b'][layer, run]                 # [n, K]
predicted = [classes[i] for i in logits.argmax(-1)]

License and attribution

Derived from UD English EWT v2.17 (CC BY-SA 4.0; text from the English Web Treebank) 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}
}