[davidackerman]

Stacked on #137 (browser-batch), where the browser's whole-network finetuning lives. Once #137 merges, this PR's base becomes main.

The browser's whole-network finetune (the 2D models, setup_53_2d and setup_54_2d) used to train with masked BCE on the paint alone. It now takes the same loss settings as the last layer, and it gets an Augmentation box, off by default as on the server.

Who sees a change

• The form, with Whole network picked: the Loss Function, Margin, Distillation Weight and Scope, Label Smoothing, Balance and Augmentation fields now show, and are used. Before, they were hidden and ignored.
• The defaults change for a whole-network run: the form starts with class balance on and distillation at 0.01, so a run with untouched fields now trains with both, where before it had neither.
• The log and the job card say what the run trained with. The card adds "augmented" when augmentation was on.
• The last layer is unchanged. It trains on features computed once, so it takes no augmentation.

How augmentation works

It's the server's (finetune/data/augment.py), in the same order as lora_trainer.py:

1. Brightness ×0.8–1.2 and noise of 1% of the raw's range, on the raw as stored, before normalization.
2. Random flips and a quarter turn of the image and the paint together. A tile turns only where its plane's two voxel sizes are equal.
3. Then the targets are made from the turned paint, and the starting network runs on the turned tile for distillation.

Because the targets are made after the turn, an affinity channel still means its own direction. Turning a target instead would need its channels permuted and shifted. The browser makes binary and affinity targets only, and both come from the labels.

Code

• web/src/finetune/augment.ts (new): the draws, the block transform (z, y, x, so a 3D tile can use it too), the intensity range, and a tally for the log.
• web/src/finetune/full/loss.ts (new): the head's supervised and distillation terms in TF.js, and the training step.
• full/run-full.ts: keeps each tile's raw and paint when augmenting and redraws them every step; runs a frozen copy of the starting network (the base's weights, also on a restart) when λ > 0.
• full/tiles.ts: tileRaw and normalizeTile, so the raw is kept before normalization; tileInput is unchanged in what it returns.
• routes/finetune.ts: one readLoss for both modes; the whole network also reads augment.
• Form (_finetune_tab.html, training-form.js, job-card.js), docs (browser.rst), CHANGELOG.

Checks

• npm run check in web/: typecheck, 1,553 tests passed, build.
• The full Python suite: 2,230 passed, with only test_importing_leaves_the_process_alone[blockwise-logging] failing, as on main in that environment.
• New tests:
  • the image and the paint stay registered through flips and turns;
  • a boundary across x becomes one across y after a quarter turn;
  • brightness and noise stay in the raw's range and the padding stays 0;
  • the TF.js loss equals the head's for every loss type, balanced or not, smoothed or not;
  • the distillation term is exactly 0 before the first step;
  • the form's fields are read for the whole network.
• Headless, on this workstation's GPU (WebGPU), jrc_hela-2 with setup_53_2d:
  • a 3-epoch run on 31 tiles of 300², with augmentation and distillation, at 244 ms a step;
  • the finetuned model served, and its chunks came back;
  • the log's tally: 93 tiles augmented, flips 51–57%, each turn 16–35%.
• The draw itself, over 100,000 tiles: every turn 25%, every flip 50%.

Not included

• LoRA in the browser: measured on setup_53's 3D UNet at 172³, one PyTorch training step. LoRA of rank 8 on every layer kept more memory for the backward pass than training every weight (4.6 vs 4.2 GB) and was about 50% slower. The backward pass still needs every layer's activations. Training only the last decoder stage kept 0.5 GB, so that's the lever if memory gets tight.
• Good regions still aren't used by the whole network.