backup: PROVENANCE.md

288781f verified about 2 months ago

80.3 kB

Provenance for `bgradowhite/cells-developmental`

Backup of /Users/brianna/Cells_Developmental/out taken 2026-09-14 14:56 PDT on brianna.local.

This is a verbatim backup, not a curated release. Directory layout is the working copy's; archives (*.tar.gz) are directories the hub could not hold loose, and MANIFEST.json records the SHA-256 of every member so an extracted copy can be checked.

Source repository at backup time

repository: /Users/brianna/Cells_Developmental
remote: origin https://github.com/bgradowhite/Cells_Developmental.git (fetch)
HEAD: af3d9fb32536c5fcbb98dbd3761306338d766046 on main
last commit: 2026-09-14 13:21:13 -0700 Shorten the web's wall-boundary caption to fit its canvas
uncommitted changes: 0 paths

The Python sources under the backup root are included as they stood on disk, so the code that wrote a checkpoint set is the copy sitting beside it, uncommitted edits included. Where a directory was produced by a script outside the backup root (the Cells_Developmental scripts/ and src/), the script is named by path and its module docstring quoted; consult the commit above for its exact text.

Directories

`census/`

17 files, 0.02 GB, sent as loose files
file kinds: .log 9, .json 7, .csv 1
provenance files inside: pythia70m_pile_ctx10_edit05.log, gpt2_pile_ctx64.log, gpt2_pile_ctx10.log, pythia410m_pile_ctx64.log, pythia70m_pile_ctx64.log, queue.log, pythia410m_pile_ctx10.log, grid_edges.log, pythia70m_pile_ctx10.log

scripts that name this directory: scripts/build_pages.py, scripts/build_pythia_sweeps.py, scripts/census_grid_edges.py, scripts/census_logit_pairs.py, scripts/publish_tree.py, src/cells_developmental/logit_census.py, src/cells_developmental/models/token_substrate.py, src/cells_developmental/report/anchor_section.py

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

build_pythia_sweeps.py docstring:

Measure the perturbation sections for a Pythia model, checkpoint by checkpoint.

    python scripts/build_pythia_sweeps.py --data-root ~/pythia --download [--device cuda]
    python scripts/build_pythia_sweeps.py --model 410m --steps 143000 --sections 1d,attenuation

The same measurements as the MNIST and GPT-2 XL pages, on the language
substrates whose training axis is real: every released checkpoint of a Pythia
model, pinned by SHA-256 in ``configs/inputs/pythia_pile_<size>.yaml``. Which
model is ``--model``; each has its own manifest and its own parts directory,
and nothing else differs between them.

**Every section in one pass over the checkpoints.** Holding the whole axis is
25.6 GB for the 70m model and 140 GB for the 410m one, so a checkpoint is
fetched, verified, measured and discarded. That makes the checkpoint, not the
arithmetic, the thing worth not repeating: measuring the 1d section now and the
2d section later would transfer the axis twice. So each checkpoint is measured
for everything wanted from it before it is deleted, and ``--keep`` holds them
where there is disk to spare.

The sweep follows the MNIST page's shape:

*1d*, at every checkpoint: every cut by five seeds by two rotation frames by
two base families, forty scans over fifty-five angles.

*Attenuation*, at every checkpoint, opt-in through ``--sections``: Arora et
al.'s noise-stability curve from a few injection cuts to every readout below
them, both base families, in the layout of the GPT-2 XL panel.

*2d by training time*, at every checkpoint: three cuts, one plane, every base
type, three base points each, which is the panel the training slider drives.

*2d by depth*, at the final checkpoint only: every cut by every base type by
every plane, which is the explorer panel. Depth is a property of the trained
network, and repeating it at 154 checkpoints would cost more than everything
else here put together. ``--depth-cuts`` and ``--depth-planes`` restrict it
where a 24-layer model makes the full product unaffordable, ``--real-bases``
gives the real prompts more examples than the constructed kinds, and
``--foreign`` adds the sixth base kind the GPT-2 XL page has: prose from the
other model's corpus, here OpenWebText through Pythia's own tokenizer.

...

census_grid_edges.py docstring:

Census of plateau edges on the 2d grids: where, along each ray from the base, the
response first reaches half its settled level, and where the rate peaks.

The grid's two coordinates are polar coordinates of a patch of the sphere, so
the total rotation at a point is sqrt(t1**2 + t2**2): 90 degrees on the axes'
ends and 127 at the corners. This walks every grid part, casts rays from the
base every five degrees of azimuth, and records the edge angle along each
ray (the project's ``plateau_edge`` convention applied ray by ray) and the
angle at which the rate is largest. A part's boundary "passes 90 degrees"
when some ray's edge lies beyond 90, or a ray toward a corner never crosses
the threshold before leaving the frame.

    .venv/bin/python scripts/census_grid_edges.py --csv out/census/grid_edges.csv mnist vgg_cifar10
    .venv/bin/python scripts/census_grid_edges.py --summary out/census/grid_edges.csv

`chord/`

31 files, 0.01 GB, sent as loose files
file kinds: .json 26, .png 5

scripts that name this directory: scripts/build_cifar_cell_properties.py, scripts/build_mnist_cell_properties.py, scripts/build_modular_cell_properties.py, scripts/publish_tree.py, scripts/residual_chord_test.py, scripts/scratch_unit_flips.py, src/cells_developmental/exp1/directions.py, src/cells_developmental/experiments/anchor_plane.py, src/cells_developmental/experiments/chord.py, src/cells_developmental/experiments/scan_1d.py, src/cells_developmental/perturbation.py, src/cells_developmental/report/cell_properties_section.py

build_cifar_cell_properties.py docstring:

Measure the cell properties of one CIFAR network at every checkpoint, into parts.

    python scripts/build_cifar_cell_properties.py --net resnet [--pools train test] [--resume]
    python scripts/build_cifar_cell_properties.py --net vgg --thin 9 --quick

The MNIST page's "Cell properties over development" section, on the whole-map
substrates. For each pool and checkpoint: the slope of the output along
straight segments between pairs of images at every cut (``paths``: same-class
and different-class pairs, drawn once at the final checkpoint among images it
classifies correctly and followed over training, as the mean squared
Fisher-Rao speed and the mean unsigned logit slope), and the distance from
single images to the nearest change of prediction (``walls``: a minimal-norm
search, rays toward the nearest other-class images, and random directions).
``experiments.cell_properties`` does the measuring; this script chooses the
images and writes one part per property, pool and checkpoint. ``chords`` is
the MNIST page's web: two correct images of each of ten classes, drawn by
the seed (all ten on CIFAR-10; ten of the hundred on CIFAR-100), and every
pair among them at every cut and checkpoint.

**Where the walls are measured.** On MNIST the walls are at the input. The
VGG's first cut is the image itself, so its walls are at the input too; the
ResNet's first cut is its first block's output, since the image is not one
of its cuts, and its wall distances are distances in that activation space,
which the part's cut says. The two are not the same statistic and the page
labels each by its cut.

The ``train`` pool is a seeded draw from the network's training images, the
``test`` pool from the held-out split; both are filtered to images the final
checkpoint classifies correctly before pairs and items are drawn. The pool's
images go on the page as colour thumbnails with their classes.

build_mnist_cell_properties.py docstring:

Measure the cell properties of the MNIST networks at every checkpoint, into parts.

    python scripts/build_mnist_cell_properties.py [--nets plain,res,tanh] [--pools train,test]
        [--properties paths,walls,chords,pathwalls] [--steps ...] [--resume] [--quick]

For each network, pool and checkpoint: the slope of the output along straight
segments between pairs of images at every cut (``paths``: same-class and
different-class pairs, drawn once at the final checkpoint among correctly
classified images and followed over training), and the distance from single
images to the nearest change of prediction at the input (``walls``: a
minimal-norm search, rays toward the nearest other-class images, and random
directions), and the same slope along every segment among a few images per
class (``chords``: ``--per-class`` images of each digit, every pair among
them, the web the page draws with its chords shaded by the running integral).
``pathwalls`` segments the same paths into plateaus and walls by two levels
of ||Ju|| read from that network's own pooled slope histogram, the plateau
mode and the trough above it, and measures each wall's thickness, height,
sharpness and contrast, remeasuring each wall on a finer grid. Two
conventions are written side by side: the levels of the first checkpoint
whose trough is empty (or the deepest, if it never empties) held fixed over
the run, and each checkpoint's own levels, which drift with the plateau; a
checkpoint whose histogram has one mode gets no drifting part, and a network
whose histogram never splits gets no fixed one, and both say so.
``experiments.cell_properties`` does the measuring; this script chooses the
images and writes one part per property, pool and checkpoint.

The ``train`` pool is what the network trained on: the thousand images of the
pair's recipe, the first 4,000 training images for the tanh network. The
``test`` pool is the first 4,000 test images. Both are filtered to images the
final checkpoint classifies correctly before pairs and items are drawn.

build_modular_cell_properties.py docstring:

Measure the cell properties of the modular-addition network at every checkpoint, into parts.

    python scripts/build_modular_cell_properties.py [--run NAME] [--pools train,test]
        [--properties paths,walls,chords] [--steps ...] [--resume] [--quick]

For each pool and checkpoint: the slope of the output along straight segments
between pairs of bank items at every cut (``paths``: same-sum and
different-sum pairs, drawn once at the final checkpoint among correctly
classified pairs and followed over training), the distance from single items
to the nearest change of prediction at the embed cut (``walls``), and the same
slope along every segment among a few items per class (``chords``: two pairs
of each of ``--chord-classes`` residues drawn by the seed, since p classes at
two nodes each would be tens of thousands of chords where the MNIST web has
190). ``experiments.cell_properties`` does the measuring.

The ``train`` pool is the pairs the network was fitted to; the ``test`` pool
is the held-out pairs of the same split. Both are filtered to pairs the final
checkpoint classifies correctly before pairs and items are drawn. The class of
a pair is its sum modulo p, which is its own name, so the nodes part carries
labels and no thumbnails.

`cifar_zoo/`

13 files, 0.40 GB, sent as loose files
file kinds: .pt 9, .json 3, .csv 1

scripts that name this directory: scripts/check_zoo_preprocessing.py, scripts/cifar_nets.py, scripts/fetch_zoo_checkpoints.py, scripts/modal/cifar.py

check_zoo_preprocessing.py docstring:

Check that we feed the zoo's ResNet what the zoo fed it.

    python scripts/check_zoo_preprocessing.py --epoch 60
    python scripts/check_zoo_preprocessing.py --epoch 60 --limit 128   # smoke test

The weights are identified -- fetched, hashed and pinned -- but weights alone
do not say what the network expects at its input, and a normalisation that is
merely plausible would move every activation we go on to measure. Their
generator, ``code/zoo_generators/train_zoo_cifar100_resnet18_kaiming_uniform.py``
in ModelZoos/ModelZooDataset, evaluates through ``ToTensor`` and ``Normalize``
with the channel statistics ``banks.IMAGE_CORPUS["cifar100"]`` now declares.
This script tests that reading against the trial's own recorded accuracy.

Two comparisons, and they check different things. The **test** split is the
standard CIFAR-100 test set read through their evaluation transform, so
agreement there is about the transform alone, and it is exact: 0.7445 against
their 0.7445. The **validation** split is 10,000 images they held out of the
training set with ``random_split(..., [40000, 10000], generator=manual_seed(42))``
and evaluated, as their generator does, through the *train* transform, so
agreement there says the split reconstruction is theirs -- which matters because
a probe bank should be drawn from images the network was actually fitted on.

Accuracy is the instrument because it is what they recorded. It is also blunt
in a useful way: a wrong normalisation does not shift it slightly, it collapses
it.

cifar_nets.py docstring:

The two CIFAR networks as the build scripts see them: one loader each, nothing else.

    from cifar_nets import load_net
    net = load_net("resnet")            # or "vgg"
    bank, source = net.bank(256)
    substrate = net.substrate(net.epochs[-1], bank, source)

The CIFAR pages share one shape -- ResNet-18 on CIFAR-100 from the model zoo
and VGG-19 on CIFAR-10 trained here -- and every section's script runs the same
sweep on either. What differs between the two is only where the trajectory
lives, which corpus is its own and which is foreign, and which adapter wraps a
checkpoint. That is all this module holds; the measurements are in
``cells_developmental.experiments`` and know nothing of it.

**The state is the whole feature map** on both networks, flattened: 64x32x32 at
the ResNet's first block and at the VGG's second convolution, down to 512x4x4
at the ResNet's last. That is what "inject noise into a layer" means in the
robustness literature and what a claim about a layer's own geometry needs. The
site substrate that perturbs one spatial position of the ResNet is kept in
``models.resnet`` and is not built here.

**Banks.** Convention 4: each network's own training images, on the scale it
was trained at -- the zoo's 40,000-image subset for the ResNet, the 50,000
fast.ai folders for the VGG, both hash-pinned. The *foreign* bank for one
network is the other's corpus, standardised by the network's own statistics
rather than the corpus's, since it is this network's activations being
measured; the source string records which.

Paths outside the repository are not assumed: the VGG trajectory can be
pointed anywhere with ``artifact``, which is what a pod uses.

`figures/`

5 files, 0.00 GB, sent as loose files
file kinds: .png 5

scripts that name this directory: scripts/build_pages.py, src/cells_developmental/exp1/mnist_task.py, src/cells_developmental/exp1/surface_geometry.py, src/cells_developmental/exp1/synthetic_task.py, src/cells_developmental/experiments/spline_cells.py, src/cells_developmental/gist/__init__.py, src/cells_developmental/models/katago.py, src/cells_developmental/models/paper_mlp.py, src/cells_developmental/models/relu_mlp.py, src/cells_developmental/report/architecture.py, src/cells_developmental/report/directions.py, src/cells_developmental/report/grid_section.py

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

grid_section.py docstring:

The 2d perturbation panel: a rotation map, and how it changes.

Where the 1d panel swings an activation along one arc, this sweeps a whole
patch of directions at fixed radius, so a plateau shows as a dark disc with a
bright cliff at its rim rather than as a knee on a curve. That picture is the
reason the section exists: a knee could be an artefact of one direction, but a
disc cannot.

Two views, as the earlier pages had them.

*By depth* holds the network fixed and varies where the perturbation starts and
which plane it moves in -- every cut, every base type, every plane family. It
asks what the geometry is.

*By training time* holds the cut and the plane fixed and walks the checkpoints.
It asks when the geometry arrives.

**Colour is capped at each map's own settled value**, not at a global maximum.
The bases sit at very different scales -- a CIFAR image lands much further out
in activation space than a digit does -- so a shared colour range would render
most of the panels as flat colour. Capping per map costs the ability to compare
absolute heights across panels, which the printed numbers give back.

`mnist_dense/`

24 files, 0.06 GB, sent as loose files
file kinds: .npz 23, .json 1
provenance files inside: inventory.json

scripts that name this directory: scripts/build_pages.py, scripts/hf_upload_checkpoints.py, scripts/mnist_nets.py, scripts/publish_tree.py

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

`mnist_dense-b5/`

24 files, 0.07 GB, sent as loose files
file kinds: .npz 23, .json 1
provenance files inside: inventory.json

scripts that name this directory: scripts/hf_upload_checkpoints.py

hf_upload_checkpoints.py docstring:

Upload the trajectories trained here to the shared Hugging Face dataset.

    python scripts/hf_upload_checkpoints.py                 # plan only: what differs
    python scripts/hf_upload_checkpoints.py --upload        # push what is missing
    python scripts/hf_upload_checkpoints.py --upload --overwrite paper_mlp/plain
    python scripts/hf_upload_checkpoints.py --upload --pull-request     # no write access
    python scripts/hf_upload_checkpoints.py --upload --pull-request 1   # onto PR 1

The repository (``--repo``) collects the trained trajectories the pages are
measured on. Only artifacts trained by this project's own scripts are listed
below, and the measured parts behind the language pages; the inputs pinned
under ``configs/inputs/`` (MNIST, CIFAR, the Pythia releases, the model-zoo
trial) are public elsewhere and are not mirrored.

Every local file is hashed and compared with the remote tree before anything
is sent. A file whose SHA-256 already matches is skipped, a missing file is
uploaded, and a file that exists remotely with different bytes is reported and
left alone unless its artifact is named by ``--overwrite``: the copy on the hub
may be someone else's re-run of the same recipe, and replacing it is a
decision, not a side effect. Uploads go in bounded commits so an interrupted
run resumes where it stopped.

The token comes from ``HF_TOKEN`` or the hub client's stored login and needs
write access to the repository, or ``--pull-request``, which opens one pull
request on the first commit and adds every later commit to it, for an account
that is not a collaborator; nothing here reads a credentials file.

`mnist_dense-b6/`

24 files, 0.08 GB, sent as loose files
file kinds: .npz 23, .json 1
provenance files inside: inventory.json

scripts that name this directory: scripts/hf_upload_checkpoints.py

hf_upload_checkpoints.py docstring:

Upload the trajectories trained here to the shared Hugging Face dataset.

    python scripts/hf_upload_checkpoints.py                 # plan only: what differs
    python scripts/hf_upload_checkpoints.py --upload        # push what is missing
    python scripts/hf_upload_checkpoints.py --upload --overwrite paper_mlp/plain
    python scripts/hf_upload_checkpoints.py --upload --pull-request     # no write access
    python scripts/hf_upload_checkpoints.py --upload --pull-request 1   # onto PR 1

The repository (``--repo``) collects the trained trajectories the pages are
measured on. Only artifacts trained by this project's own scripts are listed
below, and the measured parts behind the language pages; the inputs pinned
under ``configs/inputs/`` (MNIST, CIFAR, the Pythia releases, the model-zoo
trial) are public elsewhere and are not mirrored.

Every local file is hashed and compared with the remote tree before anything
is sent. A file whose SHA-256 already matches is skipped, a missing file is
uploaded, and a file that exists remotely with different bytes is reported and
left alone unless its artifact is named by ``--overwrite``: the copy on the hub
may be someone else's re-run of the same recipe, and replacing it is a
decision, not a side effect. Uploads go in bounded commits so an interrupted
run resumes where it stopped.

The token comes from ``HF_TOKEN`` or the hub client's stored login and needs
write access to the repository, or ``--pull-request``, which opens one pull
request on the first commit and adds every later commit to it, for an account
that is not a collaborator; nothing here reads a credentials file.

`mnist_task/`

7 files, 0.01 GB, sent as loose files
file kinds: .npz 6, .json 1
provenance files inside: inventory.json

scripts that name this directory: scripts/hf_upload_checkpoints.py, scripts/mnist_nets.py, scripts/publish_tree.py

hf_upload_checkpoints.py docstring:

Upload the trajectories trained here to the shared Hugging Face dataset.

    python scripts/hf_upload_checkpoints.py                 # plan only: what differs
    python scripts/hf_upload_checkpoints.py --upload        # push what is missing
    python scripts/hf_upload_checkpoints.py --upload --overwrite paper_mlp/plain
    python scripts/hf_upload_checkpoints.py --upload --pull-request     # no write access
    python scripts/hf_upload_checkpoints.py --upload --pull-request 1   # onto PR 1

The repository (``--repo``) collects the trained trajectories the pages are
measured on. Only artifacts trained by this project's own scripts are listed
below, and the measured parts behind the language pages; the inputs pinned
under ``configs/inputs/`` (MNIST, CIFAR, the Pythia releases, the model-zoo
trial) are public elsewhere and are not mirrored.

Every local file is hashed and compared with the remote tree before anything
is sent. A file whose SHA-256 already matches is skipped, a missing file is
uploaded, and a file that exists remotely with different bytes is reported and
left alone unless its artifact is named by ``--overwrite``: the copy on the hub
may be someone else's re-run of the same recipe, and replacing it is a
decision, not a side effect. Uploads go in bounded commits so an interrupted
run resumes where it stopped.

The token comes from ``HF_TOKEN`` or the hub client's stored login and needs
write access to the repository, or ``--pull-request``, which opens one pull
request on the first commit and adds every later commit to it, for an account
that is not a collaborator; nothing here reads a credentials file.

mnist_nets.py docstring:

The MNIST data and trajectories as every MNIST build script opens them.

Nine scripts each read the pinned manifest, built the training configuration
and prepared the dataset with the same lines and their own copies of the
constants; one copy drifted (a different root seed, inert, and a bank of 4000
against 1000 with a comment saying they were the same). The constants live
here with their meanings, and the drift is stated rather than hidden.

`modular/`

1450 files, 0.46 GB, sent as loose files
file kinds: .json 1450

scripts that name this directory: scripts/backfill_modular_anchor_verdicts.py, scripts/build_pages.py, scripts/modular_nets.py, scripts/train_modular_transformer.py, src/cells_developmental/models/modular_mlp.py, src/cells_developmental/models/modular_transformer.py, src/cells_developmental/report/anchor_section.py, src/cells_developmental/report/directions.py, src/cells_developmental/report/payload.py

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

train_modular_transformer.py docstring:

Train the one-layer transformer on modular addition and keep its trajectory.

    python scripts/train_modular_transformer.py [--p 113] [--steps 40000] [--seed 0]
        [--split-seed 0] [--device cpu] [--resume]

Writes ``out/modular_transformer/<run>/``: ``config.json`` (architecture,
recipe and ``arch: transformer`` so the run opens through
``scripts/modular_nets.py``), one ``step*.pt`` per checkpoint holding the
weights and the evaluation there, ``metrics.json`` with every evaluation,
and ``latest.pt`` with the optimiser state for ``--resume``. Checkpoints fall
on a logarithmic grid and at every evaluation where the test accuracy has
moved, so the transition is dense. Every file is written as it is reached,
so an interrupted run keeps what it did.

`modular_transformer/`

133 files, 0.12 GB, sent as loose files
file kinds: .pt 131, .json 2
provenance files inside: tf_p113_d128_h4_m512_wd1.0_frac0.3_seed0/metrics.json, tf_p113_d128_h4_m512_wd1.0_frac0.3_seed0/config.json

scripts that name this directory: scripts/build_pages.py, scripts/hf_upload_checkpoints.py, scripts/modular_nets.py, scripts/train_modular_transformer.py, src/cells_developmental/models/modular_transformer.py, src/cells_developmental/report/architecture.py, src/cells_developmental/report/directions.py

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

train_modular_transformer.py docstring:

Train the one-layer transformer on modular addition and keep its trajectory.

    python scripts/train_modular_transformer.py [--p 113] [--steps 40000] [--seed 0]
        [--split-seed 0] [--device cpu] [--resume]

Writes ``out/modular_transformer/<run>/``: ``config.json`` (architecture,
recipe and ``arch: transformer`` so the run opens through
``scripts/modular_nets.py``), one ``step*.pt`` per checkpoint holding the
weights and the evaluation there, ``metrics.json`` with every evaluation,
and ``latest.pt`` with the optimiser state for ``--resume``. Checkpoints fall
on a logarithmic grid and at every evaluation where the test accuracy has
moved, so the transition is dense. Every file is written as it is reached,
so an interrupted run keeps what it did.

`paper_mlp/`

528 files, 0.53 GB, sent as loose files
file kinds: .npz 516, .json 12
provenance files inside: res/inventory.json, plain-noise-h1-0.1/inventory.json, plain/inventory.json, plain-h6/inventory.json, plain-s1/inventory.json, res-h5/inventory.json, res-h4/inventory.json, plain-noise-h1-0.5/inventory.json, plain-h5/inventory.json, plain-h4/inventory.json, res-h6/inventory.json, plain-noise-h1-0.25/inventory.json

scripts that name this directory: scripts/build_cells_sweeps.py, scripts/build_pages.py, scripts/hf_upload_checkpoints.py, scripts/mnist_nets.py, scripts/train_paper_mlp.py, src/cells_developmental/models/paper_mlp.py, src/cells_developmental/report/architecture.py, src/cells_developmental/report/payload.py

build_cells_sweeps.py docstring:

Measure the Cells section: the plane through three activations.

    python scripts/build_cells_sweeps.py --slices 70 --steps 41
    python scripts/build_cells_sweeps.py --pools test_all --shard 3/8 --skip-existing
    python scripts/build_cells_sweeps.py --slices 4 --all-cuts

One plane measured once and kept in every view the panel can show: the exact
spline partition with each cell filled by how sharp its own walls are and by
the output slope over it, the sensitivity field, the distance to the anchors
and the predicted class.

Which images the anchors come from is a swept axis, the *pool*, read from
``configs/cells_slices.json``. ``test_correct`` is the test split kept to what
both paper networks classify correctly at their final checkpoint, so the two
networks share every plane; ``test_all`` is the test split unfiltered, so about
one anchor in seven is one the network gets wrong, and every part records which.
The retired ``train_head`` pool is the first thousand training images, of which
the network trained on fifteen: it is what made a decision boundary between two
zeros look like a paradox rather than an error the network makes.

Two axes cannot both be swept to the end. The slice list and the training
ladder run in full at the default perturbation cut and readout; the
cut-by-readout cross is a separate, much smaller run at a few slices, which is
what ``--all-cuts`` is for. ``--shard i/n`` strides over the flat list of
frames so several machines can split a sweep without coordinating, since parts
are named for what they measured and two machines cannot write the same name
unless they measured the same thing.

The partition exists only where the network is exactly piecewise linear, so
the tanh network's planes carry every other view -- the Jacobian field, the
Fisher rate, the distances, the decision map -- and no partition, which the
part records rather than faking a region count (convention 6). Its bank is the
same test split the pair's pools index, standardised as its training saw it,
so the three networks share every anchor triple.

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

train_paper_mlp.py docstring:

Train the grokking paper's MNIST MLP and its minimal residual pair.

    python scripts/train_paper_mlp.py [--steps 100000] [--hidden-layers 3] [--out DIR]
        [--members plain,res] [--seed 0]
        [--noise-cut h1 --noise-level 0.1 [--noise-start 0] [--noise-stop N]]

Their recipe, from the vendored config: a thousand training points, batch 200,
AdamW at 1e-3 with decay 0.01, MSE against one-hots, width 200, depth 4. The
two networks differ in one thing -- identity paths around the hidden layers --
so anything that differs between them is attributable to the skips.

``--hidden-layers`` trains a deeper pair with the same recipe: ``n`` hidden
layers of width 200 is depth ``n + 1``. The default three is theirs and writes
the tags ``plain`` and ``res`` under ``out/paper_mlp``; any other count writes
``plain-h<n>`` and ``res-h<n>`` beside them, so the depth-4 artifacts the
pages were measured from are never overwritten.

Two further departures, each recorded in the tag and the inventory so that the
artifacts they produce sit beside the pair without displacing it. ``--seed``
other than 0 appends ``-s<seed>``: the initialisation, the trained-on thousand
and the batch order all derive from it, so a second seed is a replicate of the
recipe and the spread between replicates is what an intervention is judged
against. ``--noise-cut`` with ``--noise-level`` trains with Gaussian noise added
to the state at that cut on every training forward pass, sized per sample as
``level`` times its own state norm (the attenuation panel's construction, so a
level here and a level there name the same perturbation), and appends
``-noise-<cut>-<level>``; ``--noise-start`` and ``--noise-stop`` confine it to a
window of steps and append ``-w<start>-<stop>``. Evaluation and the stored
weights are always clean. ``--members`` restricts the run to one member.

Both are ReLU with no normalisation, so both are exactly piecewise linear and
admit an exact partition, which the repository's tanh substrate never can.

`paper_mlp_100k/`

84 files, 0.07 GB, sent as loose files
file kinds: .npz 82, .json 2
provenance files inside: res/inventory.json, plain/inventory.json
no script under the search roots names this directory (check the README beside it)

`parts_retired/`

642 files, 0.05 GB, sent as loose files
file kinds: .json 642
no script under the search roots names this directory (check the README beside it)

`pod_logs_pythia410m/`

4 files, 0.00 GB, sent as loose files
file kinds: .log 4
provenance files inside: pythia410m_cells_session.log, cells_worker_0.log, cells_worker_1.log, cells_worker_2.log
no script under the search roots names this directory (check the README beside it)

`queue/`

54 files, 0.00 GB, sent as loose files
file kinds: .log 28, .txt 26
provenance files inside: path_fisher_energy.log, cell_chords.log, cell_properties_paths.log, mnist_path_norms.log, chord_gpt2.log, cifar_scans.log, build_mnist_page.log, paper_mlp_1m.log, mnist_grids_launch.log, noise_h1_plain.log, mnist_symmetric.log, paper_mlp_1m_sweeps.log

scripts that name this directory: src/cells_developmental/report/cells_section.py

cells_section.py docstring:

The Cells section: basins, spline partition, rate field and decision map.

Four views of one plane, shown together because that is the only way to tell a
boundary that matters from one that does not. The basins say where each
anchor's behaviour dominates; the partition says where the network's affine
pieces change; the rate field says how fast the output is moving; the decision
map says where the predicted class flips. A boundary present in all four is
real. A wall present only in the partition is one the network does nothing
across, which is exactly what the cell fill is there to measure.

The partition and its fill exist only on an exactly piecewise-linear network,
so this section carries the paper pair and not the smooth substrate.

`vgg_cifar10/`

4 files, 0.00 GB, sent as loose files
file kinds: .json 3, .log 1
provenance files inside: job.log

scripts that name this directory: scripts/build_pages.py, scripts/census_grid_edges.py, scripts/cifar_nets.py, scripts/hf_upload_checkpoints.py, scripts/modal/cifar.py, scripts/train_vgg_cifar10.py

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

census_grid_edges.py docstring:

Census of plateau edges on the 2d grids: where, along each ray from the base, the
response first reaches half its settled level, and where the rate peaks.

The grid's two coordinates are polar coordinates of a patch of the sphere, so
the total rotation at a point is sqrt(t1**2 + t2**2): 90 degrees on the axes'
ends and 127 at the corners. This walks every grid part, casts rays from the
base every five degrees of azimuth, and records the edge angle along each
ray (the project's ``plateau_edge`` convention applied ray by ray) and the
angle at which the rate is largest. A part's boundary "passes 90 degrees"
when some ray's edge lies beyond 90, or a ray toward a corner never crosses
the threshold before leaving the frame.

    .venv/bin/python scripts/census_grid_edges.py --csv out/census/grid_edges.csv mnist vgg_cifar10
    .venv/bin/python scripts/census_grid_edges.py --summary out/census/grid_edges.csv

train_vgg_cifar10.py docstring:

Train the VGG-19 substrate on CIFAR-10, on Arora et al.'s recipe.

    python scripts/train_vgg_cifar10.py --epochs 299 --device cuda
    python scripts/train_vgg_cifar10.py --smoke                       # proves it runs
    python scripts/train_vgg_cifar10.py --resume-from out/vgg_cifar10/epoch_30.pt --start-epoch 30

The recipe is theirs where the paper states it: SGD with momentum 0.9, weight
decay 5e-4, batch 128, the learning rate halved every thirty epochs, random
crop and horizontal flip, 299 epochs, dropout in the fully connected layers.
Two things are ours, and both are forced. The initial rate is 0.02 rather than
their 0.05, because a plain VGG-19 sits at a loss of exactly ln(10) at 0.05 and
never leaves it -- we tried, twice, on two machines. And the network is
Kaiming-initialised, as torchvision's VGG is, for the same reason. At 0.02 it
reaches 92.3 percent on their schedule against their 92.45.

Checkpoints are written on a grid -- 1, 2, 5, 10, 20, the last epoch, and every
``--marks`` epochs -- because the attenuation is a property that appears during
training, and a final checkpoint alone cannot say when. The data are the pinned
CIFAR-10 folders under ``data/cifar10``, verified by ``scripts/fetch_inputs.py``;
``--data`` also accepts torchvision's python-batch layout, which is what a pod
that downloads the set itself will have.

`vit_zoo/`

3 files, 0.09 GB, sent as loose files
file kinds: .json 2, 1
provenance files inside: sl_ft_SD_42_LR_0.0001_WD_0_OM_adamw_HD_NA_FZ_False_FCMLP_False/config.json

scripts that name this directory: scripts/cifar_nets.py

cifar_nets.py docstring:

The two CIFAR networks as the build scripts see them: one loader each, nothing else.

    from cifar_nets import load_net
    net = load_net("resnet")            # or "vgg"
    bank, source = net.bank(256)
    substrate = net.substrate(net.epochs[-1], bank, source)

The CIFAR pages share one shape -- ResNet-18 on CIFAR-100 from the model zoo
and VGG-19 on CIFAR-10 trained here -- and every section's script runs the same
sweep on either. What differs between the two is only where the trajectory
lives, which corpus is its own and which is foreign, and which adapter wraps a
checkpoint. That is all this module holds; the measurements are in
``cells_developmental.experiments`` and know nothing of it.

**The state is the whole feature map** on both networks, flattened: 64x32x32 at
the ResNet's first block and at the VGG's second convolution, down to 512x4x4
at the ResNet's last. That is what "inject noise into a layer" means in the
robustness literature and what a claim about a layer's own geometry needs. The
site substrate that perturbs one spatial position of the ResNet is kept in
``models.resnet`` and is not built here.

**Banks.** Convention 4: each network's own training images, on the scale it
was trained at -- the zoo's 40,000-image subset for the ResNet, the 50,000
fast.ai folders for the VGG, both hash-pinned. The *foreign* bank for one
network is the other's corpus, standardised by the network's own statistics
rather than the corpus's, since it is this network's activations being
measured; the source string records which.

Paths outside the repository are not assumed: the VGG trajectory can be
pointed anywhere with ``artifact``, which is what a pod uses.

`parts/chord/`

26 files, 0.01 GB, sent as archive parts/chord.tar.gz
file kinds: .json 26

build_cifar_cell_properties.py docstring:

Measure the cell properties of one CIFAR network at every checkpoint, into parts.

    python scripts/build_cifar_cell_properties.py --net resnet [--pools train test] [--resume]
    python scripts/build_cifar_cell_properties.py --net vgg --thin 9 --quick

The MNIST page's "Cell properties over development" section, on the whole-map
substrates. For each pool and checkpoint: the slope of the output along
straight segments between pairs of images at every cut (``paths``: same-class
and different-class pairs, drawn once at the final checkpoint among images it
classifies correctly and followed over training, as the mean squared
Fisher-Rao speed and the mean unsigned logit slope), and the distance from
single images to the nearest change of prediction (``walls``: a minimal-norm
search, rays toward the nearest other-class images, and random directions).
``experiments.cell_properties`` does the measuring; this script chooses the
images and writes one part per property, pool and checkpoint. ``chords`` is
the MNIST page's web: two correct images of each of ten classes, drawn by
the seed (all ten on CIFAR-10; ten of the hundred on CIFAR-100), and every
pair among them at every cut and checkpoint.

**Where the walls are measured.** On MNIST the walls are at the input. The
VGG's first cut is the image itself, so its walls are at the input too; the
ResNet's first cut is its first block's output, since the image is not one
of its cuts, and its wall distances are distances in that activation space,
which the part's cut says. The two are not the same statistic and the page
labels each by its cut.

The ``train`` pool is a seeded draw from the network's training images, the
``test`` pool from the held-out split; both are filtered to images the final
checkpoint classifies correctly before pairs and items are drawn. The pool's
images go on the page as colour thumbnails with their classes.

build_mnist_cell_properties.py docstring:

Measure the cell properties of the MNIST networks at every checkpoint, into parts.

    python scripts/build_mnist_cell_properties.py [--nets plain,res,tanh] [--pools train,test]
        [--properties paths,walls,chords,pathwalls] [--steps ...] [--resume] [--quick]

For each network, pool and checkpoint: the slope of the output along straight
segments between pairs of images at every cut (``paths``: same-class and
different-class pairs, drawn once at the final checkpoint among correctly
classified images and followed over training), and the distance from single
images to the nearest change of prediction at the input (``walls``: a
minimal-norm search, rays toward the nearest other-class images, and random
directions), and the same slope along every segment among a few images per
class (``chords``: ``--per-class`` images of each digit, every pair among
them, the web the page draws with its chords shaded by the running integral).
``pathwalls`` segments the same paths into plateaus and walls by two levels
of ||Ju|| read from that network's own pooled slope histogram, the plateau
mode and the trough above it, and measures each wall's thickness, height,
sharpness and contrast, remeasuring each wall on a finer grid. Two
conventions are written side by side: the levels of the first checkpoint
whose trough is empty (or the deepest, if it never empties) held fixed over
the run, and each checkpoint's own levels, which drift with the plateau; a
checkpoint whose histogram has one mode gets no drifting part, and a network
whose histogram never splits gets no fixed one, and both say so.
``experiments.cell_properties`` does the measuring; this script chooses the
images and writes one part per property, pool and checkpoint.

The ``train`` pool is what the network trained on: the thousand images of the
pair's recipe, the first 4,000 training images for the tanh network. The
``test`` pool is the first 4,000 test images. Both are filtered to images the
final checkpoint classifies correctly before pairs and items are drawn.

build_modular_cell_properties.py docstring:

Measure the cell properties of the modular-addition network at every checkpoint, into parts.

    python scripts/build_modular_cell_properties.py [--run NAME] [--pools train,test]
        [--properties paths,walls,chords] [--steps ...] [--resume] [--quick]

For each pool and checkpoint: the slope of the output along straight segments
between pairs of bank items at every cut (``paths``: same-sum and
different-sum pairs, drawn once at the final checkpoint among correctly
classified pairs and followed over training), the distance from single items
to the nearest change of prediction at the embed cut (``walls``), and the same
slope along every segment among a few items per class (``chords``: two pairs
of each of ``--chord-classes`` residues drawn by the seed, since p classes at
two nodes each would be tens of thousands of chords where the MNIST web has
190). ``experiments.cell_properties`` does the measuring.

The ``train`` pool is the pairs the network was fitted to; the ``test`` pool
is the held-out pairs of the same split. Both are filtered to pairs the final
checkpoint classifies correctly before pairs and items are drawn. The class of
a pair is its sum modulo p, which is its own name, so the nodes part carries
labels and no thumbnails.

`parts/cifar/`

8072 files, 0.59 GB, sent as archive parts/cifar.tar.gz
file kinds: .json 8072

scripts that name this directory: scripts/build_pages.py, scripts/cifar_nets.py, scripts/modal/cifar.py, src/cells_developmental/report/directions.py

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

`parts/gemma_3_270m/`

43 files, 0.00 GB, sent as archive parts/gemma_3_270m.tar.gz
file kinds: .json 43

scripts that name this directory: scripts/backfill_parameter_counts.py, scripts/build_pages.py, scripts/hf_upload_checkpoints.py

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

`parts/gpt2medium/`

802 files, 0.05 GB, sent as archive parts/gpt2medium.tar.gz
file kinds: .json 802

scripts that name this directory: scripts/backfill_parameter_counts.py, scripts/build_pages.py, scripts/hf_upload_checkpoints.py, scripts/language_nets.py

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

`parts/gptxl/`

674 files, 0.08 GB, sent as archive parts/gptxl.tar.gz
file kinds: .json 674

scripts that name this directory: scripts/backfill_parameter_counts.py, scripts/build_light_page.py, scripts/build_pages.py, scripts/hf_upload_checkpoints.py, scripts/language_nets.py

build_light_page.py docstring:

Build a reduced GPT-2 XL page from a subset of its parts, for distribution.

The full page draws 77 MB of frames: the 1d ensembles at every one of the 48
cuts, twenty 2d patches at each of four cuts, and the Cells planes. The reduced
page has the same shape over a subset: the 1d ensembles at a few cuts, the
first base or two of every 2d family at every measured cut, every Cells plane
and every attenuation curve. It is assembled from a store of symlinks into the
full one, so what it keeps carries exactly the full page's numbers, and its
banner states what was left out, counted from the parts rather than written.

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

`parts/katago_b18c384nbt/`

577 files, 0.07 GB, sent as archive parts/katago_b18c384nbt.tar.gz
file kinds: .json 577

scripts that name this directory: scripts/build_katago_sweeps.py, scripts/build_pages.py, scripts/fetch_inputs.py, scripts/modal_katago_sweeps.py, scripts/pin_katago_inputs.py, src/cells_developmental/report/payload.py

build_katago_sweeps.py docstring:

Measure the page sections for the KataGo b18c384nbt series over its pinned checkpoints.

    python scripts/build_katago_sweeps.py --device cuda --resume
    python scripts/build_katago_sweeps.py --steps 1 --cuts block08 --sections 1d --scans 2

The same measurements as the CIFAR and language pages, on KataGo through
:mod:`cells_developmental.models.katago`, at every checkpoint the manifest
pins (``--steps N`` thins the axis evenly, ``--step S`` takes one). Each part
is written as it finishes and ``--resume`` skips parts already in the store,
so an interrupted run keeps what it did.

*Site substrate* for every section: a state is the trunk's channel vector at
tengen, the host position's board and global scalars around it.

*1d*: the rotation ensembles, both frames and both base families, on the
sweep's cuts. *2d*: the constant-radius patches, response and forward-mode
rate, on the grid cuts, for a real position, a scrambled one and a position of
random legal play as long as the real one. *Cells*: the
plane through three real activations on the GPT-2 pages' axes, with the
Fisher-whitened rate from probes; no regions, since the network is Mish
(convention 6). *map2d*: the 2d patches again on the whole-map substrate, on a
smaller bank, with only the output reads kept.

**The bank** is the model's own training distribution (convention 4): rows of
the pinned kata1 training shard, self-play positions written with the model's
input features by the run's own data writer.

**Cost.** A forward pass is 19x19 through 18 nested-bottleneck blocks at 384
channels, about the cost of a small vision model; the exact Jacobian of the
policy's 362 outputs with respect to a 384-vector site is cheap, and the map
substrate's 138k-wide states are why its section is separate and its bank
smaller. Measure one checkpoint before quoting a total.

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

modal_katago_sweeps.py docstring:

Run the KataGo sweeps on a Modal GPU and bring the parts back.

    modal run scripts/modal_katago_sweeps.py::push_inputs      # once: checkpoints and shard
    modal run scripts/modal_katago_sweeps.py --sections cells,1d,2d --steps 9
    modal volume get cells-developmental-parts katago_b18c384nbt out/parts/

The measurement is exactly ``scripts/build_katago_sweeps.py``; this only moves
it somewhere with a GPU. The pinned inputs are not downloaded inside the
container: ``push_inputs`` copies the verified checkpoints under ``out/katago``
and the shard games under ``data/katago`` from this machine into an inputs
volume, so the container measures the same bytes the manifests pin, and the
sweep verifies them again before loading. One container per checkpoint, so
the nine checkpoints run side by side; parts land in the shared parts volume
under ``katago_b18c384nbt``, where ``build_pages.py`` looks once fetched.

`parts/language_light/`

138 files, 0.02 GB, sent as archive parts/language_light.tar.gz
file kinds: .json 138

scripts that name this directory: scripts/build_light_page.py, scripts/publish_tree.py

build_light_page.py docstring:

Build a reduced GPT-2 XL page from a subset of its parts, for distribution.

The full page draws 77 MB of frames: the 1d ensembles at every one of the 48
cuts, twenty 2d patches at each of four cuts, and the Cells planes. The reduced
page has the same shape over a subset: the 1d ensembles at a few cuts, the
first base or two of every 2d family at every measured cut, every Cells plane
and every attenuation curve. It is assembled from a store of symlinks into the
full one, so what it keeps carries exactly the full page's numbers, and its
banner states what was left out, counted from the parts rather than written.

`parts/mnist/`

80928 files, 18.56 GB, sent as archive parts/mnist.tar.gz
file kinds: .json 80928

scripts that name this directory: scripts/backfill_cells_labels.py, scripts/build_pages.py, scripts/census_grid_edges.py, scripts/fetch_inputs.py, scripts/mnist_nets.py, scripts/publish_tree.py, scripts/train_paper_mlp.py, src/cells_developmental/banks.py, src/cells_developmental/report/directions.py

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

census_grid_edges.py docstring:

Census of plateau edges on the 2d grids: where, along each ray from the base, the
response first reaches half its settled level, and where the rate peaks.

The grid's two coordinates are polar coordinates of a patch of the sphere, so
the total rotation at a point is sqrt(t1**2 + t2**2): 90 degrees on the axes'
ends and 127 at the corners. This walks every grid part, casts rays from the
base every five degrees of azimuth, and records the edge angle along each
ray (the project's ``plateau_edge`` convention applied ray by ray) and the
angle at which the rate is largest. A part's boundary "passes 90 degrees"
when some ray's edge lies beyond 90, or a ray toward a corner never crosses
the threshold before leaving the frame.

    .venv/bin/python scripts/census_grid_edges.py --csv out/census/grid_edges.csv mnist vgg_cifar10
    .venv/bin/python scripts/census_grid_edges.py --summary out/census/grid_edges.csv

train_paper_mlp.py docstring:

Train the grokking paper's MNIST MLP and its minimal residual pair.

    python scripts/train_paper_mlp.py [--steps 100000] [--hidden-layers 3] [--out DIR]
        [--members plain,res] [--seed 0]
        [--noise-cut h1 --noise-level 0.1 [--noise-start 0] [--noise-stop N]]

Their recipe, from the vendored config: a thousand training points, batch 200,
AdamW at 1e-3 with decay 0.01, MSE against one-hots, width 200, depth 4. The
two networks differ in one thing -- identity paths around the hidden layers --
so anything that differs between them is attributable to the skips.

``--hidden-layers`` trains a deeper pair with the same recipe: ``n`` hidden
layers of width 200 is depth ``n + 1``. The default three is theirs and writes
the tags ``plain`` and ``res`` under ``out/paper_mlp``; any other count writes
``plain-h<n>`` and ``res-h<n>`` beside them, so the depth-4 artifacts the
pages were measured from are never overwritten.

Two further departures, each recorded in the tag and the inventory so that the
artifacts they produce sit beside the pair without displacing it. ``--seed``
other than 0 appends ``-s<seed>``: the initialisation, the trained-on thousand
and the batch order all derive from it, so a second seed is a replicate of the
recipe and the spread between replicates is what an intervention is judged
against. ``--noise-cut`` with ``--noise-level`` trains with Gaussian noise added
to the state at that cut on every training forward pass, sized per sample as
``level`` times its own state norm (the attenuation panel's construction, so a
level here and a level there name the same perturbation), and appends
``-noise-<cut>-<level>``; ``--noise-start`` and ``--noise-stop`` confine it to a
window of steps and append ``-w<start>-<stop>``. Evaluation and the stored
weights are always clean. ``--members`` restricts the run to one member.

Both are ReLU with no normalisation, so both are exactly piecewise linear and
admit an exact partition, which the repository's tanh substrate never can.

`parts/mnist_retired/`

4386 files, 0.06 GB, sent as archive parts/mnist_retired.tar.gz
file kinds: .json 4386
no script under the search roots names this directory (check the README beside it)

`parts/modular/`

8647 files, 0.51 GB, sent as archive parts/modular.tar.gz
file kinds: .json 8647

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

train_modular_transformer.py docstring:

Train the one-layer transformer on modular addition and keep its trajectory.

    python scripts/train_modular_transformer.py [--p 113] [--steps 40000] [--seed 0]
        [--split-seed 0] [--device cpu] [--resume]

Writes ``out/modular_transformer/<run>/``: ``config.json`` (architecture,
recipe and ``arch: transformer`` so the run opens through
``scripts/modular_nets.py``), one ``step*.pt`` per checkpoint holding the
weights and the evaluation there, ``metrics.json`` with every evaluation,
and ``latest.pt`` with the optimiser state for ``--resume``. Checkpoints fall
on a logarithmic grid and at every evaluation where the test accuracy has
moved, so the transition is dense. Every file is written as it is reached,
so an interrupted run keeps what it did.

`parts/modular_transformer/`

12840 files, 0.42 GB, sent as archive parts/modular_transformer.tar.gz
file kinds: .json 12840

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

train_modular_transformer.py docstring:

Train the one-layer transformer on modular addition and keep its trajectory.

    python scripts/train_modular_transformer.py [--p 113] [--steps 40000] [--seed 0]
        [--split-seed 0] [--device cpu] [--resume]

Writes ``out/modular_transformer/<run>/``: ``config.json`` (architecture,
recipe and ``arch: transformer`` so the run opens through
``scripts/modular_nets.py``), one ``step*.pt`` per checkpoint holding the
weights and the evaluation there, ``metrics.json`` with every evaluation,
and ``latest.pt`` with the optimiser state for ``--resume``. Checkpoints fall
on a logarithmic grid and at every evaluation where the test accuracy has
moved, so the transition is dense. Every file is written as it is reached,
so an interrupted run keeps what it did.

`parts/pythia410m/`

2943 files, 0.55 GB, sent as archive parts/pythia410m.tar.gz
file kinds: .json 2943

scripts that name this directory: scripts/backfill_parameter_counts.py, scripts/build_pages.py, scripts/build_pythia_sweeps.py, scripts/census_logit_pairs.py, scripts/hf_upload_checkpoints.py

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

build_pythia_sweeps.py docstring:

Measure the perturbation sections for a Pythia model, checkpoint by checkpoint.

    python scripts/build_pythia_sweeps.py --data-root ~/pythia --download [--device cuda]
    python scripts/build_pythia_sweeps.py --model 410m --steps 143000 --sections 1d,attenuation

The same measurements as the MNIST and GPT-2 XL pages, on the language
substrates whose training axis is real: every released checkpoint of a Pythia
model, pinned by SHA-256 in ``configs/inputs/pythia_pile_<size>.yaml``. Which
model is ``--model``; each has its own manifest and its own parts directory,
and nothing else differs between them.

**Every section in one pass over the checkpoints.** Holding the whole axis is
25.6 GB for the 70m model and 140 GB for the 410m one, so a checkpoint is
fetched, verified, measured and discarded. That makes the checkpoint, not the
arithmetic, the thing worth not repeating: measuring the 1d section now and the
2d section later would transfer the axis twice. So each checkpoint is measured
for everything wanted from it before it is deleted, and ``--keep`` holds them
where there is disk to spare.

The sweep follows the MNIST page's shape:

*1d*, at every checkpoint: every cut by five seeds by two rotation frames by
two base families, forty scans over fifty-five angles.

*Attenuation*, at every checkpoint, opt-in through ``--sections``: Arora et
al.'s noise-stability curve from a few injection cuts to every readout below
them, both base families, in the layout of the GPT-2 XL panel.

*2d by training time*, at every checkpoint: three cuts, one plane, every base
type, three base points each, which is the panel the training slider drives.

*2d by depth*, at the final checkpoint only: every cut by every base type by
every plane, which is the explorer panel. Depth is a property of the trained
network, and repeating it at 154 checkpoints would cost more than everything
else here put together. ``--depth-cuts`` and ``--depth-planes`` restrict it
where a 24-layer model makes the full product unaffordable, ``--real-bases``
gives the real prompts more examples than the constructed kinds, and
``--foreign`` adds the sixth base kind the GPT-2 XL page has: prose from the
other model's corpus, here OpenWebText through Pythia's own tokenizer.

...

`parts/pythia70m/`

13617 files, 0.56 GB, sent as archive parts/pythia70m.tar.gz
file kinds: .json 13617

scripts that name this directory: scripts/backfill_parameter_counts.py, scripts/build_pages.py, scripts/build_pythia_sweeps.py, scripts/hf_upload_checkpoints.py

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

build_pythia_sweeps.py docstring:

Measure the perturbation sections for a Pythia model, checkpoint by checkpoint.

    python scripts/build_pythia_sweeps.py --data-root ~/pythia --download [--device cuda]
    python scripts/build_pythia_sweeps.py --model 410m --steps 143000 --sections 1d,attenuation

The same measurements as the MNIST and GPT-2 XL pages, on the language
substrates whose training axis is real: every released checkpoint of a Pythia
model, pinned by SHA-256 in ``configs/inputs/pythia_pile_<size>.yaml``. Which
model is ``--model``; each has its own manifest and its own parts directory,
and nothing else differs between them.

**Every section in one pass over the checkpoints.** Holding the whole axis is
25.6 GB for the 70m model and 140 GB for the 410m one, so a checkpoint is
fetched, verified, measured and discarded. That makes the checkpoint, not the
arithmetic, the thing worth not repeating: measuring the 1d section now and the
2d section later would transfer the axis twice. So each checkpoint is measured
for everything wanted from it before it is deleted, and ``--keep`` holds them
where there is disk to spare.

The sweep follows the MNIST page's shape:

*1d*, at every checkpoint: every cut by five seeds by two rotation frames by
two base families, forty scans over fifty-five angles.

*Attenuation*, at every checkpoint, opt-in through ``--sections``: Arora et
al.'s noise-stability curve from a few injection cuts to every readout below
them, both base families, in the layout of the GPT-2 XL panel.

*2d by training time*, at every checkpoint: three cuts, one plane, every base
type, three base points each, which is the panel the training slider drives.

*2d by depth*, at the final checkpoint only: every cut by every base type by
every plane, which is the explorer panel. Depth is a property of the trained
network, and repeating it at 154 checkpoints would cost more than everything
else here put together. ``--depth-cuts`` and ``--depth-planes`` restrict it
where a 24-layer model makes the full product unaffordable, ``--real-bases``
gives the real prompts more examples than the constructed kinds, and
``--foreign`` adds the sixth base kind the GPT-2 XL page has: prose from the
other model's corpus, here OpenWebText through Pythia's own tokenizer.

...

`parts/pythia70m_ctxsmoke/`

5 files, 0.00 GB, sent as archive parts/pythia70m_ctxsmoke.tar.gz
file kinds: .json 5
no script under the search roots names this directory (check the README beside it)

`parts/pythia70m_hosttest/`

48 files, 0.00 GB, sent as archive parts/pythia70m_hosttest.tar.gz
file kinds: .json 48
no script under the search roots names this directory (check the README beside it)

`parts/smoke_gpt2_cells/`

5 files, 0.00 GB, sent as archive parts/smoke_gpt2_cells.tar.gz
file kinds: .json 5
no script under the search roots names this directory (check the README beside it)

`parts/smoke_mps/`

0 files, 0.00 GB, sent as loose files
file kinds:
no script under the search roots names this directory (check the README beside it)

`parts/unit_flips/`

21 files, 0.00 GB, sent as archive parts/unit_flips.tar.gz
file kinds: .json 18, .log 3
provenance files inside: context_session_failed_attempt1.log, session.log, context_session.log

scripts that name this directory: scripts/scratch_unit_flips.py

scratch_unit_flips.py docstring:

Scratch: which nonlinear units downstream of a cut change state under a rotation, by angle.

    python scripts/scratch_unit_flips.py --net resnet --cuts layer1.0 layer3.0 --device cpu
    python scripts/scratch_unit_flips.py --net vit --cuts block00 block06 --device cpu
    python scripts/scratch_unit_flips.py --net gpt2 --repo gpt2-medium --cuts L1 L6 L12 \\
        --download --stream-buffer 20000 --last-position
    python scripts/scratch_unit_flips.py --net vit-context --cuts block00 block06 --first-position
    python scripts/scratch_unit_flips.py --net gpt2 --context --repo gpt2-medium --cuts L1 L6 L12 \\
        --download --stream-buffer 20000 --last-position

For each real base and each direction (isotropic and covariance-Gaussian, the 1d
panel's two families, mean removed), the state is rotated about the origin by
each angle and run through the substrate's suffix with a pre-hook on every ReLU
or GELU module, recording the fraction of units whose side of the threshold
differs from the base's, per activation site and pooled over sites. The chord
displacement relative to the base norm is printed beside each angle, so
networks can be compared on either ruler. Also recorded: the share of units at
the first downstream site whose pre-activation lies within a small fraction of
that site's spread of the threshold, a margin statistic independent of any
perturbation.

On a token substrate the perturbed state is one position inside a held
context, and only that position's units can change, so ``--last-position``
reads the hooks at the last position alone rather than diluting the count
with the context's untouched units. On a context substrate every position is
rotated by the same angle within its own space (the per-position family), and
the same position is read, so the two runs differ only in the perturbation's
support.

Results are printed and written as JSON under ``out/parts/unit_flips/``, one
file per network and cut, so a pod's collector can bring them home.

`parts/vgg_cifar10/`

7872 files, 0.45 GB, sent as archive parts/vgg_cifar10.tar.gz
file kinds: .json 7872

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

census_grid_edges.py docstring:

Census of plateau edges on the 2d grids: where, along each ray from the base, the
response first reaches half its settled level, and where the rate peaks.

The grid's two coordinates are polar coordinates of a patch of the sphere, so
the total rotation at a point is sqrt(t1**2 + t2**2): 90 degrees on the axes'
ends and 127 at the corners. This walks every grid part, casts rays from the
base every five degrees of azimuth, and records the edge angle along each
ray (the project's ``plateau_edge`` convention applied ray by ray) and the
angle at which the rate is largest. A part's boundary "passes 90 degrees"
when some ray's edge lies beyond 90, or a ray toward a corner never crosses
the threshold before leaving the frame.

    .venv/bin/python scripts/census_grid_edges.py --csv out/census/grid_edges.csv mnist vgg_cifar10
    .venv/bin/python scripts/census_grid_edges.py --summary out/census/grid_edges.csv

train_vgg_cifar10.py docstring:

Train the VGG-19 substrate on CIFAR-10, on Arora et al.'s recipe.

    python scripts/train_vgg_cifar10.py --epochs 299 --device cuda
    python scripts/train_vgg_cifar10.py --smoke                       # proves it runs
    python scripts/train_vgg_cifar10.py --resume-from out/vgg_cifar10/epoch_30.pt --start-epoch 30

The recipe is theirs where the paper states it: SGD with momentum 0.9, weight
decay 5e-4, batch 128, the learning rate halved every thirty epochs, random
crop and horizontal flip, 299 epochs, dropout in the fully connected layers.
Two things are ours, and both are forced. The initial rate is 0.02 rather than
their 0.05, because a plain VGG-19 sits at a loss of exactly ln(10) at 0.05 and
never leaves it -- we tried, twice, on two machines. And the network is
Kaiming-initialised, as torchvision's VGG is, for the same reason. At 0.02 it
reaches 92.3 percent on their schedule against their 92.45.

Checkpoints are written on a grid -- 1, 2, 5, 10, 20, the last epoch, and every
``--marks`` epochs -- because the attenuation is a property that appears during
training, and a final checkpoint alone cannot say when. The data are the pinned
CIFAR-10 folders under ``data/cifar10``, verified by ``scripts/fetch_inputs.py``;
``--data`` also accepts torchvision's python-batch layout, which is what a pod
that downloads the set itself will have.

`parts/vit_cifar100/`

650 files, 0.02 GB, sent as archive parts/vit_cifar100.tar.gz
file kinds: .json 650

scripts that name this directory: scripts/build_pages.py, scripts/cifar_nets.py, scripts/modal/cifar.py

build_pages.py docstring:

Assemble the family of directions pages from whatever parts exist.

    python scripts/build_pages.py

Every page has the same shape: the family row, a tab per section, and the
sections themselves. A page is built from the parts currently in its store, so
a substrate that has not been measured yet still gets a page -- one that says
plainly that it is a placeholder rather than showing an empty figure.

Sections are added here as their measurements are written. What is not in the
store does not appear, and nothing is faked to fill a gap.

Provenance for bgradowhite/cells-developmental

Source repository at backup time

Directories

census/

chord/

cifar_zoo/

figures/

mnist_dense/

mnist_dense-b5/

mnist_dense-b6/

mnist_task/

modular/

modular_transformer/

paper_mlp/

paper_mlp_100k/

parts_retired/

pod_logs_pythia410m/

queue/

vgg_cifar10/

vit_zoo/

parts/chord/

parts/cifar/

parts/gemma_3_270m/

parts/gpt2medium/

parts/gptxl/

parts/katago_b18c384nbt/

parts/language_light/

parts/mnist/

parts/mnist_retired/

parts/modular/

parts/modular_transformer/

parts/pythia410m/

parts/pythia70m/

parts/pythia70m_ctxsmoke/

parts/pythia70m_hosttest/

parts/smoke_gpt2_cells/

parts/smoke_mps/

parts/unit_flips/

parts/vgg_cifar10/

parts/vit_cifar100/

Provenance for `bgradowhite/cells-developmental`

`census/`

`chord/`

`cifar_zoo/`

`figures/`

`mnist_dense/`

`mnist_dense-b5/`

`mnist_dense-b6/`

`mnist_task/`

`modular/`

`modular_transformer/`

`paper_mlp/`

`paper_mlp_100k/`

`parts_retired/`

`pod_logs_pythia410m/`

`queue/`

`vgg_cifar10/`

`vit_zoo/`

`parts/chord/`

`parts/cifar/`

`parts/gemma_3_270m/`

`parts/gpt2medium/`

`parts/gptxl/`

`parts/katago_b18c384nbt/`

`parts/language_light/`

`parts/mnist/`

`parts/mnist_retired/`

`parts/modular/`

`parts/modular_transformer/`

`parts/pythia410m/`

`parts/pythia70m/`

`parts/pythia70m_ctxsmoke/`

`parts/pythia70m_hosttest/`

`parts/smoke_gpt2_cells/`

`parts/smoke_mps/`

`parts/unit_flips/`

`parts/vgg_cifar10/`

`parts/vit_cifar100/`