Deep Analog takes a single reference film scan it has never seen, extracts its color character as a neural 3D LUT plus physical film parameters, and re-renders any target photograph in that look — no per-stock training, no preset library.
The system splits the problem: what color transform to apply (StyleLUTNet), what the reference's tonal statistics are (analyzer), and how film physically renders (grain & halation parameters). Click any block for details.
Click any node in the diagram to see what it does, its exact tensor shapes, and where it appears in the thesis.
These are actual intermediate outputs of the trained model, conditioned on the Happy Together (1997) reference frame. Drag the divider to compare each stage against the previous one; use ← → or Play.
This is the real 33³ LUT the network predicted from the reference frame (subsampled to 17³ = 4,913 points). Each point sits at its output RGB coordinate and is painted its output color. Drag the morph slider: at identity the points form the untouched RGB cube; morphing to predicted shows how the network bends color space toward the film look.
Stages 5–6 are differentiable physical renderers, not filters. This lab re-implements both equations in JavaScript and runs them live on the real stage-4 intermediate. Push the sliders past the fitted defaults to see what each parameter controls.
Each widget below implements the exact equation from the paper in JavaScript and lets you probe it. Defaults are the values the system actually measured or predicted for this reference.
Click the input photo to sample a pixel, or set RGB directly:
The sampled color falls inside one cell of the LUT grid. Its output is the weighted blend of the 8 surrounding grid entries — line thickness ∝ weight. This is exactly what F.grid_sample computes per pixel, which is why the whole color stage is trainable end-to-end.
Solid = CDF of the graded image, dashed = CDF of the reference, both computed live from the embedded images. Follow the amber path: v → F_src(v) → jump to the reference CDF → read off T(v). The full curve T (thin amber) is Gaussian-smoothed (σ=2 bins) and blended at strength 0.7 with highlight protection.
Two parameters — measured from the reference by the statistical analyzer (sliders start at the real measured values) — reproduce film's lifted toe and soft shoulder. Applied after the LUT and CDF stages, it stays a small residual correction rather than a full display-referred sigmoid.
The map shows M(L) evaluated on the real stage-3 intermediate — bright = more grain (contrast-stretched for display). With the fitted defaults the quadratic peaks in the mid-tones, matching silver-halide density: shadows are thin, highlights saturate, grain shows most in between.
The map shows which pixels pass the soft threshold — only those scatter. The red kernel spreads 1.4× wider than green and 2× wider than blue: red light penetrates the emulsion, reflects off the film base, and re-exposes the red-sensitive layer — hence film's warm halos.
Paper measurements: baseline V1 collapses to mean w₁ = 0.947 (H = 0.16); entropy-regularized V3 uses all five bases (H = 1.58 of 1.61 max). But even fixed, a basis bank is a closed set — which is what motivates predicting one conditional LUT instead (StyleLUTNet).
The same random transform hits two different images: one becomes the reference, the other the input. To reconstruct the original, the network must infer the inverse transform from the reference alone — no film scans, no paired data. Transform ranges are set to span and slightly exceed real film variation, which is what buys open-set generalization.
Behind the demo sit >120M trained parameters across three networks, a curated 5,000-image expert-retouched dataset, a self-supervised pair-generation protocol, and seven model generations trained on RIT Research Computing (SPORC cluster, NVIDIA A100 80 GB). All values below are taken directly from the training job scripts and the experiments section of the thesis.
Every model generation ran as a batch job on RIT's SPORC partition — grain/halation jobs at 48 GB / 4 h walltime, end-to-end V6 at 64 GB / 12 h. Training data, checkpoints and logs lived on cluster storage under /shared/rc/deep-analog.
5,000 RAW photographs, each hand-retouched by five professional colorists (A–E). SwinLUT trains against Expert C at 480×480, prepared and indexed on cluster storage:
The open-set stage has no dataset to buy. No corpus pairs arbitrary photos with specific film stocks — building one would mean professionally grading every input against every stock. The RandomColorTransform protocol (section 05) manufactures unlimited supervised pairs with exact ground truth instead, and the 350-pair test set is generated the same way. What pixel metrics then certify — transform inversion, not emulsion fidelity — is assessed separately by a two-round user study.
λ_h is the largest coefficient because the self-supervised task is about reproducing global color distributions, not per-pixel error. Push the regularizers up: at roughly 15:1 against reconstruction the optimizer discovers it is cheaper to shrink the residual scale α toward zero than to improve color — the exact failure observed in training (α: 0.10 → 0.04 over 100 epochs, near-identity output), fixed by freezing α = 1 and rebalancing. SwinLUT adds entropy + diversity terms (λ_e = 0.1, λ_d = 0.01); FilmAnalyzerNet uses magnitude-weighted MSE per parameter.
Drag to compare the original digital photograph against the final Deep Analog render conditioned on the Happy Together frame.