replicaverse/replica-predictors

REPLICA predictor store

Per-unit predictors for computational models of human sentence processing: surprisal, several entropies, similarity-adjusted surprisal, information value and unigram surprisal, scored by language models over reading corpora (eye tracking, self-paced reading, maze, N400). Every row names the text unit it describes and the unit its number is in.

dataset	tag	predictor	stimulus_id	unit_index	text_unit	value	value_unit	layer	storage_class	unit_rule
provo	gpt2_surprisal_provo	surprisal	provo_1	4	Apple	8.4213	bits	1	positional

Start from tags.parquet: one row per (tag, predictor, file), with the model, method, configuration, storage class, layer and provenance of every cell decoded, so a cell can be found by model, method and configuration.

• 2,596 cells across 58 corpora, 280,030,555 scalar rows
• 25 methods, 26 models and frequency tables

Layout

path	contents
tags.parquet	the cell index: one row per (tag, predictor, file)
coverage.parquet	one row per planned or produced table with its status
history.parquet	first-publish and last-change commit of every file
<dataset>.parquet	word-grain scalar predictors of one corpus
tokens/<dataset>.parquet	token-grain scalar predictors of one corpus
characters/<dataset>.parquet	character-grain scalar predictors of one corpus
responsivity/<tag>.parquet	embedding-distance word predictors, one file per cell
lens_layers/<tag>.parquet	per-layer log-probability vectors of the lens cells, one file per cell
mcword_samples/, cont_entropy_samples/	per-unit Monte Carlo sample pools behind the entropy cells
next_log_probs/	the next-position distribution over word types at each scored word
simadj_esim/	per-unit expected-similarity arrays behind the similarity-adjusted cells
fwd_word_lookahead_entropy_samples/	look-ahead entropies at depths 1..K and the per-sample step log probabilities
manifests/<tag>.json	the compute driver's provenance sidecar of every exported cell
verification/<wave>.json	per-table verification records of one recompute wave
owt/, modelblocks_kenlm_models/, kenlm_o1/	frequency tables the unigram cells read
pool/, pool_s900000/, pool_tokens/, pool_tokens_s900000/	the marginal sample pools earlier releases published

Layers

Layer 1 holds the predictors REPLICA computes under its own conventions. Layer 2 holds a released defect reconstructed for one study; the study column of the index names it. Cells published before the layer field existed carry the layer of their method.

layer	cells
1	2507
2	63
null	26

method	study	cells
continuation_entropy_buggy	giulianelli2024generalized	1
modelblocks_surprisal	clark2025wordentropy	28
wordsprobability_surprisal_buggy	pimentel2024probability	34

Storage classes and units

A positional estimator conditions on a prefix ending at a token position and returns a value for that position; its cell is stored per token under tokens/ and any coarser unit derives from the token table. A unit_bound estimator takes the unit as an input, so its cell is stored at the unit it was computed for and unit_rule names the boundary rule the estimator used (whitespace_continuation is the model's own notion of a word: a token sequence that continues until the next whitespace-initial token). unit is the grain of the rows: words, tokens or characters. A carried cell whose method the compute driver no longer accepts has null storage columns.

storage_class	unit	cells
null	words	26
positional	characters	15
positional	tokens	429
positional	words	1253
unit_bound	words	873

unit_rule	cells
spacy_sentence	26
whitespace_continuation	395

Word values derived from token tables

410 word cells are aggregated from a token table of the same model and corpus; derivation_source names that table's tag and the cell's manifest records the aggregation. A word takes the tokens whose spans nest inside its span; a token that would have to be split, dropped or interpolated stops the derivation. Log probabilities sum over the word's tokens and the summed value is also stored as surprisal in bits; an entropy or distance takes the value at the word's first token. A corpus without word spacing derives word surprisal from the char_beam character table instead.

method	rule	derived cells
char_beam	sum	2
continuation_entropy	first	77
first_token_entropy	first	40
logit_lens_surprisal	sum	88
responsivity	first	36
similarity_surprisal_contextual	sum	2
similarity_surprisal_noncontextual	sum	10
surprisal	sum	60
token_renyi_entropy	first	95

Row schemas

Word and character tables, and the responsivity/ files:

column	type	meaning
dataset	string	corpus, also the file name of the per-corpus tables
tag	string	cell id: model, method and configuration
predictor	string	value key, e.g. surprisal
stimulus_id	string	stimulus within the corpus
unit_index	int32	0-based position of the unit within the stimulus
text_unit	string	the unit as the corpus loader spells it: the word, or the character; null when the stored unit count of the stimulus differs from the corpus
value	double	the number; NaN where undefined
value_unit	string	nats, bits, dimensionless or tokens
layer	int32	1 or 2, see Layers
storage_class	string	positional or unit_bound, see Storage classes
unit_rule	string	boundary rule of a unit-bound estimator; null for a positional one

Token tables (tokens/<dataset>.parquet):

column	type	meaning
dataset, tag, predictor, stimulus_id, value, value_unit		as above
token_index	int32	0-based position of the token within the stimulus
span_start, span_end	int32	character offsets of the token in the stimulus text
token_id	int64	vocabulary id under the cell's tokenizer
token	string	the token string as the tokenizer spells it

Array files carry dataset, tag, stimulus_id, unit_index, one or more list columns whose unit is in the column's Parquet field metadata, and value_unit. A word-grain file adds text_unit; a token-grain file adds the token identity columns instead.

Index (tags.parquet) columns beyond the row schema: file (where the rows live), model, model_kind (lm or frequency_table), method, n_stimuli, n_rows, the configuration (alpha, n_samples, max_tokens, beam_width, max_words, seed), the realization (provenance, chunk_size, device, cuda, torch, transformers, python, replica, code_commit, code_dirty, source_sha256, model_revision, computed_at), and the storage columns layer, study, storage_class, unit, unit_rule, context_scope, derivation_source, wave, verification, verification_file.

Verification

Each recompute wave was checked table by table against the corpus loader's unit grid and, where a released or independently recomputed value exists, against that value. The records live in verification/<wave>.json; the index carries each cell's verdict in verification and the file in verification_file. pass means no flag was raised; check means at least one flag names something to look at, listed in the record's flags. A flag that begins manifest describes the sidecar the producing commit wrote, so it names a field that commit predates; the index columns are filled from the tag and the method and stay complete. A cell without a record has a null verdict.

file	verdict	cells
verification/wave1-tokens.json	check	406
verification/wave1-tokens.json	pass	6
verification/wave2.json	check	269
verification/wave2.json	pass	626

flag	tables
manifest identity lacks storage_class	405
manifest layer is None	405
words empty or containing whitespace	274
context scope story (layer 1 conditions on the whole stimulus)	49
BOS disabled	42
context scope story	28
context scope sentence (layer 1 conditions on the whole stimulus)	14
unit characters	9
manifest lacks the window rule	8
manifest sampling block does not record positions: all	8
manifest sampling block records no seed	8
context scope sentence	7
token spans differ from the independent tokenization	7
NaN beyond the first token	7
NaN beyond the first word	4
unexpected producer commit	2
non-finite values	2
independent per-token recomputation differs by 0.0017	1
stimuli whose stored words differ from re-aggregating gpt2_simadj_surprisal_noncontextual_tokens_sbsat.pkl	1
stimuli whose stored words differ from re-aggregating gpt2_simadj_surprisal_noncontextual_tokens_zuco1.pkl	1

Coverage and gaps

coverage.parquet has one row per planned (method, model, corpus, unit) table and one per produced table no plan names. status is exported when the table comes from the latest release, carried when the store ships it from an earlier one, quarantined when the compute driver refused to publish it (a stimulus failed or the values failed an audit) and the store has no earlier table, and absent when the store has none. reason_class is the plan's class for the table, one of complete, excluded_by_decision, expected_refusal, held_decision, known_gap_beam_empty, missing, running. expected_refusal is a whitespace-word estimator on a corpus whose words are not the model's words, and known_gap_beam_empty is a character beam that emptied on a stimulus. detail holds the failure log of a quarantined table or the command of an absent one.

status	tables
absent	1
carried	43
exported	1309
quarantined	5

status	reason_class	tables
absent	held_decision	1
carried	excluded_by_decision	1
carried	expected_refusal	6
carried	held_decision	24
carried	known_gap_beam_empty	2
carried	missing	8
carried	running	2
exported	complete	855
exported	expected_refusal	2
exported	not planned	452
quarantined	held_decision	5

quarantined method	tables
modelblocks_surprisal	1
wordsprobability_surprisal	2
wordsprobability_surprisal_buggy	2

What changed in this release

Built on the published store at commit 2508a73d9431d94a3b776ced13c3fc44f49d9427; every published cell this release does not replace is carried over unchanged.

wave	cells exported
wave1-tokens	412
wave2	895

• 825 published cells replaced by a recomputed table of the same tag
• 0 published files deleted because their cell was recomputed without the array they held
• 1895 files written
• new: tokens/ (token-grain tables), characters/ (character-grain tables), coverage.parquet, verification/, and the storage columns of the word tables and the index
• array keys without a store folder, left in the pickles only: orth_similarity_samples, pos_match_samples, sampled_words, similarity_samples_tokens

Carried cells on an older unit grid

133 cells this release carries were computed against an earlier version of their corpus, so their stimulus_id and unit_index do not line up with the cells this release stages into the same table. Join them to a recomputed predictor only after checking the units match. tags.parquet gives each cell's n_stimuli and n_rows, and a recomputed cell of the same corpus gives the current shape.

table	cells on an older grid
dundee.parquet	20
meco_de.parquet	2
meco_ee.parquet	7
meco_fi.parquet	5
meco_gr.parquet	6
meco_it.parquet	5
meco_l1_w2_ch_s.parquet	6
meco_l1_w2_ch_t.parquet	6
meco_l2_w2.parquet	10
meco_tr.parquet	5
onestop.parquet	17
provo.parquet	15
sbsat.parquet	20
szewczyk_n400.parquet	9

Loading

import pandas as pd

REPO = "hf://datasets/replicaverse/replica-predictors"
idx = pd.read_parquet(f"{REPO}/tags.parquet")
provo = pd.read_parquet(f"{REPO}/provo.parquet")
cell = provo[provo.tag == "gpt2_surprisal_provo"]
tokens = pd.read_parquet(f"{REPO}/tokens/provo.parquet")

Values from different models are on different scales and vocabularies; compare within a model.