Flow State — RoCo-Spring 2026

Participation repository for Flow State in RoCo-Spring: The Robust Correspondence Challenge, a NeurIPS 2026 challenge on robust dense correspondence under realistic distribution shifts.

RoCo-Spring evaluates both clean accuracy and robustness to realistic camera noise, adverse weather, blur, compression, and illumination changes. It uses the high-resolution Spring benchmark and its 20-corruption RobustSpring extension.

Team registration

Field	Details
Team ID	RoCo-45
Registered team name	Flow State
Primary contact	Syed Mohaiminul Hoque
Contact email	syedmuhaimintahsin@gmail.com
Affiliation	Center For Computational and Data Sciences Lab, Independent University Bangladesh
Registered	September 8, 2026
Registration revision	2
Organizer record	Synchronized at revision 2
Account status	Awaiting organizer verification

The exact team ID and registered team name—RoCo-45, Flow State—must appear in the workshop paper abstract.

Selected tracks

• Optical Flow — dense 2D motion between consecutive frames
• Stereo Matching — dense disparity from rectified stereo pairs
• Scene Flow — dense 3D motion from stereo image sequences
• Exploration Track — analysis of robustness, failure modes, method behavior, metrics, or evaluation design

Competition schedule

Date	Milestone
July 2, 2026	Website launch
July 13, 2026	Development leaderboard opened
September 15, 2026	Workshop paper deadline (4–6 main pages)
September 29, 2026	Workshop paper author notification
September 30, 2026	Final quantitative submission deadline
October 7, 2026	Camera-ready paper, code, and reproducibility package deadline
October 15, 2026	Final evaluation, reproducibility checks, and award shortlist
October 31, 2026	Winners notified and workshop program finalized
December 11 or 12, 2026	In-person NeurIPS Competition Track workshop

All dates are tentative. Verify them on the official challenge website before submission.

Participation workflow

• Register the team
• Receive team ID RoCo-45
• Receive organizer account verification
• Download the Spring and RobustSpring training splits
• Install the official PTLFlow-based Starter Kit
• Run the RAFT-Sintel clean optical-flow baseline
• Fine-tune RAFT on the Spring spring-train-left split
• Generate and validate the clean Spring optical-flow predictions
• Upload the validated optical-flow HDF5 to the Spring benchmark
• Train or adapt a model for the selected optical-flow track
• Submit the workshop paper through the RoCo-Spring OpenReview venue
• Submit the camera-ready paper, code, and reproducibility package

Experiment 01 — RAFT-Sintel optical-flow baseline

The first benchmark submission was generated by the executed RAFT-Sintel master baseline notebook. It is an inference-only transfer baseline: the full RAFT model uses the official Sintel checkpoint without Spring fine-tuning or test-time augmentation.

Setting	Value
Benchmark method name	RoCo-45
Model	Full RAFT, 5,257,536 parameters
Checkpoint	raft-sintel-fb44381e.ckpt
Input	Native 1920×1080 Spring test frames; no rescaling
Recurrent refinements	32
Correlation	Triton lookup, 4 pyramid levels, radius 4
Directions and views	Forward and backward flow, independently for left and right cameras
Compute	Kaggle T4×2; sample sharding only, not an ensemble
Devkit revision	90ae81a9324c6806dc3c2482aab84a2744215bd9
Raw predictions	3,960 native-resolution .flo5 files
Submission artifact	Officially subsampled HDF5, 689,231,090 bytes

Spring benchmark result

The clean Spring optical-flow benchmark returned 6.766% total 1px error, 1.513 px EPE, 3.100% Fl, and 91.037 WAUC. Lower is better for 1px, EPE, and Fl; higher is better for WAUC. Robustness deltas are unavailable because this notebook submitted only the clean Spring test split.

Name	1px total ↓	EPE ↓	Fl ↓	WAUC ↑	Robust ΔEPE	Robust ΔFl	Robust Δ1px
RoCo-45	6.766	1.513	3.100	91.037	n/a	n/a	n/a

The benchmark's 1px error breakdown is:

Low detail	High detail	Matched	Unmatched	Rigid	Non-rigid	Not sky	Sky	Motion 0–10 px	Motion 10–40 px	Motion 40+ px
6.401	64.231	6.007	38.165	3.961	27.987	5.284	29.292	3.072	5.322	41.582

Method and equations

Let the two consecutive input frames be $I_1,I_2\in[0,1]^{H\times W\times3}$. The loader supplies BGR tensors, and the model applies the notebook's fixed normalization and channel conversion:

$$ \widetilde I_k = 2,\mathrm{RGB}(I_k)-1,\qquad k\in{1,2}. $$

The model uses stride $s=8$ and replicate padding to the nearest compatible size,

$$ H'=8\left\lceil\frac{H}{8}\right\rceil,\qquad W'=8\left\lceil\frac{W}{8}\right\rceil. $$

For this experiment, $H=1080$ and $W=1920$ are both divisible by 8, so $H'=H$ and $W'=W$: no pixels are actually added and no spatial rescaling is performed.

The shared feature encoder produces 256-channel, 1/8-resolution feature maps $f_1$ and $f_2$. Conceptually, RAFT measures all-pairs similarity by the normalized dot product

$$ C_{ijkl}=\frac{f_1(i,j)^\top f_2(k,l)}{\sqrt{D}},\qquad D=256. $$

The selected Triton implementation computes the correlation lookup without materializing the full volume. At refinement $t$ and pyramid level $\ell$, it bilinearly samples a radius-4 neighborhood around the current correspondence $q_t(p)$:

$$ c_t^{(\ell)}(p,\delta)= \frac{f_1(p)^\top f_2^{(\ell)}!\left(q_t(p)/2^\ell+\delta\right)}{\sqrt D}, \quad \ell\in{0,1,2,3},\quad \delta\in{-4,\ldots,4}^2. $$

Concatenating the four $9\times9$ neighborhoods gives $4(2r+1)^2=324$ correlation channels per pixel. A separate context encoder processes $I_1$ and initializes the recurrent hidden state and context features:

$$ [a,b]=g_\theta(\widetilde I_1),\qquad h_0=\tanh(a),\qquad x=\mathrm{ReLU}(b). $$

RAFT represents low-resolution flow as the difference of two coordinate grids. Both grids initially coincide, hence $F_0=0$. A motion encoder combines the current flow with the sampled correlations, a separable convolutional GRU updates the hidden state, and a two-layer flow head predicts an increment:

$$ F_t=q_t-q_0, $$

$$ m_t=E_{\mathrm{motion}}(F_t,c_t),\qquad h_{t+1}=\mathrm{SepConvGRU}!\left(h_t,[x,m_t]\right), $$

$$ \Delta F_t=H_{\mathrm{flow}}(h_{t+1}),\qquad q_{t+1}=q_t+\Delta F_t. $$

This update is repeated for $T=32$ iterations. The full-resolution prediction uses a learned softmax mask to form a convex combination of each low-resolution vector and its $3\times3$ neighborhood. For a high-resolution subpixel $p$ associated with low-resolution location $x$,

$$ \widehat F_T(p)=\sum_{q\in\mathcal N_3(x)} \mathrm{softmax}(M_T(p))_q,\bigl(8F_T(q)\bigr). $$

The factor 8 converts displacement from feature-grid units to input-pixel units. The notebook evaluates the same network with both frame orders, separately for each camera:

$$ \widehat F_{1\rightarrow2}=\mathrm{RAFT}(I_1,I_2),\qquad \widehat F_{2\rightarrow1}=\mathrm{RAFT}(I_2,I_1). $$

No training loss or optimizer is used in the notebook. Its only learned quantities come from the fixed Sintel checkpoint.

For interpretation of the reported benchmark metrics, let $e_p=\lVert\widehat F(p)-F^*(p)\rVert_2$ for every valid pixel $p\in V$. Then

$$ \mathrm{EPE}=\frac{1}{|V|}\sum_{p\in V}e_p, \qquad \mathrm{1px}=\frac{100}{|V|}\sum_{p\in V}\mathbf{1}[e_p>1], $$

$$ \mathrm{Fl}=\frac{100}{|V|}\sum_{p\in V} \mathbf{1}!\left[e_p>3\ \land\ e_p>0.05\lVert F^*(p)\rVert_2\right]. $$

The devkit's weighted accuracy-under-curve calculation uses thresholds $\delta_i=i/20$ pixels and weights $w_i=1-(i-1)/100$ for $i=1,\ldots,100$:

$$ A(\delta_i)=\frac{1}{|V|}\sum_{p\in V}\mathbf{1}[e_p\le\delta_i], \qquad \mathrm{WAUC}=100\frac{\sum_{i=1}^{100}w_iA(\delta_i)}{\sum_{i=1}^{100}w_i}. $$

Experiment 02 — RAFT fine-tuned on Spring train-left

The second benchmark submission used the separate Spring fine-tuning notebook and fine-tuned inference notebook. RAFT was initialized from the same official Sintel checkpoint as Experiment 01, fine-tuned with Spring left-camera forward-flow labels, and then evaluated at native resolution on both cameras and temporal directions.

Setting	Value
Initialization	raft-sintel-fb44381e.ckpt
Training data	Spring spring-train-left; sequence 0022 held out for validation
Training schedule	1 epoch; batch size 1; gradient accumulation 4
Training crop	540×960
Optimization	AdamW; learning rate 1e-5; weight decay 1e-5; mixed precision
Recurrent refinements	12 during training; 32 during inference
Inference input	Native 1920×1080 Spring test frames; no rescaling
Directions and views	Forward and backward flow, independently for left and right cameras
Submission artifact	Git LFS-tracked HDF5, 696,721,788 bytes

Spring benchmark result

The fine-tuned model returned 7.762% total 1px error, 1.765 px EPE, 3.583% Fl, and 89.986 WAUC. Compared with the inference-only RAFT-Sintel baseline, this one-epoch Spring fine-tune was worse on every aggregate metric: 1px increased by 0.996 points, EPE by 0.252 px, and Fl by 0.483 points, while WAUC decreased by 1.051 points. The result is therefore an informative fine-tuning baseline, not the current best submission.

Experiment	1px total ↓	EPE ↓	Fl ↓	WAUC ↑
RAFT-Sintel inference only	6.766	1.513	3.100	91.037
RAFT fine-tuned on Spring train-left	7.762	1.765	3.583	89.986

The complete benchmark breakdown is:

Region or motion range	1px ↓	EPE ↓	Fl ↓	WAUC ↑
Total	7.762	1.765	3.583	89.986
Low detail	7.397	1.675	3.392	90.291
High detail	65.216	15.930	33.743	41.967
Matched	6.983	1.580	3.145	90.693
Unmatched	39.977	9.400	21.736	60.743
Rigid	4.583	1.377	2.363	92.789
Non-rigid	31.817	4.698	12.820	68.785
Not sky	6.213	0.842	2.485	91.322
Sky	31.302	15.792	20.285	69.691
Motion 0–10 px	4.288	0.827	1.756	93.293
Motion 10–40 px	5.702	0.865	3.475	91.154
Motion 40+ px	42.397	12.049	19.161	59.161

Experiment 03 — MEMFOF zero-shot optical flow

The third benchmark submission was generated by the official MEMFOF zero-shot notebook. It uses the authors' public MEMFOF-Tartan-T-TSKH checkpoint without Spring fine-tuning or test-time augmentation. Three-frame windows produce backward and forward flow around each middle frame at native resolution for both cameras.

Setting	Value
Model	Official MEMFOF, approximately 76 million parameters
Checkpoint	egorchistov/optical-flow-MEMFOF-Tartan-T-TSKH
Checkpoint revision	87b740bed2c7ea4890d98fd0f9d6ef5738254eb9
Spring fine-tuning	None; zero-shot evaluation
Input	Three native 1920×1080 frames; no rescaling
Recurrent refinements	8
Directions and views	Forward and backward flow for left and right cameras
Compute	Kaggle T4×2; sample sharding only, not an ensemble
Submission artifact	Git LFS-tracked HDF5, 662,250,141 bytes

Spring benchmark result

MEMFOF returned 3.640% total 1px error, 0.431 px EPE, 1.356% Fl, and 94.460 WAUC, making it the best of the three recorded submissions on every aggregate metric. Compared with the RAFT-Sintel inference baseline, total 1px error decreased by 3.126 points, EPE by 1.082 px, and Fl by 1.744 points, while WAUC increased by 3.423 points.

Experiment	1px total ↓	EPE ↓	Fl ↓	WAUC ↑
RAFT-Sintel inference only	6.766	1.513	3.100	91.037
RAFT fine-tuned on Spring train-left	7.762	1.765	3.583	89.986
MEMFOF-Tartan-T-TSKH zero-shot	3.640	0.431	1.356	94.460

The complete benchmark breakdown is:

Region or motion range	1px ↓	EPE ↓	Fl ↓	WAUC ↑
Total	3.640	0.431	1.356	94.460
Low detail	3.294	0.397	1.216	94.749
High detail	58.133	5.756	23.458	48.944
Matched	3.085	0.353	1.075	94.990
Unmatched	26.625	3.644	12.973	72.543
Rigid	1.530	0.182	0.779	96.534
Non-rigid	19.607	2.315	5.726	78.771
Not sky	3.744	0.444	1.429	94.523
Sky	2.060	0.237	0.254	93.504
Motion 0–10 px	1.325	0.125	0.392	96.922
Motion 10–40 px	4.561	0.340	2.627	92.987
Motion 40+ px	20.521	3.232	5.984	77.846

Quantitative submission requirements

Generate predictions on the Spring test split using the dataset's Python I/O utilities for .flo5 and .dsp5 files. Preserve the exact dataset sequence numbers, directory layout, and filenames.

Standard evaluation layout

<rootdir>/####/disp1_{left|right}/disp1_{left|right}_####.dsp5
<rootdir>/####/flow_{FW|BW}_{left|right}/flow_{FW|BW}_{left|right}_####.flo5
<rootdir>/####/disp2_{FW|BW}_{left|right}/disp2_{FW|BW}_{left|right}_####.dsp5

These paths correspond to Stereo Matching, Optical Flow, and the additional disparity-over-time output required for Scene Flow, respectively.

Optional robustness evaluation layout

<rootdir>/<corruption>/test/####/disp1_{left|right}/disp1_{left|right}_####.dsp5
<rootdir>/<corruption>/test/####/flow_{FW|BW}_{left|right}/flow_{FW|BW}_{left|right}_####.flo5
<rootdir>/<corruption>/test/####/disp2_{FW|BW}_{left|right}/disp2_{FW|BW}_{left|right}_####.dsp5

Supported top-level folders are clean plus the 20 corruptions: brightness, contrast, defocus_blur, elastic_transform, fog, frost, gaussian_blur, gaussian_noise, glass_blur, impulse_noise, jpeg_compression, motion_blur, pixelate, rain, saturate, shot_noise, snow, spatter, speckle_noise, and zoom_blur.

Run the appropriate official subsampling executable from the submission root to produce an upload-ready .hdf5 file:

./disp1_subsampling <rootdir>       # Stereo Matching
./flow_subsampling <rootdir>        # Optical Flow
./disp2_subsampling <rootdir>       # Scene Flow disparity over time

Use the corresponding *_robust_subsampling executables for robustness submissions. A Scene Flow submission requires all three generated files. Benchmark evaluation takes approximately 1–2 hours; results are private by default and may later be made public anonymously or with the team and method name.

Workshop paper

• Use the official NeurIPS 2026 format with the sglblindworkshop option.
• Submit a single-blind paper with 4–6 main-content pages; references and an optional appendix may be outside that limit.
• Include the exact identifier and name RoCo-45, Flow State in the abstract.
• Submit the reproducibility package with the camera-ready paper.

Official resources

• Experiment 01: executed RAFT-Sintel optical-flow baseline (Kaggle T4×2)
• Experiment 02: RAFT Spring train-left fine-tuning
• Experiment 02: fine-tuned RAFT Spring inference
• Experiment 03: official MEMFOF zero-shot baseline
• Challenge overview
• Participation instructions
• OpenReview submission venue
• Starter Kit
• Spring benchmark
• Spring dataset
• RobustSpring dataset
• Challenge support: roco-spring-org@googlegroups.com

Challenge information was last checked against the official challenge and participation pages on September 8, 2026. The Experiment 01 benchmark result was recorded on September 10, 2026; the Experiment 02 fine-tuned result and Experiment 03 MEMFOF result were recorded on September 12, 2026.