| # Status against the 12-week plan |
|
|
| **2026-09-13 correction:** the historical decoder results below used incorrect |
| intrinsic/FoV supervision and biased validation subsets. They do not establish |
| the value of geometry pretraining. The repaired implementation and its validation |
| are described in [the repair report](reports/repair_20260913.md). Formal training |
| with the repaired code and full test/OOD comparisons remain to be run. |
|
|
| Design-doc section 14 lays out twelve weeks with four go/no-go gates. This maps |
| each row to what exists in this repository, what was *measured*, and what is |
| blocked and why. Nothing below is aspirational: every "done" has a command that |
| reproduces it. |
|
|
| Legend: **done** = implemented and verified with measured numbers · |
| **code-complete** = implemented and unit-tested, not yet run at the doc's scale · |
| **blocked** = cannot be done here, with the reason. |
|
|
| | week | plan | status | evidence | |
| |---:|---|---|---| |
| | 1 | environment, VACE inference, AnyCalib/GeoCalib baselines; 50-image closure report; gate `< 0.05 px` | **done** | `tests/test_cameras.py::test_projection_closure` — all five models close at machine precision (median `0.00e+00`, p99 `< 1e-13` px), against a gate of 0.05 px. Official AnyCalib (320 M) and GeoCalib (28.9 M) checkpoints load and are wrapped as baselines. Our camera models agree with AnyCalib's own implementations to `< 1e-4` deg (`tests/test_third_party_agreement.py`). | |
| | 2 | OpenPano download, trajectory pool, ERP rendering; 200-clip smoke set; no leakage / seam / misalignment | **done** | 749 panoramas fetched. `tools/render_calib_clips.py` produced 200 clips in 285 s with zero split leakage and zero integrity errors. End-to-end render geometry verified to `~7e-6` deg by decoding a coordinate-encoding panorama. | |
| | 3 | three camera models, overlays, QC; 10k-clip MVP; auto QC pass rate `> 99%` | **done** | MVP tier: 11,984 clips from 749 panoramas, AnyCalib's exact 0.34/0.33/0.33 mixture. `tools/validate_dataset.py` gate passes at pass-rate **1.000 on a 400-clip random sample of the MVP tier** with every check enabled, including the two that decode and re-render the stored overlay video; zero clips failed anything. | |
| | 4 | video baselines and solver; single-frame/video table; dense field to parameters converges `> 95%` | **done** | `tools/fit_camera_from_field.py` recovers every clip's parameters: solver success 1.0, family accuracy 1.0, median ray AE `< 1e-3` deg on the generated data. The single-frame / frame-pooled / video table is measured on the MVP test split (`docs/RESULTS.md` section 11), together with the clip-length sweep, which shows the same trained model improving 15.68 -> 11.82 deg from 1 to 17 frames and saturating there. At 4,000 steps (~1.5 epochs) the temporal architecture does not yet pay for its extra parameters, and all three of our models sit 3x behind published AnyCalib -- so the week-4 gate's premise (a saturated simple baseline) does not hold yet. | |
| | 5 | VACE Stage 1a | **gate passed at reduced scale** | `tools/train_vace_overlay.py` with the real Wan2.1-VACE-1.3B checkpoint: 30 layers, dim 1536, 12 heads, 15 VACE blocks, token grid `21 x 30 x 52` — all confirmed against the published config. Rectified-flow objective, frozen base. The overfit gate **passes**: measured at fixed timesteps with fixed noise, the flow-matching loss on a held clip drops 0.648 -> 0.085 (7.6x) over 1,200 steps on 16 clips. Not trained to the doc's 25k steps at 81 frames / 480p, which is 116 GPU-hours on one H200 at the throughput measured in `docs/RESULTS.md`. | |
| | 6 | VACE Stage 1b | **code-complete** | Stage-1b overlays generated for the whole MVP tier with the doc's 40/30/20/10 task mixture; `--stage 1b --resume` continues from Stage 1a. | |
| | 7 | intermediate features and decoder; `L`/`tau` ablation | **runs end to end at reduced scale** | `DiTFeatureHooks` hooks `blocks[L]` and `vace_blocks[k]` and reshapes the padded token sequence back to `[B, 1536, 21, 30, 52]` (verified against the real checkpoint); layer / `tau` / source are arguments with the doc's ablation grids as defaults. `train_geometry_decoder.py --backbone vace` trains a 4.9 M-parameter decoder on the frozen 2.15 B backbone: the loss falls and validation ray AE is produced. What the DiT is fed at time `tau` is the choice that is not obvious and is documented in the code -- the RGB clip's own noised latent, because that is what exists at test time. Not run at the doc's 30k-step budget: the frozen backbone forward is the per-step cost. | |
| | 8 | Lensfun/Optiland profile bank; unseen-lens test set | **done** | Built bank: 6,474 profiles across 1,436 families (6,432 Lensfun + 42 Optiland), all converted to `pixel -> ray`. Distortion families covered: pincushion 2,732, barrel 2,203, negligible 1,326, moustache 177, fisheye 36. Family-level splits give a fully disjoint unseen-family test set (`test_families_unseen_fraction = 1.0`). Two gaps documented rather than hidden: 4,255 of the profiles are near-duplicates, and no open source covers decentred distortion (correction 7). | |
| | 9 | TUM VI / KITTI-360 / ADT evaluation | **blocked** | KITTI-360 and ADT need registration; TUM VI is public but was not fetched. Adapters and the fetcher exist (`tools/build_trajectories.py --source tumvi`, `fetch.py info kitti360`). | |
| | 10 | real 7V GT and fine-tuning | **blocked** | Needs the vehicle, the rig and the calibration workflow. The manifest fields, split policy and weak-GT weighting are implemented. | |
| | 11 | full ablations, downstream VIO/3DGS | **partial** | `AblationTable` tracks all 22 ablations the doc lists and reports coverage. Downstream: straight-line residual and rectification-flow error are implemented detector-free and verified exact for a correct camera; VIO/SLAM and 3DGS are declared and explicitly marked not-run. | |
| | 12 | paper and open-source cleanup; data card, model card | **done** for the repository | `docs/DATA.md`, `docs/CONVENTIONS.md`, this file, `docs/RESULTS.md`. Every experiment is reproducible from a manifest plus a config; every generated clip records its generator version, encoder settings and SHA-256. | |
|
|
| ## The four gates |
|
|
| 1. **Week 3 — "if the synthesiser's closure is not exact, stop all training."** |
| Passed with margin: projection closure is at machine precision, `10^12` times |
| better than the 0.05 px gate, and the end-to-end render (unproject, rotate, |
| ERP map, sample, decode) closes to `~7e-6` deg. |
| 2. **Week 4 — "if a simple video baseline already saturates, redefine VACE's |
| value as cross-domain generalisation rather than average accuracy."** |
| **Answered: it has not saturated.** All three of our trained baselines sit at |
| 9.5-11.8 deg median ray AE against published AnyCalib's 3.42 deg on the same |
| test clips through the same metric code -- 3x of headroom, so redefining |
| VACE's value on saturation grounds would be premature. Two supporting |
| measurements: the clip-length sweep shows the same trained model improving |
| 15.68 -> 11.82 deg from 1 to 17 frames and saturating there, so frames do |
| carry usable information; and temporal aggregation alone cuts gravity error |
| 10x versus a single frame (1.29 -> 0.13 deg) with no learned model at all. |
| What *did* not pay off at this budget is the temporal *architecture*: at |
| 4,000 steps it has 36% more parameters than the frame-pooled model and is |
| worse than it. See `docs/RESULTS.md` section 11 for the caveats, chiefly that |
| clean renders from a static panorama are the regime where aggregation should |
| help least. |
| 3. **Week 7 — "if VACE features are no better than a small video network, cut |
| the generative training."** Not reached; the decision requires the Stage-1a/1b |
| training budget. |
| 4. **Week 10 — "if the real 7V domain gap persists, fix the ISP/crop/EIS |
| metadata first."** Not reached; blocked on the rig. |
|
|
| ## Corrections to the design doc |
|
|
| Found while implementing, and fixed here rather than reproduced: |
|
|
| 1. **Feature cache arithmetic (section 10).** The doc says caching raw DiT |
| features for 50k clips is "about 4.8 PiB". 96 MiB x 50,000 = **4.6 TiB**; the |
| figure is 1000x too large. The conclusion (do not cache at scale) is |
| unaffected, and `feature_bytes_per_clip` documents both numbers. |
| 2. **Residual field versus prediction noise (sections 11.1, 17.3).** The doc's |
| rule — declare a lens non-parametric when the edge residual stays large — |
| fires on *white noise* of the same magnitude. Measured: 0.5 deg of isotropic |
| ray noise produced an edge P95 of 1.23 deg, well over the 0.25 deg threshold, |
| with no lens residual present at all. Added `residual_structure`, the spatial |
| autocorrelation of the *signed* tangent residual: 0.002 for white noise, |
| 0.989 for a smooth lens residual, 0.668 for a mixture. Selection now requires |
| both a large edge residual *and* spatial structure. |
| 3. **Trajectory amplitudes are duration-dependent.** The doc's motion families |
| are specified for the reference 81-frame, 16 fps (5 s) clip. Reusing the same |
| amplitudes for a 9-frame clip packs the same rotation into 0.5 s and violates |
| the angular-velocity limit. `duration_scale` now scales amplitudes with clip |
| duration so the *rates* stay constant; violations across 5 clip lengths x 6 |
| seeds x 200 clips are zero. |
| 4. **The global head needs supervision.** The head that section 10 specifies |
| (FoV, principal point, gravity, uncertainty) received no gradient in the first |
| implementation, because the loss list of section 11 never references it — yet |
| section 11.1 step 2 uses its output to initialise the solver. Added FoV, |
| principal-point, clip-level-gravity and uncertainty-calibration terms; a test |
| now asserts every head receives finite gradients. |
| 5. **EUCM's sampled `alpha`/`beta` range exceeds the stated FoV range.** The |
| example parameters in section 7.4 (`alpha=0.63, beta=1.34, fx=241` at 832 px |
| wide) give a ~253 deg horizontal FoV, not the `<= 180 deg` the section-7.2 |
| sampling range implies. The sampler therefore solves for the focal length from |
| a *target* FoV and rejects on the achieved FoV, rather than sampling |
| `alpha`/`beta`/`f` independently. |
| 6. **`Stage-1b` colour encodings must be decodable.** The doc asks for |
| perceptual colour maps ("latitude continuous colour map"). A perceptual map is |
| not invertible, so the target cannot be validated. Both are provided: |
| `perceptual` for contact sheets and papers, and an invertible `codec` family |
| used as the actual generation target, with round-trip error through 8-bit |
| video measured at 0.18 deg (latitude), 0.06 deg (up), 0.22 deg (ray). |
|
|
| 7. **The open profile bank cannot cover decentred distortion.** Section 8.3 |
| grades the bank on covering barrel, pincushion, moustache, fisheye *and* |
| "clearly asymmetric / decentred residuals", and section 8.1 presents the |
| open path as an equivalent substitute for LensView. It is not, on that last |
| family: Lensfun's three present models (`ptlens`, `poly3`, `poly5`) are |
| radial in one variable, the database holds no `acm` entries (the only format |
| with tangential terms), and Optiland's sample designs are centred. Measured |
| on the built bank: `p1`, `p2` fitted from 120 real profiles stay within |
| `+-2e-4` of zero. The v1 synthetic sampling does not fill the gap either, |
| because it follows AnyCalib's `radial:1` with `p1 = p2 = 0`. Decentring is |
| therefore carried only by the non-parametric residual field, which represents |
| it but provides no training signal for it. `docs/DATA.md` states this rather |
| than letting the family counts imply coverage. |
|
|
| 8. **The ray and gravity angular losses cannot be `arccos`.** Section 11 |
| specifies `acos(clamp(r_pred . r_gt))`, which is the right *metric* and the |
| wrong *loss*: its derivative is `-1/sqrt(1 - cos^2)`, infinite at zero error. |
| Measured here -- at exactly zero error `arccos` produces a **NaN gradient**; |
| at 1e-7 rad it produces a gradient of **2.7e7**. The consequence is that a |
| run turns to NaN precisely because it started fitting, which is how this was |
| found: the decoder overfit gate reached ~0 gravity error at step ~200 and |
| every loss term went NaN together. `stable_angle` uses the half-angle form |
| `2 * atan2(||a - b||, ||a + b||)`, which agrees with `arccos` to 4e-9 degrees, |
| has a bounded derivative (0.203 at 1e-7 rad), and is used by every angular |
| *loss*; `arccos` stays in the metrics, where no gradient is taken. |
| `tests/test_geometry.py` asserts both the agreement and that the bad case is |
| still bad, so the two cannot be confused again. |
|
|
| 9. **"Single frame" has to mean one frame.** Doc section 15 asks for a |
| capacity-matched single-frame baseline. The obvious implementation -- take the |
| video network and delete the temporal blocks -- is *not* one: it still ingests |
| every frame of the clip and pools them into the clip-level ray field, so it |
| measures whether explicit temporal mixing helps, not whether video beats a |
| single frame. Verified structurally: with `temporal=False` the encoder has 0 |
| `SpaceTimeBlock` and the decoder 0 `TemporalAttention`, yet a 17-frame input |
| still produces one clip-level ray field. The three configurations are now |
| distinct and separately named -- `video` (temporal mixing over N frames), |
| `frame_pooled` (no temporal mixing, N frames pooled), and `single_frame` |
| (same architecture, `--frames` forced to 1) -- because the first version's |
| naming would have turned a temporal-mixing ablation into an unsupported claim |
| about video versus single frame. |
|
|
| ## Implementation findings |
|
|
| Not errors in the plan -- integration details that fail silently or |
| confusingly, recorded so they are not rediscovered. |
|
|
| * **`enable_gradient_checkpointing` was a no-op.** The natural first |
| implementation sets a flag on each block; the upstream Wan blocks never read |
| it, so nothing changed and the 81-frame 480p step OOMed at over 90 GiB. It now |
| wraps all 45 block forwards in `torch.utils.checkpoint` with |
| `use_reentrant=False` (required -- the blocks take keyword arguments), and the |
| same step runs in 41.7 GiB. |
| * **Wan's forward must be wrapped in a bf16 autocast.** `time_embedding` forces |
| float32 internally and hands the result to bf16 blocks; without the wrapper |
| the first attention fails on a dtype mismatch. `WanVaceBackbone.forward` does |
| it so callers cannot forget. |
| * **VACE's context is `[inactive | reactive | mask]`, 16 + 16 + 64 = 96 |
| channels.** Putting the conditioning latent in the wrong slot does not crash; |
| the branch simply receives the RGB in the slot reserved for the region it is |
| supposed to invent. `build_vace_context` names the split and validates the |
| channel count. |
| * **Freezing has to be verified by comparison, not inspection.** After an |
| optimiser step, `patch_embedding.weight` is bit-identical (max delta 0) while |
| `vace_blocks.0.modulation` moves by 5.9e-03 -- that check is what actually |
| demonstrates the base is frozen. |
| * **GeoCalib's gravity vector is the negation of ours.** Its |
| `Gravity.from_rp` is `(-sin r cos p, -cos r cos p, sin p)` against our |
| `(sin r cos p, cos r cos p, -sin p)`. The first adapter carried it through |
| unchanged and the evaluation reported ~147 degrees of gravity error, which |
| reads as a broken model rather than a broken adapter. |
| `tests/test_third_party_agreement.py` now pins the conversion against |
| GeoCalib's own class rather than against a remembered formula. |
| * **Fixing a baseline's camera family measures the mismatch, not the baseline.** |
| Evaluating AnyCalib with `cam_id="pinhole"` on 230-degree EUCM clips gives 34 |
| degrees of ray error -- a number about the protocol, not the model. AnyCalib |
| predicts a dense ray field and fits whatever family it is asked for, so the |
| fair protocol passes each clip's *true* family (`--anycalib-camera gt`), and |
| the fixed-family run is reported separately as the cost of getting model |
| selection wrong. |
| * **This cuDNN build cannot run the bf16 convolution backward at all for two |
| whole classes of convolution.** Measured here (cuDNN 9.21, H200), all in the |
| **backward** and all reported as a bare `RuntimeError: GET was unable to find |
| an engine to execute this computation` that names neither the layer nor the |
| reason: |
|
|
| | convolution | with cuDNN | cuDNN disabled | |
| |---|---|---| |
| | `Conv2d(64, 128, 1, stride=1)` | works | works | |
| | `Conv2d(64, 128, 3, stride=1)` | works | works | |
| | `Conv2d(64, 128, 2, stride=2)` | **fails** | works | |
| | `Conv2d(64, 128, 3, stride=2)` | **fails** | works | |
| | `Conv2d(64, 128, 7, stride=4)` | **fails** | works | |
| | `Conv2d(1552, 256, 1)` | works | works | |
| | `Conv2d(1554, 256, 1)` | **fails** | works | |
| | `Conv2d(64, 8, 1)` | works | works | |
| | `Conv2d(64, 4, 1)` | **fails** | works | |
|
|
| So: any stride > 1, and any 1x1 whose channel counts are not 8-aligned. Both |
| are natural to write here -- an RGB stem is `Conv2d(3, 64, 7, stride=4)`, a |
| stage downsample is stride 2, the neck input is 1536 DiT channels plus 18 |
| coordinate-PE channels, and the heads project to 2, 4 and 12 channels. |
|
|
| Two responses, both kept. `AlignedConv1x1` / `AlignedConv2d` pad both channel |
| counts to a multiple of 8 and slice the output back, which is good practice |
| regardless and makes the model portable; a test asserts structurally that no |
| convolution anywhere in the model is misaligned. And `ensure_conv_backend` |
| probes the shapes this project uses at trainer construction and disables cuDNN |
| only if they fail, logging what it changed. On this machine the fallback costs |
| nothing: a full training step of the video baseline (batch 2, 9 frames, |
| 240x416) takes 0.117 s either way. |
| * **The Wan VAE compresses time 4x, so the DiT predicts at latent-frame rate.** |
| A 33-frame clip becomes 9 latent frames, and the per-frame heads produce 9 |
| predictions, not 33. Comparing those with 33 frames of labels is a shape error |
| if you are lucky and a silently wrong loss if broadcasting saves you. |
| `latent_frame_centres` encodes Wan's causal grouping -- frame 0 maps to latent |
| 0, then each group of 4 -- and `upsample_to` interpolates on those centres |
| rather than on a naive `linspace`. |
| * **A single-batch loss is not a readable trend, and neither is a 12-clip |
| validation median.** One batch of 4 clips mixes a 65-degree pinhole with a |
| 250-degree fisheye -- different problems -- so the instantaneous loss swings by |
| about 2 nats with no change in the model, and the von Mises-Fisher term |
| amplifies it. Observed on a real run: instantaneous loss 1.02 / 0.12 / 0.23 |
| over three consecutive log points while the 100-step mean fell monotonically |
| 2.82 / 1.78 / 1.31. The training log now reports both. This is the same |
| mistake as reading the rectified-flow loss as a curve, in a different guise: |
| the fix in both cases is to hold constant whatever is varying. |
| * **Tracking `best_val` without saving it makes selection impossible.** The |
| first implementation recorded the best validation ray AE and then wrote the |
| *final* weights, so a run whose validation degraded shipped the worse model -- |
| while doc section 10 says explicitly that the decoder is chosen on validation |
| ray angular error. `decoder.pt` is now the selected checkpoint (best, or final |
| if final is better), `decoder_final.pt` and `decoder_best.pt` are both kept, |
| and the summary records which was chosen and at which step. |
| * **Label generation, not the GPU, is what limits training throughput.** The up |
| field is two camera projections per pixel per frame; generating it at 832x480 |
| and resizing to the 240x416 training grid cost about 8x more than generating it |
| at 240x416 directly, and expanding all 81 frames of a clip when a sample uses |
| 17 cost another ~5x. Measured per clip: 13.5 s at full resolution and all |
| frames, 1.66 s at the training stride and the selected frames. Two further |
| cuts followed from looking at the profile rather than guessing: the validation |
| set does not need the up field or latitude at all (it measures ray angular |
| error), and QC was unprojecting the same pixel grid twice per clip. With the |
| GPU step at 0.117 s, anything above that in the loader is the whole cost of a |
| run. |
| * **Grouped 3-D convolution has bf16 kernel gaps too.** The temporal depthwise |
| convolution was originally a `Conv3d` with a `(k, 1, 1)` kernel; it is now the |
| arithmetically identical grouped `Conv1d` over `[B*H*W, C, T]`, which has full |
| kernel coverage and is faster. A test pins the equivalence. |
| * **The rectified-flow training loss cannot be read as a curve.** It resamples |
| the timestep every step and the objective's magnitude depends strongly on it, |
| so consecutive losses vary ~5x with no learning involved. |
| `evaluate_fixed_timesteps` holds the timestep, the noise and the clip fixed; |
| that is what the gate uses. |
| |
| ## Paper tier (doc sections 9.1, 12.4, 13.1) |
| |
| The MVP tier answered doc section 15 with a clean dataset, and that turned out to |
| be the limit of what it could answer. Rendering a static panorama with no noise, |
| no occlusion and no exposure integral gives every frame of a clip *identical* |
| lens information, so temporal aggregation has nothing to suppress and the |
| measured result -- a video network no better than a single frame -- is a |
| statement about the data, not about video. The paper tier exists to make the |
| claim testable. |
| |
| ### What changed |
| |
| * **Imaging conditions** (`vidicalib/render/conditions.py`), mixed per clip at |
| the doc's section 9.1 weights: clean 0.40, noise 0.12, night 0.12, |
| low_texture 0.12, motion_blur 0.08, dynamic_occlusion 0.16. `--conditions |
| default` on `tools/render_calib_clips.py`; `--conditions clean` (the default) |
| reproduces the MVP path exactly. |
| * **Motion blur is an exposure integral, not a post-process.** Each output frame |
| is the mean of sub-frames whose orientations are interpolated across |
| `exposure_fraction` of the interval to the next frame, so the smear follows |
| the actual motion and its length varies with the local angular velocity. |
| * **Measured-profile OOD clips** (`tools/render_ood_clips.py`): real Lensfun and |
| Optiland profiles from lens families the training split never contains, |
| rendered through `render_clip_rays` with the profile's own ray grid as the |
| ground truth. |
|
|
| ### Findings |
|
|
| * **Every pixel has to be visible in some frame, and that does not happen by |
| itself.** The point of dynamic occlusion is the asymmetry -- a per-frame method |
| cannot recover an occluded region from that frame, a temporal one can, because |
| the occluders move. A pixel hidden in *every* frame is recoverable by nothing |
| and only adds label noise. Two independently sampled occluders can between |
| them cover a pixel for a whole clip: rare per pair, but at four occluders it |
| happened on 1 seed in 6 and hid 5.6% of pixels permanently. Occluders are now |
| accepted greedily under the invariant -- a candidate is kept only if, after |
| compositing it, essentially every pixel is still visible somewhere. Measured |
| over 24 seeds at four clip shapes: 28-38% mean occlusion, worst-case |
| permanently-hidden fraction 0.0008, at a cost of about one rejection per clip. |
| On the 230-clip full-resolution pilot the worst case was 0.00047. |
| * **A clip can be assigned motion blur and have none.** On a stop-and-go |
| trajectory the camera is stationary, the exposure integral is a no-op, and the |
| render is byte-identical to the clean one -- physically correct, but it would |
| put an easy clip in the "hard" bucket of the results table. The generator now |
| measures the achieved blur (`exposure_sweep_deg / clip_deg_per_px`) and |
| relabels the clip `clean` below half a pixel, recording `relabelled_from` so |
| the relabelling is visible rather than silent. |
| * **Blur direction needed a single-orientation test to settle.** A checkerboard |
| suggested the smear ran the wrong way; a checkerboard has both edge |
| orientations and cannot separate them. With single-orientation stripes the |
| answer is unambiguous: yaw destroys vertical-stripe contrast by 70% and leaves |
| horizontal stripes untouched (0%), pitch does the reverse (69% against 9%). |
| * **Running the conditions on the CPU cost more than rendering the clip.** At |
| 832x480x81 each non-clean condition takes 19-32 s on CPU against 18.5 s for the |
| render itself, and with twelve render workers on twenty-four cores the |
| thread oversubscription made it worse: throughput fell from 0.65 to 0.121 |
| clips/s, a 5x regression, for work that is 0.0-0.35 s on the GPU. The |
| conditions now run on the device the frames are already on, and the pilot |
| measured **0.70 clips/s** -- slightly *faster* than the clean MVP run. The |
| scalar parameters (which condition, how strong, where the occluders go) still |
| come from a CPU generator, so they stay reproducible across devices; only the |
| per-pixel noise realisation is device-local, because drawing 400M samples on |
| the CPU and copying them costs more than the render. |
| * **The condition RNG must not be seeded from `hash()`.** Python salts string |
| hashing per process, so seeding from `hash(clip_id)` would have given a |
| different condition for the same clip on every run -- unreproducible in the way |
| that is hardest to notice, since any single run looks perfectly consistent. |
| It uses `zlib.crc32` instead. |
| * **88% of held-out lens profiles have no converged parametric fit.** The OOD |
| ground truth therefore cannot be "the fitted Brown-Conrady": of the 12% that do |
| fit, the fit is off from the true profile by a median of 0.007 degrees but up |
| to 1.0 degree, which is the same order as the effect being measured. The |
| profile's own ray grid is stored as the ground truth instead, evaluated on both |
| the output and the supersampled lattice rather than interpolated from one to |
| the other. Round-trip through the manifest is exact to 2.4e-6 degrees, the |
| arccos metric's own noise floor. |
| * **An ablation that runs is not an ablation that varies anything.** The doc |
| section 12.4 pair `fixed_principal_point` / `variable_principal_point` ran |
| green and produced *byte-identical* rows, including the principal-point error |
| itself. `fit_camera`'s `principal_point` argument only seeds the multistart |
| and centres the pixel sampler; the optimiser then moved cx, cy straight back |
| to the truth. Holding a parameter requires removing it from the step, which |
| is now done by solving the *reduced* normal equations -- not by computing the |
| full step and zeroing the fixed entries, which would let the remaining |
| parameters absorb a direction they should never have seen. Measured on a |
| camera whose principal point is 8.5 px off centre: free recovers |
| (112.00, 55.00) exactly at 0.0000 degrees, fixed holds (103.50, 59.50) exactly |
| at 2.95 degrees. Four tests pin it, including one asserting that on a centred |
| camera the constrained and unconstrained fits agree -- the check that |
| distinguishes a reduced solve from a zeroed one. |
| * **The measured-profile renderer is the same renderer.** `render_clip_rays` and |
| `render_clip` share `_sample_frames`; a test asserts that feeding a parametric |
| camera's own ray field to the measured path reproduces its render bit for bit, |
| so the OOD numbers cannot be an artefact of a second implementation. |
|
|
| ## The mainline: VACE generative geometry pre-training (doc Phase 1a/1b/2) |
|
|
| Everything reported before this section used `--feature-source base`: the raw |
| Wan2.1 video-generation features with **no geometric pre-training at all**. |
| That is not the design doc's method. The doc's mechanism is Stage 1a (sparse |
| geometry overlays) then Stage 1b (dense ray / latitude / up encodings) as |
| *generative* pre-training of the VACE branch, and only then reading features |
| out for the geometry decoder. Running the mainline is what this section |
| records. |
|
|
| The doc is unambiguous that the base stays frozen -- sections at lines 12, 56, |
| 518, 533 and 764 all say so, and 764 lists it as the cost-control measure. |
| Only the VACE branch trains: 735 M of 2,154 M parameters. |
|
|
| ### Stage 1a, as run |
|
|
| 8,500 optimizer steps, 81 frames, 480p, 56.9 wall-hours. The recorded batch |
| history is 3,250 steps at batch 1 followed by 5,250 at batch 3: approximately |
| 19,000 sample presentations on the retained branch, not 25,500. The design |
| document specifies 25,000 **steps**, so this is not the same training budget. |
| The 8,500-step stopping point was a user-approved adjustment. Fixed-timestep flow-matching loss **1.100 -> 0.031**, a |
| 36x reduction. Two methodological discontinuities are baked into that curve and |
| it must not be read as one trajectory: batch changed 1 -> 3 at step 3,250, and |
| the cosine schedule was re-scoped from 25,000 to 8,500 steps at step 3,500, |
| which stepped the learning rate down from 9.7e-5 to 8.3e-5. |
|
|
| Throughput is flat in batch size: 13.71 s/sample at batch 1 and 13.66 s/sample |
| at batch 3, i.e. **0.4% apart**, while memory went 45.8 GB -> 119.0 GB. The |
| workload is compute-bound on a single 81-frame 480p forward through a 2.15 B |
| DiT, so a larger batch buys wall-clock nothing. Batch 4 needs ~156 GB and does |
| not fit in 143 GB. |
|
|
| ### A stage that reported success having trained nothing |
|
|
| Stage 1b "completed" in 48 seconds with `rc=0` and a normal-looking |
| `summary.json`. It had trained **zero steps**. |
|
|
| The resume guard added to make a 100-hour run restartable contained this: |
|
|
| ```python |
| same_stage = str((sd.get("config") or {}).get("stage", args.stage)) == args.stage |
| ``` |
|
|
| The default for the lookup is the value it is compared against, so a |
| checkpoint that records no stage matches *every* stage -- and none recorded |
| one, because the stage lived in the CLI arguments and never reached the |
| serialised config. Stage 1b therefore restored Stage 1a's optimiser **and its |
| step counter of 8,500** against its own budget of 3,334. `while step < |
| args.steps` was false on entry, the loop never ran, and the stage wrote a |
| summary claiming completion. |
|
|
| The tell was in the summary all along: `first_loss: null`, `last_loss: null`, |
| `fixed_ratio: 1.0` -- before and after identical to the last decimal -- and two |
| log rows carrying the same numbers. Nothing in the pipeline looked at any of |
| them. |
|
|
| What it cost: the geometry decoder then trained for 17 hours on Stage-1a-only |
| features while being labelled 1a+1b. That run is real but answers a different |
| question, and is reported as such below. |
|
|
| Four things changed: |
|
|
| * the checkpoint records `stage` at its top level, from the trainer config; |
| * **an absent stage counts as a *different* stage.** Unknown must mean |
| "different", because the unsafe direction inherits an optimiser and a step |
| count across a curriculum boundary; |
| * resuming at or past the step budget is an error that returns non-zero and |
| **refuses to write a summary**, instead of completing silently; |
| * the chain verifies `first_loss is not None and steps >= 3000` before it will |
| train a decoder on those weights. |
|
|
| `tests/test_models.py` pins all four, including the faulty comparison written |
| out as an explicit assertion. |
|
|
| ### Historical decoder results: not a controlled comparison |
|
|
| | actual run | decoder steps | historical best validation ray AE | |
| |---|---:|---:| |
| | paper_single_frame, 1 frame | 20,000 | 8.2210 deg | |
| | paper_video, 17 frames | 20,000 | 9.1937 deg | |
| | fair_vace, base features, no geometry pretraining | 1,500 | 8.0847 deg | |
| | Stage-1a-only, vace features | 20,000 | 7.99 deg (conversation record only) | |
| | Stage-1a+1b, vace features, pre-fix archive | 20,000 | 7.5741 deg | |
|
|
| The original Stage-1a-only decoder weights and logs were overwritten. Its |
| 7.99-degree number cannot be treated as a preserved reevaluable checkpoint. |
| The surviving Stage-1a and Stage-1b branch weights and the pre-fix 1a+1b decoder |
| are archived under `archive/2026-09-12_pre_fix/`. |
|
|
| These runs changed feature source, training schedule and validation selection; |
| the early convolutional runs used 32 validation clips, and the later VACE runs |
| used the first 128 clips from only two panoramas. All pre-fix decoder training |
| also used inconsistent camera intrinsics after resizing. Neither improvement nor |
| regression in this table can be attributed solely to geometric pretraining. |
| The previous conclusion that sparse-overlay pretraining was nearly useless, |
| or that these runs could refute the design, is withdrawn. |
|
|
| The corrected comparison is implemented in `tools/run_vace_controlled.py`. |
| For each of `base`, `vace` and `fused`, it independently compares bundled VACE |
| weights, Stage-1a, and Stage-1a+1b with the same decoder settings, feature task, |
| seed and validation subset. Feature-source changes are a separate ablation. |
| Full evaluation uses OpenPano test and the Lensfun/Optiland OOD manifest. |
|
|
