Replicate #46 Phase 1 on a second machine: silent_activation.json has one provenance and §0c rests on it

analysis_out/silent_activation.json (#46 Phase 1, merged in #99) has been produced exactly once, on one machine — a local RTX 3070. Every number in docs/curb_ramp_data_sourcing.md §0c's Phase 1 half derives from it: the 10 / 39 / 79 decomposition, the null percentiles, the 3 / 12 / 19 split of the far-field rated-visible population, and the 6-of-45 near-field count the 0.013 sourcing estimate now leans on.

Phase 0 is fine — it reads committed caches only, and tests/test_farfield_forensics.py::test_main_reproduces_the_committed_result_json_byte_for_byte re-runs it and compares bytes on every CI run. Phase 1 cannot do that: it needs the native-res panoramas and a GPU, so what CI checks instead is that the artifact is self-consistent with the pure functions shipped beside it (seam regenerates from x, above_own_null_p95 from act and null_p95, the class counts from class_of). That is a good guard against the file drifting from the code. It is not a demonstration that the file is reproducible.

Against the repo's own bar — could a new student clone this, obtain every input, re-run it, and get our numbers? — Phase 1 is currently answered by argument rather than by evidence.

What to run

python scripts/analysis/silent_activation.py \
    --panos-root <checkout holding benchmark/*/panos> \
    --json-out analysis_out/silent_activation_replica.json

Inputs are all published: the panoramas are the HF dataset projectsidewalk/rampnet-benchmark; the checkpoint is projectsidewalk/rampnet-model; the caches, witness list, gallery manifest and verdicts are committed. ~20 minutes on one GPU for 128 misses across 108 panoramas.

What we actually learn

Three outcomes, and all three are worth having:

1. Byte-identical. Phase 1 joins Phase 0 as demonstrably reproducible, and the §0c numbers get a second provenance.
2. Numerically identical, bytes differ. Tells us where the float noise lives and lets us state a tolerance instead of guessing one.
3. Values move. Then we learn the size of GPU/driver/cuDNN nondeterminism on this pipeline — which is a fact worth knowing well beyond this analysis, since operating_point_curve.py extract produced every committed cache the same way and has never been re-run either.

Outcome 3 is the reason this is worth doing on purpose rather than as a side effect of some other change: if the numbers move, we want that isolated and measured, not discovered while explaining something else.

Notes

• Run it on a different machine than the original (makelab2's A40, or Hyak) — same-machine agreement is the weaker claim and we half have it already.
• The script pins the run's scope in the payload (cities, panos) and refuses --limit with --json-out, so a partial replica cannot be mistaken for a full one.
• If it does reproduce, fold the check into the docs next to the numbers, and consider whether operating_point_curve.py extract deserves the same treatment on one split as a spot check.
• Do not overwrite analysis_out/silent_activation.json with the replica. Write it alongside and compare; if they differ, that difference is the result.

Refs #46 (the study), #99 (where Phase 1 landed and where this gap was recorded), #21 / projectsidewalk/rampnet-benchmark (the imagery).

🤖 Generated with Claude Code (claude-opus-5[1m])

Run scripts/analysis/silent_activation.py with the published panoramas, checkpoint, and caches on a different GPU machine, writing analysis_out/silent_activation_replica.json. Compare the replica with analysis_out/silent_activation.json and determine whether the result is byte-identical, numerically identical with byte differences, or materially different. Record the outcome and update docs/curb_ramp_data_sourcing.md §0c if appropriate.