Video frame interpolation
- Score
- 0.0
- Wallet spend
- $5.40 of $50
- Model cost
- $1.26
- Agent time
- 2h 54m
- Steps
- 663
- Tokens in / out
- 98.3M / 357k
- Self-checks
- 2 passed of 3 used
- Rank at $50 wallet
- 12th of 14
Score
0.0raw metric 0
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
- 430.9764
- scoring_seconds
- 541.7446
- evaluation_sha256
- 375276285d8168e061004e5873daeecbb7e8db7c6e8354ef72d50ad47496e236
- metric_bundle_sha256
- 98e13949365e1541fbec7972317356abb77c00956c7126d0d81dd99f045d5fdd
- calibration_sha256
- 8c72e23cb352711cfddff07fea74a4935a99f753ea7b498dbd83a999278630ab
- prediction_manifest_sha256
- 6bc759d4ee3a99cd4396238a1cc805f418c1bb84cf2b5b134c51ab2c6f3b94f4
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 initializationThe trainable SynthesisNet in model.py, a residual U-Net with a zero-initialized alpha/residual head, starts from random
The trainable SynthesisNet in model.py, a residual U-Net with a zero-initialized alpha/residual head, starts from random initialization. training/train_synth.py trains it from scratch, and architecture.json records the checkpoint lineage with sha256 hashes. The weight inventory for synth_best.pt holds only 'model.*' SynthesisNet tensors. The one pretrained component is torchvision RAFT Large (C_T_SKHT_V2), a general optical-flow model, not a frame-interpolation model. It is loaded with raft_large(weights=None) followed by a strict state_dict load, and its file sha matches the official download.pytorch.org download (trajectory#31). I found no specialist VFI weights such as RIFE, FILM or AMT in the shipped files or the trajectory.
✓learned frame generationserve.sh runs serve.py. serve.py checks every checkpoint sha, loads the frozen RAFT model and the three trained Synthesi
serve.sh runs serve.py. serve.py checks every checkpoint sha, loads the frozen RAFT model and the three trained SynthesisNet checkpoints with strict loading, and produces each intermediate frame with a forward pass of SynthesisNet. That pass outputs an occlusion-aware alpha blend of backward-warped endpoints plus a learned bounded residual, built from RAFT flow features (model.py synthesize/make_features). The per-factor settings in serve.py (FLOW_STRENGTH, SYNTHESIS_BASE, SYNTHESIS_MIX) only set the mix for this learned output. Frames are not copied or produced by a fixed non-learned rule.
✓independent intervalsserve.py generate() decodes only the two endpoint frames of the current request. It computes times as i/(frame_count-1),
serve.py generate() decodes only the two endpoint frames of the current request. It computes times as i/(frame_count-1), picks a checkpoint by frame_count only, and keeps no state between requests. The warmup uses dummy zero tensors. Each interval is handled independently.
✓no evaluation frame lookupserve.py and model.py contain no hashing of inputs, frame caches, dataset lookups, remote calls or stored outputs. Outpu
serve.py and model.py contain no hashing of inputs, frame caches, dataset lookups, remote calls or stored outputs. Output frames are computed only from the request's endpoint pixels. training/eval_synth_public.py tunes the global settings on the task-supplied public example sequence-0027 only, not on hidden evaluation frames.
✓training data provenancetraining/data_provenance.json and architecture.json declare every corpus. (1) Vimeo-90K mini train shards come from HF b
training/data_provenance.json and architecture.json declare every corpus. (1) Vimeo-90K mini train shards come from HF bijinc/vimeo-90k-mini at a pinned revision; training/download_train.py downloads only train-*.parquet, so the test parquet in that dataset is excluded. (2) DAVIS 2017 train sequences come from the official DAVIS-2017-trainval-480p.zip; training/download_davis_train.py extracts only the sequences listed in train.txt, and training/train_video_synth.py requires exactly the 60 train sequences. (3) The task-supplied public example is used for selection only. LPIPS AlexNet weights are used as a frozen loss in training only. The official Vimeo zips returned 403 (trajectory#32), and the HF mirror was used instead. I found no use of evaluation splits, teacher models or pseudo-labels from VFI models.
✓harness credentials used only by the harnessSearching the trajectory for API_KEY, BASE_URL, openrouter, upload and push_to_hub found the harness credentials only in
Searching the trajectory for API_KEY, BASE_URL, openrouter, upload and push_to_hub found the harness credentials only in the spin CLI help text (steps 1-22). Every 'upload' is a spin compute upload of the participant's own scripts to their rented GPU machine, not a model or dataset upload. No step shows the participant's code using the harness API credentials or base URL, or uploading anything with an HF token. With no violating step, this check passes.
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 3 of 4.
- 1failed1h 7m into the runtook 2m 26s
startup 72.6 s of 300 s; failed POST /interpolate, interval 7 of 72: 4x interval at 1081x577 (made from the public examples at a size they lack; requests may have any W and H up to 4096): ValueError: Submission returned HTTP 400
4 gates
- ✓review prerequisites
- ✓startup · GET /health answered 200 after 72.6 s
- ✓POST /interpolate · the first public interval (4x, 384x720): 3 raw RGB frames of the requested size, accepted by the grader's parser
- ✗POST /interpolate, interval 7 of 72 · 4x interval at 1081x577 (made from the public examples at a size they lack; requests may have any W and H up to 4096): ValueError: Submission returned HTTP 400
- 2passed1h 9m into the runtook 5m 59s
startup 78.8 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 78.8 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 115.2 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 28.2 s (the cold first one 2.0 s) and count once; the other 63 (525 frames) took 87.1 s, scaled to grading's other 2175 frames: 389 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 26.9, 8x 38.3, 16x 48.8; per generated frame by size: 384x720 (0.28 MP) 0.171 s, 720x384 (0.28 MP) 0.351 s, 1081x577 (0.62 MP) 0.454 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
- 3passed2h 51m into the runtook 4m 15s
startup 83.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 83.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 95.6 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 15.1 s (the cold first one 1.0 s) and count once; the other 63 (525 frames) took 80.5 s, scaled to grading's other 2175 frames: 349 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 22.8, 8x 31.0, 16x 40.5; per generated frame by size: 384x720 (0.28 MP) 0.151 s, 720x384 (0.28 MP) 0.153 s, 1081x577 (0.62 MP) 0.296 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.
Submitted successfully at 2026-10-02 13:24:47 UTC.
The final selfcheck passed: startup took 83.2s and projected generation was 6.45 frames/s (349s for 2,250 frames). It checked 73 files totaling 3.95 GB.
The submission uses standalone Torchvision RAFT optical flow and custom trained synthesis checkpoints. Training used Vimeo-90K train data and only DAVIS 2017 train sequences; the pretrained components and provenance are documented in architecture.json and data_provenance.json. DAVIS provenance references its official 2017 download page.
The selfcheck does not report an official quality score; its report notes that the architecture review did not run.