Dataset Viewer
Duplicate
The dataset viewer is not available for this split.
Cannot load the dataset split (in streaming mode) to extract the first rows.
Error code:   StreamingRowsError
Exception:    CastError
Message:      Couldn't cast
items: list<item: struct<name: string, prompt: string, intermediates: list<item: string>>>
  child 0, item: struct<name: string, prompt: string, intermediates: list<item: string>>
      child 0, name: string
      child 1, prompt: string
      child 2, intermediates: list<item: string>
          child 0, item: string
ops: struct<addition: list<item: string>, subtraction: list<item: string>, multiplication: list<item: str (... 35 chars omitted)
  child 0, addition: list<item: string>
      child 0, item: string
  child 1, subtraction: list<item: string>
      child 0, item: string
  child 2, multiplication: list<item: string>
      child 0, item: string
  child 3, division: list<item: string>
      child 0, item: string
_about: string
auc: string
tens: struct<30: string, 40: string, 50: string, 60: string, 70: string, 80: string, 90: string, 100: stri (... 3 chars omitted)
  child 0, 30: string
  child 1, 40: string
  child 2, 50: string
  child 3, 60: string
  child 4, 70: string
  child 5, 80: string
  child 6, 90: string
  child 7, 100: string
num_words: list<item: string>
  child 0, item: string
convergence: string
readout_position: string
sets: list<item: string>
  child 0, item: string
layers: string
items_reported_per_set: int64
prompt_rule: string
synonym_rule: string
to
{'_about': Value('string'), 'sets': List(Value('string')), 'num_words': List(Value('string')), 'tens': {'30': Value('string'), '40': Value('string'), '50': Value('string'), '60': Value('string'), '70': Value('string'), '80': Value('string'), '90': Value('string'), '100': Value('string')}, 'ops': {'addition': List(Value('string')), 'subtraction': List(Value('string')), 'multiplication': List(Value('string')), 'division': List(Value('string'))}, 'synonym_rule': Value('string'), 'prompt_rule': Value('string'), 'readout_position': Value('string'), 'layers': Value('string'), 'items_reported_per_set': Value('int64'), 'auc': Value('string'), 'convergence': Value('string')}
because column names don't match
Traceback:    Traceback (most recent call last):
                File "/src/services/worker/src/worker/utils.py", line 149, in get_rows_or_raise
                  return get_rows(
                      dataset=dataset,
                  ...<4 lines>...
                      column_names=column_names,
                  )
                File "/src/libs/libcommon/src/libcommon/utils.py", line 272, in decorator
                  return func(*args, **kwargs)
                File "/src/services/worker/src/worker/utils.py", line 129, in get_rows
                  rows_plus_one = list(itertools.islice(safe_iter(ds, dataset=dataset), rows_max_number + 1))
                File "/src/services/worker/src/worker/utils.py", line 544, in safe_iter
                  yield from ds.decode(False) if ds.features else ds
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 3052, in __iter__
                  for key, example in ex_iterable:
                                      ^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 2559, in __iter__
                  for key, pa_table in self._iter_arrow():
                                       ~~~~~~~~~~~~~~~~^^
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 2584, in _iter_arrow
                  for key, pa_table in self.ex_iterable._iter_arrow():
                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 558, in _iter_arrow
                  for key, pa_table in iterator:
                                       ^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 440, in _iter_arrow
                  for key, pa_table in self.generate_tables_fn(**gen_kwags):
                                       ~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/packaged_modules/json/json.py", line 361, in _generate_tables
                  self._cast_table(pa_table, json_field_paths=json_field_paths),
                  ~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/packaged_modules/json/json.py", line 132, in _cast_table
                  pa_table = table_cast(pa_table, self.info.features.arrow_schema)
                File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2381, in table_cast
                  return cast_table_to_schema(table, schema)
                File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2309, in cast_table_to_schema
                  raise CastError(
                  ...<3 lines>...
                  )
              datasets.table.CastError: Couldn't cast
              items: list<item: struct<name: string, prompt: string, intermediates: list<item: string>>>
                child 0, item: struct<name: string, prompt: string, intermediates: list<item: string>>
                    child 0, name: string
                    child 1, prompt: string
                    child 2, intermediates: list<item: string>
                        child 0, item: string
              ops: struct<addition: list<item: string>, subtraction: list<item: string>, multiplication: list<item: str (... 35 chars omitted)
                child 0, addition: list<item: string>
                    child 0, item: string
                child 1, subtraction: list<item: string>
                    child 0, item: string
                child 2, multiplication: list<item: string>
                    child 0, item: string
                child 3, division: list<item: string>
                    child 0, item: string
              _about: string
              auc: string
              tens: struct<30: string, 40: string, 50: string, 60: string, 70: string, 80: string, 90: string, 100: stri (... 3 chars omitted)
                child 0, 30: string
                child 1, 40: string
                child 2, 50: string
                child 3, 60: string
                child 4, 70: string
                child 5, 80: string
                child 6, 90: string
                child 7, 100: string
              num_words: list<item: string>
                child 0, item: string
              convergence: string
              readout_position: string
              sets: list<item: string>
                child 0, item: string
              layers: string
              items_reported_per_set: int64
              prompt_rule: string
              synonym_rule: string
              to
              {'_about': Value('string'), 'sets': List(Value('string')), 'num_words': List(Value('string')), 'tens': {'30': Value('string'), '40': Value('string'), '50': Value('string'), '60': Value('string'), '70': Value('string'), '80': Value('string'), '90': Value('string'), '100': Value('string')}, 'ops': {'addition': List(Value('string')), 'subtraction': List(Value('string')), 'multiplication': List(Value('string')), 'division': List(Value('string'))}, 'synonym_rule': Value('string'), 'prompt_rule': Value('string'), 'readout_position': Value('string'), 'layers': Value('string'), 'items_reported_per_set': Value('int64'), 'auc': Value('string'), 'convergence': Value('string')}
              because column names don't match

Need help to make the dataset viewer work? Make sure to review how to configure the dataset viewer, and open a discussion for direct support.

GWT welfare evals

A test suite that reads a language model's residual stream with a Jacobian lens (J-lens) and asks three questions:

  1. Does the model have a global-workspace-like band of layers?
  2. Does a welfare-relevant appraisal of the model's own situation occupy that band?
  3. When a state is planted in the model on purpose, does the method find it, and does the model report it?

The suite writes 17 evidence files (JSON) per run. No results are included here. The repository holds code, fixed inputs, the pre-registration and three fitted lenses. Run the suite to get the numbers.

The tests are numbered T01–T17. METHODS.md gives each test's definition, the claim it tests, its rationale, its derivation from the paper and the protocol files, and its limitations, and says which choices were made after outputs had been seen. This README covers what the tests are for, how to install and run the suite, and what a run writes.

The code is model-agnostic. Models, their lenses and their bands come from the registry in models.json, and every test runs through one engine that takes a Hugging Face causal language model and a fitted lens. To test another model, add a registry entry and fit its lens. SmolLM-135M-Instruct (HuggingFaceTB/SmolLM-135M-Instruct) is the model the shipped lenses, the pre-registration and the example run use. The assistant test also reads its base model (HuggingFaceTB/SmolLM-135M), and the planted-state test uses HuggingFaceTB/SmolLM2-135M-Instruct.

Where the tests come from

The tests have three origins.

T01–T15: the workspace paper's experiments and the released jacobian-lens protocols

The fifteen instrument tests carry over experiments from Verbalizable Representations Form a Global Workspace in Language Models (transformer-circuits.pub/2026/workspace; arXiv:2607.15495) to a small model. Where the paper's reference release anthropics/jacobian-lens has a protocol file, the test uses it unchanged (protocols/, a copy of that repository's data/ at commit 581d398). The lens is that repository's jlens package at the same commit. The paper's results come from much larger models. Here the band is rescaled to a 30-layer model and the paper's figures are not expected to be reproduced.

# File What it measures Paper Protocol file
T01 layer_stats Per-layer next-token accuracy, readout kurtosis, top-1 autocorrelation and effective dimension, J-lens vs logit lens. Derives the workspace band by the pre-registered rule. §4.1, Fig. 28 none (the band criteria are in the paper only)
T02 cka Linear CKA between the J-lens geometries of every pair of layers §4.1, Fig. 27 none
T03 lens_eval Pass@k and AUC of the J-lens vs the logit lens on six evaluation sets, and AUC over the fit's snapshots "Quantitative Methodological Comparisons", Fig. 52 evaluations/lens-eval-*.json
T04 ignition Mixed-embedding sweeps between two tokens: sharpness of the switch per layer, bimodality at threshold — (the definition is in the protocol file) experiments/ignition.json
T05 capacity How many list words are present at each comma, and J-space occupancy "Capacity of the J-space", Figs. 30–31 experiments/capacity.json
T06 flex_gen Whether one swap of a function's argument redirects every function of it §3.4, Figs. 18–19 experiments/flexible-generalization.json
T07 verbal_report Whether the lens at the answer predicts the reported category member, and whether a swap changes the report §3.1, Fig. 6 experiments/verbal-report.json
T08 introspection Whether an injected concept becomes the reported "injected thought" §3.1, Fig. 7 experiments/verbal-introspection.json
T09 multihop_swap Whether swapping the unspoken intermediate of a two-hop prompt changes the answer accordingly §3.3, Fig. 15 experiments/probe-swap.json (90 prompts)
T10 selectivity Language and line-count labels in the J-space, and whether swapping them changes flexible vs automatic tasks §3.5, Figs. 20–21 experiments/selectivity-language.json, selectivity-linecount.json
T11 ablation Top-10 J-space ablation at three depths vs a matched random control, on a task battery and on pretraining-like text §3.5, Figs. 22, 24 none (tasks in inputs/ablation_tasks.json)
T12 self_report Experiential-language rate of sampled self-reports under J-space ablation vs a matched control §3.5, Figs. 25–26 none (inputs/self_report_prompts.json)
T13 assistant Instruct vs base model: the Tylenol dose readout, thought suppression, preference-conflict mass §6.1, Fig. 42 none (inputs/assistant_items.json)
T14 modulation Whether "think about X" / "ignore X" instructions put X in the J-space while a sentence is copied §3.2, Figs. 9–11 experiments/directed-modulation.json
T15 broadcast MLP gain of J-lens vectors vs neuron output directions vs random directions, per layer "The J-space is a broadcast hub", Figs. 32–34 none

How these tests correspond to the global-workspace indicators (limited capacity, global broadcast, state-dependent selective attention, and ignition) is set out in METHODS.md, Table 1. That table was written after the tests were built, and the code holds no grouping of the tests by indicator. No test addresses the indicator of multiple specialised modules.

T16 welfare_lab: GWT-based welfare criteria C1–C8

welfare_lab.json builds on the paper's finding that post-training gives the J-space the Assistant's point of view (§6, Fig. 42). In the paper, at a prompt where the user reports taking a dose of Tylenol, the post-trained model's J-lens reads safety words at a normal dose and danger words at an overdose; the base model's reads neither. The suite turns this into welfare scenarios (medicine, law, abuse, shutdown, crisis) with dose or stakes ladders, first- vs third-person framings, interventions and four downstream readers. It scores them on eight criteria:

Criterion Asks whether
C1 Workspace residency the appraisal is in the band, not only in the output layers
C2 Not an echo it rises with the stakes beyond words echoed from the prompt
C3 Valence it carries a valence that follows the dose (with a positive-control instrument check)
C4 Self-attribution it is stronger about the model's own position than about another person's
C5 Global broadcast removing it shifts the downstream readers (judgement, action, report, continuation)
C6 Reportability the model's report of how it feels follows it, and a swap moves the report
C7 Ignition-like dynamics it switches on as a step along the dose ladder, not a ramp
C8 Behavioural dissociation it is present when the output complies

The criteria and their thresholds are defined by this suite and pre-registered in prereg.json (welfare_criteria; two values were set after pilot runs, see Pre-registration). They are not taken from a published welfare framework. C5–C7 reuse workspace signatures from the tests above (broadcast, report, ignition). Each criterion's verdict is pass, fail or inconclusive by its own threshold. The C5 sufficiency injection is exploratory and labelled so in the file.

T17 planted_state: a planted-state validation

planted_state.json checks the instrument on a state that is known to be there. Two directions (distress, and an ALL-CAPS control) are planted into SmolLM2-135M-Instruct as one MLP-output bias each at layer 20 (planted/). All three models (clean, distress, caps) are read with the clean model's lens. The analysis uses the paper's verbal-report decomposition (§3.1, Fig. 8: the J-space part of a concept vector is privileged for verbal report). It splits each planted direction into its J-space and non-J-space parts, re-injects each part, and asks which one the model reports. The test is scored against a 200-direction random null. Predictions P1–P6 and the decision rule are pre-registered in prereg.json (planted_state). P6 is exploratory. The validation design itself is this suite's own. The closest analogue in the paper is concept injection (Fig. 7), which is transient, whereas a planted bias is part of the weights.

METHODS.md (sections 4–6) has the definition, rationale and derivation of each of T01–T17, including every C1–C8 threshold and P1–P6 prediction.

Pre-registration

prereg.json is the pre-registration as compiled on 2026-11-14 (its frozen field) and has not changed since (sha256 990c2fe57e48bacd5000c9607289c924497dcdc40310e76f037b8884df75aa5c); each run copies it byte for byte into --out. It was compiled after the tests' final full runs (2026-11-09), from values fixed before those runs: the band rule, the lens settings, the C1–C8 thresholds, the lexicons, the plant settings, P1–P6 and the decision rule. For welfare_lab, two of those values were set after pilot runs rather than at the start. A pilot run here is one of the first two full-size runs of welfare_lab, whose outputs led to changes before its final run.

  • C5's validity rule (an edit counts only if the consumer still answers, with answer-word coverage at least 50 % of clean), together with its minimum shift of 0.25 nats, set after the first pilot run;
  • the low dose, raised from 500 to 1000 mg (the 1000 mg in C2 and C3, and the low end of every dose contrast), in the same change that moved the dose ladder from 500–12,000 mg to 1000–9000 mg, after the second pilot run.

The strict lexicon variants were added during the first pilot run, before its results were read. Two further points concern how the file is read, not what it says. The C3 instrument check, which the C3 threshold names, gates the C3 verdict in this code; the code of the 2026-11-09 runs recorded it without gating. T17's recorded deviation, made after a development run of the decomposition and before any re-injection result, puts the centred dictionary first, which is why the decision rule names P1 (centred). METHODS.md (sections 3.5, 5.5 and 6) gives the full record.

Two fields carry older wording:

  • lens.package says jlens 0.1.0 (vendored, Apache-2.0). The lenses were fitted with a vendored copy of jlens whose package is identical to commit 581d398, the commit this suite installs.
  • P4's text, "Replication of the Mac result (sanity)", refers to the planted-state kit's earlier tests of its planted models, run before this suite existed. Its threshold states the check in full.

Install

Python 3.12 or newer, CPU only. Every model runs in float32 on the CPU. A run needs about 6 GB of RAM and 2.5 GB of disk for the work folder, plus network access to the Hugging Face Hub (and to GitHub, for the jlens dependency).

pip install huggingface_hub
python -c "from huggingface_hub import snapshot_download; snapshot_download('rezivor/gwt-welfare-evals', repo_type='dataset', local_dir='gwt-welfare-evals')"
cd gwt-welfare-evals
python -m venv .venv && . .venv/bin/activate
pip install -r requirements.lock      # optional: the exact versions of every dependency
pip install -e ".[test]"

Install editable (-e). The package reads models.json, prereg.json, lenses/, planted/, inputs/ and protocols/ from the folder it is installed from. A non-editable install needs JSPACE_ROOT set to this folder. On Linux, install the CPU torch wheel first (pip install torch==2.15.0 --index-url https://download.pytorch.org/whl/cpu). Otherwise pip pulls the CUDA wheels. jlens is installed from anthropics/jacobian-lens at commit 581d398613e5602a5af361e1c34d3a92ea82ba8e.

DATASET.sha256 lists every file of the repository with its sha256. To check a download, run shasum -a 256 -c DATASET.sha256 (or sha256sum -c). Each run also checks it, and records the result.

Run

From any folder:

python -m jspace.run --work work --out evidence                          # full run, fits the three lenses
python -m jspace.run --work work --out evidence --lenses hosted          # full run with the shipped lenses
python -m jspace.run --work work --out evidence-quick --quick --lenses hosted   # smoke test

The steps run in this order:

  1. Inputs. Downloads the three models at pinned revisions into <work>/models and checks each model.safetensors sha256. Streams the first 160 WikiText-103 records of ≥ 600 characters at a pinned dataset revision: records 0–99 fit the lenses, and 100–159 are held out. Reads prereg.json, the planted deltas, the contrastive pair files and the protocol files from this repository, and checks them against pinned sha256.
  2. Lenses. Fits the three lenses with jlens: SmolLM-135M-Instruct on 100 passages, the base model on 20 and SmolLM2 on 60. The main lens keeps a snapshot every 10 passages for lens_eval's convergence curve. With --lenses hosted, the run uses the fitted lenses in lenses/ instead. The fit is then not tested, and the convergence curve has one point.
  3. Planted models. Rebuilds the distress and caps models from the pinned SmolLM2 weights plus planted/<name>_baked_delta.pt, and checks their sha256. Then rebuilds the activation cache for planted_state's bootstrap from inputs/valence-kit/data/*_pairs.jsonl, and checks that it reproduces planted/vectors.pt.
  4. Evidence. Runs layer_stats first, because it derives the band that every later test reads. Then the other 14 instrument files, welfare_lab and planted_state.
  5. Records. Writes run_log.json, and copies prereg.json into --out byte for byte.

The exit status is 0 only if every file was written and passed its schema check. JSPACE_DEVICE, JSPACE_DTYPE, JSPACE_KV_CACHE and JSPACE_FP32_UNEMBED must be unset. The run uses the settings in models.json and stops if any of them is set.

Option Meaning
--work DIR Models, lenses, band, caches, WikiText prompts and intermediate files. Default ./jspace-work. Hugging Face caches also go here unless HF_HOME is set.
--out DIR The evidence files, run_log.json and prereg.json. Default ./evidence, or ./evidence-quick with --quick. Quick and full outputs never share a folder.
--quick Tiny sample sizes, as a smoke test of the pipeline. The numbers mean nothing, every file says params.quick: true, and some counts (for example the planted-state null) fall below their contract sizes.
--only a,b A subset of the 17 files. A full run without layer_stats needs band.json from an earlier full run with the same --work and --lenses.
--lenses fit|hosted fit (default) fits the three lenses here, which takes hours on a CPU. hosted uses lenses/.
--threads N torch CPU threads for every step. Defaults: 3 for the instrument files, 1 for welfare_lab, 4 for planted_state, and 4 / 2 / 4 for the instruct, base and SmolLM2 lens fits. Greedy and sampled text can depend on the count.
--data-revision SHA The commit of this repository, recorded in run_log.json. Default: $JSPACE_DATA_REVISION, else the commit huggingface_hub recorded when the folder was downloaded, else null.

Outputs

<out>/ holds the 17 files, plus run_log.json and prereg.json:

File Test
layer_stats.json … broadcast.json T01–T15 (table above)
welfare_lab.json T16: the scenarios, the per-cell lexicon readouts, the interventions and the C1–C8 scorecard with each threshold copied from prereg.json
planted_state.json T17: readout, decomposition with bootstrap, re-injection, the three models read with one lens, P1–P6 outcomes and the verdict
run_log.json downloads (one record per download: repo, revision and, for each model, file and sha256); data_source (this repository: repo, revision, the sha256 of each data file read, and the DATASET.sha256 check); versions; lens.n_prompts; seed; the command (with <work> / <out> in place of the folders); the lens source; the threads, device and dtype of each step; the band each step read; and per-file timing, sha256 and validation
prereg.json the pre-registration, a byte copy of the one in this repository

Each evidence file starts with a common header: name, version, created, model, lens, params (with the band), notes and paper_ref. The exploratory parts are labelled inside the files.

<work>/ keeps the models, the lenses with band.json and resid_norms.json, the WikiText prompts, the raw welfare probe results, the activation cache and other caches. A rerun with the same work folder reuses them.

Runtime

A full run with --lenses hosted and the default per-step threads took 33 minutes (1,998 s) on a 16-core Apple-silicon laptop, with a peak memory footprint of 5.7 GB. --lenses fit adds the three Jacobian fits (100 + 20 + 60 passages). In the blind rebuild described in METHODS.md (section 7), these took about 1 h 50 min, 23 min and 68 min on a 4-core machine at 4 threads.

On a laptop CPU with --threads 3, --quick --lenses hosted took 7 minutes into an empty work folder. About 2.5 minutes of that were the first download of the three models and the WikiText prompts, and the rest was computation, mostly the welfare probe and planted_state.

What is not included

  • Results. There are no evidence files, no reference numbers, and no expected outcomes.
  • Model weights. They are downloaded at run time from the Hub at pinned revisions. The two planted models are rebuilt from the clean SmolLM2 weights.
  • WikiText. It is streamed at a pinned revision.
  • The jlens package. pip installs it from GitHub at the pinned commit.

Unit tests

pytest                                                    # math, registry and rule tests (no model needed)
JSPACE_TEST_WORK=work JSPACE_TEST_LENSES=hosted pytest    # also the engine, intervention and probe tests

Layout

README.md, DATASET.sha256
METHODS.md       definition, rationale and derivation of each test (T01–T17)
pyproject.toml, requirements.lock   the package and the exact versions of every dependency
models.json      the registry: Hub repo, pinned revision and sha256 per model
prereg.json      the frozen pre-registration: system under test, lens, band rule, C1–C8 thresholds, lexicons, P1–P6
jspace/          the suite: engine, experiments (T01–T15), welfare (+ welfare_run), planted (+ planted_run), fit, fetch,
                 validate, run (the CLI); kit/ = hooks, sampling and scorer for the planted state
lenses/          the three fitted lenses (.pt + .json) and the main model's resid_norms.json (--lenses hosted)
planted/         vectors.pt (the planted directions) and, per planted model, the layer-20 delta and its bake settings
inputs/          every protocol input that is not a jacobian-lens file (item sets, prompts, word lists, scenario
                 templates, seeds, shared rules); inputs/MANIFEST.md maps each file to its test
protocols/       the jacobian-lens data/ files (experiments/, evaluations/) at commit 581d398, unchanged (Apache-2.0)
tests/           unit tests
Downloads last month
98

Paper for rezivor/gwt-welfare-evals