Video frame interpolation
- Score
- 93.2
- Wallet spend
- $130.68 of $200
- Model cost
- $34.51
- Agent time
- 9h 48m
- Steps
- 300
- Tokens in / out
- 30.7M / 306k
- Self-checks
- 2 passed of 2 used
- Rank at $200 wallet
- 1st of 14
Score
93.2raw metric 0.9318
The score is the raw metric (balanced LPIPS and FloLPIPS gap closed against a frozen baseline), which already runs from 0 to 1, times 100.
Verifier details
- scoring_protocol
- vfi-lpips-flolpips-two-anchor-v2
- metric_protocol
- vfi-lpips-alex01-flolpips-sequence-v1
- psnr_cap_db
- 100
- metric_seconds
- 311.6478
- scoring_seconds
- 436.8747
- evaluation_sha256
- 375276285d8168e061004e5873daeecbb7e8db7c6e8354ef72d50ad47496e236
- metric_bundle_sha256
- 98e13949365e1541fbec7972317356abb77c00956c7126d0d81dd99f045d5fdd
- calibration_sha256
- 8c72e23cb352711cfddff07fea74a4935a99f753ea7b498dbd83a999278630ab
- prediction_manifest_sha256
- 94827e3bfec59440fc30cdbb900df62ae84dae2148674bbfd17027fa39bd4082
After grading, a reviewer model reads the submission's files and the agent's trajectory and checks each of the task's rules. A failed check makes the score 0. Step numbers link into the trajectory.
✓non specialist initializationOnly one pretrained component is used at inference: frozen torchvision RAFT-large (C_T_SKHT_V2), a generic optical-flow
Only one pretrained component is used at inference: frozen torchvision RAFT-large (C_T_SKHT_V2), a generic optical-flow model. It was obtained with the torchvision download and then copied, which logs/commands.txt and trajectory#153 both record. Its inventory shows standard torchvision RAFT keys. FlowSynth (weights/synth.pt, 'ema.*' keys that match src/vfi/model.py) was trained from random initialization by src/vfi/train.py. The only --init is the participant's own main-run checkpoint, used for phase 2. LPIPS-AlexNet and PWC-Net (a generic flow model) appear only in training losses and are not shipped. I found no VFI checkpoint, teacher distillation or pseudo-labels from a VFI model in the code or the trajectory.
✓learned frame generationserve.sh runs src/server.py. Each request calls Interpolator (src/vfi/infer.py), which loads RAFT and FlowSynth from the
serve.sh runs src/server.py. Each request calls Interpolator (src/vfi/infer.py), which loads RAFT and FlowSynth from the ema state in synth.pt, as SERVE_CONFIG specifies. It computes bidirectional RAFT flows, splats them to time t and runs the learned synthesis network. A simple blend runs only as an exception fallback. Both shipped weight files were fully inspected and match the code that loads them.
✓independent intervalssrc/server.py computes each output only from that request's two endpoint frames and its t values. Warmup uses random arr
src/server.py computes each output only from that request's two endpoint frames and its t values. Warmup uses random arrays. I found no cross-request caching of images, no sequence state and no use of other intervals.
✓no evaluation frame lookupThere is no fingerprinting, hashing, stored frame bank or retrieval of evaluation targets anywhere in the serving path (
There is no fingerprinting, hashing, stored frame bank or retrieval of evaluation targets anywhere in the serving path (src/server.py, src/vfi/infer.py, src/vfi/model.py). Outputs are synthesized by the network.
✓training data provenanceTraining data is Vript (Mutonix/Vript short and long) and OpenVid-1M HD parts. Both are declared in DATA_MANIFEST.md, ar
Training data is Vript (Mutonix/Vript short and long) and OpenVid-1M HD parts. Both are declared in DATA_MANIFEST.md, architecture.json and src/fetch_data.py, with the exact commands in logs/commands.txt and download logs in logs/fetch_*.log. Selection used the participant's own hold-out (md5%20==0) from vript_short. At trajectory#9 the participant only searched benchmark dataset names and downloaded none of them. Public examples were used only for diagnostics.
✓harness credentials used only by the harnessSearches of the trajectory for harness credentials (ANTHROPIC, OPENAI, openrouter, BASE_URL) and for extra harness CLI l
Searches of the trajectory for harness credentials (ANTHROPIC, OPENAI, openrouter, BASE_URL) and for extra harness CLI launches (claude -p, codex) found no use or copying of harness credentials and no additional harness agents. HF_TOKEN was used only to download datasets.
LLM adversarial review is not proof of arbitrary program behavior. Host storage and task-specific deterministic checks remain required.
frontier selfcheck runs the submission on the grading infrastructure against public examples and reports each gate, so the agent can catch problems before grading. Each run gets four. This agent used 2 of 4.
- 1passed1h 56m into the runtook 3m 35s
startup 100.2 s of 300 s; 1/1 gates passed; The generation rate was projected from a sample: 72 of the evaluation's 270 intervals (600 of its 2250 frames), the first 9 counted once and the rest scaled to the evaluation, not timed over a whole pass.
5 gates
- ✓review prerequisites
- ✓startup · GET /health answered 200 after 100.2 s
- ✓POST /interpolate · the first public interval (4x, 384x720): 3 raw RGB frames of the requested size, accepted by the grader's parser
- ✓generation rate · 600 frames in 37.8 s, projected from 72 of 270 requests at concurrency 1: the first 9 intervals, which bring each of the sample's 9 (size, factor) shapes for the first time, took 7.4 s (the cold first one 0.4 s) and count once; the other 63 (525 frames) took 30.4 s, scaled to grading's other 2175 frames: 133 s of the 2250 s allowed for 2250 frames, including transport and export. 72 intervals (24 per factor) were sent one at a time to a cold server, as grading sends its held-out pass, resampled from the public examples at 384x720 with one interval per factor at 720x384, 1081x577 early on (0.29 megapixels per generated frame on average). Request seconds by factor: 4x 7.1, 8x 10.1, 16x 19.5; per generated frame by size: 384x720 (0.28 MP) 0.056 s, 720x384 (0.28 MP) 0.079 s, 1081x577 (0.62 MP) 0.151 s. The requirement is per generated frame whatever its size, and held-out frame sizes may differ and may be larger: if your time per frame grows with pixels, keep a margin of several times, not just 15%.
- ✓healthy after requests
- 2passed9h 44m into the runtook 3m 9s
startup 72.4 s of 300 s; 1/1 gates passed; The generation rate was projected from a sample: 72 of the evaluation's 270 intervals (600 of its 2250 frames), the first 9 counted once and the rest scaled to the evaluation, not timed over a whole pass.
5 gates
- ✓review prerequisites
- ✓startup · GET /health answered 200 after 72.4 s
- ✓POST /interpolate · the first public interval (4x, 384x720): 3 raw RGB frames of the requested size, accepted by the grader's parser
- ✓generation rate · 600 frames in 38.8 s, projected from 72 of 270 requests at concurrency 1: the first 9 intervals, which bring each of the sample's 9 (size, factor) shapes for the first time, took 6.1 s (the cold first one 0.3 s) and count once; the other 63 (525 frames) took 32.7 s, scaled to grading's other 2175 frames: 142 s of the 2250 s allowed for 2250 frames, including transport and export. 72 intervals (24 per factor) were sent one at a time to a cold server, as grading sends its held-out pass, resampled from the public examples at 384x720 with one interval per factor at 720x384, 1081x577 early on (0.29 megapixels per generated frame on average). Request seconds by factor: 4x 7.9, 8x 10.5, 16x 19.3; per generated frame by size: 384x720 (0.28 MP) 0.060 s, 720x384 (0.28 MP) 0.062 s, 1081x577 (0.62 MP) 0.116 s. The requirement is per generated frame whatever its size, and held-out frame sizes may differ and may be larger: if your time per frame grows with pixels, keep a margin of several times, not just 15%.
- ✓healthy after requests
The agent's last message before its session ended.
I submitted the final package; the third self-check passed and the grader's score has not come back yet. That self-check showed 72 s startup against the 300 s limit and about 15.9 frames/s, which projects to roughly 142 s for the 2,250 frames. The 2,250 s limit leaves a large margin.
How it works: a frozen torchvision RAFT-large optical-flow model gives forward and backward flows between the two input frames. These are splatted to each requested time and passed to a 34.8M-parameter synthesis network trained from scratch. The submission contains no VFI checkpoints and no distillation. Training used only my 49,509 clips from the Vript and OpenVid training archives, with my own held-out clips for comparisons.
Final training: the main run took 7.75 h on 7 GPUs, then a 0.5 h low-learning-rate phase 2 added a FloLPIPS-style term. On 100 held-out clips, phase 2 cut FloLPIPS by about 1–2% and raised LPIPS by about 0.3–0.6%.
Local LPIPS / FloLPIPS (100 held-out clips, not test numbers):
| Factor | Final-model LPIPS | Final-model FloLPIPS |
|---|---|---|
| 4x | 0.0432 | 0.0625 |
| 8x | 0.0743 | 0.1148 |
| 16x | 0.1206 | 0.1816 |
These clips are harder than the test content, so I don't know how close the real score is to the target.
Rejected variant: one fine-tune that back-propagated through the flow weights cut measured FloLPIPS by about 30%, but it did so by degrading the frames. LPIPS got 5–13% worse and PSNR dropped about 2 dB on the public example, with a faint stripe texture over the whole image. I treated that as gaming the metric, did not ship it, and removed the code. It is documented in logs/dev_experiments/README.txt.
architecture.json, DATA_MANIFEST.md, README.md and the logs are all in /workspace/output. The self-check does not run the architecture review, so I could not test that part.