| # 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, <none> 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 |
| - 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. |
| ``` |
|
|
| ### `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 |
| - 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. |
| ``` |
|
|
| ### `parts/modular_transformer/` |
| |
| - 12840 files, 0.42 GB, sent as archive `parts/modular_transformer.tar.gz` |
| - file kinds: .json 12840 |
| - 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. |
| ``` |
|
|
| ### `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 |
| - 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. |
| ``` |
|
|
| ### `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. |
| ``` |
|
|
