tidalove/cfc-track-instruction

This dataset accompanies the paper Teach a Molmo2Fish: Towards interactive fish tracking with natural language guidance.

CFC Track & Track-Correction Instruction Data

Fish tracking and multi-turn track-correction annotations on the Caltech Fish Counting sonar videos, in the Molmo2 video-track-instruction format.

This is the data behind Molmo2Fish — a Molmo2-8B model fine-tuned to edit fish tracks in response to natural-language feedback, rather than only to produce them. A correction example is a conversation: the model is shown a set of starting tracks, told in words what is wrong with them, and asked to return a repaired set.

Code	github.com/tidalove/molmo2fish
Model	tidalove/Molmo2Fish
Source frames	perona-lab/cfc26

No video is stored here. Rows carry annotations and inline RLE masks and refer to clips by video id. Frames come from perona-lab/cfc26; the molmo2fish repo stages them and encodes the mp4s for you (see Usage).

Conventions

Videos are 6 fps clips; annotations are stored at 2 fps. Only native frames with frame % 3 == 0 are annotated, frame keeps the native 6 fps index, and time = frame / 6. Inline masks follow the same convention — mask entry i corresponds to native frame 3 * i.

The clips are not the original CFC videos: they are subsampled 3x in time and many are sliced into shorter, sometimes overlapping segments so that both the tracking and the correction task fit in the model's context window. Metrics reported on this data are not comparable to metrics on the original CFC release.

Configs

Every correction config pairs a starting point (where the step-0 tracks came from) with a prompt tier (how much the correction instruction actually tells you).

Starting points

family	step-0 tracks are…
cfc_synthetic_correction_*	ground truth with corruptions applied artificially
cfc_correction_molmo_high_*	real predictions from a high-performing (late) Molmo2 checkpoint
cfc_correction_molmo_low_*	real predictions from a low-performing (early) Molmo2 checkpoint
cfc_correction_yolo_*	real predictions from a two-stage YOLO+SORT tracking-by-detection pipeline (evaluation only)

Prompt tiers

tier	the correction instruction	example
full	every mistake spelled out, with times and positions	"Track 1 should exit around 38s but stays until the end of the clip. You also missed two fish entirely — a small fish that barely moves around 43-50s on the left side, and another brief fish near the bottom left toward the end around 60s."
vague	the same mistakes, tersely and underspecified	"Track 1 stays too long. Two fish missing, one mid-clip, one late."
wrong_only	generic, but asserts that mistakes exist	"These tracks contain errors. Clean them up."
no_info	generic and non-committal about whether anything is wrong	"Review and refine the tracks if necessary."

All configs

config	task	train	validation
cfc_track	track — one row per clip, "track all fish"	2129	442
cfc_guided	track — one row per query (qid 0 = all fish, others = referred subsets)	7248	1941
cfc_synthetic_correction_full	correction — synthetic step 0	5226	1180
cfc_synthetic_correction_vague	correction — synthetic step 0	5285	1180
cfc_synthetic_correction_wrong_only	correction — synthetic step 0	5285	1180
cfc_synthetic_correction_no_info	correction — synthetic step 0	7414	1622
cfc_synthetic_correction_targeted	correction — partial-fix target (GT is the final step, not the full-video GT)	1650	440
cfc_correction_molmo_high_full	correction — Molmo-high step 0	1241	442
cfc_correction_molmo_high_vague	correction — Molmo-high step 0	1241	442
cfc_correction_molmo_high_wrong_only	correction — Molmo-high step 0	1241	—
cfc_correction_molmo_high_no_info	correction — Molmo-high step 0	2129	442
cfc_correction_molmo_low_full	correction — Molmo-low step 0	1888	380
cfc_correction_molmo_low_vague	correction — Molmo-low step 0	1888	380
cfc_correction_molmo_low_wrong_only	correction — Molmo-low step 0	1888	380
cfc_correction_molmo_low_no_info	correction — Molmo-low step 0	2115	439
cfc_correction_yolo_full	correction — YOLO+SORT step 0	—	344
cfc_correction_yolo_vague	correction — YOLO+SORT step 0	—	344
cfc_correction_yolo_wrong_only	correction — YOLO+SORT step 0	—	344
cfc_correction_yolo_no_info	correction — YOLO+SORT step 0	—	442
cfc_text	text-only correction (no masks, no video input at train time)	1927	256

Schema

Track configs (cfc_track, cfc_guided): id, video, clip, video_dataset, task, expression, qid, prepend, width, height, fps (6), sampling_fps (2), n_frames, start_frame, end_frame, mask_id, obj_id, anno_id, frame_trajectories, masks.

frame_trajectories: list of {frame, time, points: [{id, point: [x, y], occluded}]}. Point id indexes into the mask_id/obj_id slots.

Correction configs replace prepend/anno_id/frame_trajectories with confidence and turns: a list of {correction_step, prompt, frame_trajectories} forming a multi-turn conversation, where step 0 is the starting tracks and later steps are the correction targets.

Prompts are stored raw, with native frame references (frame 404); the loaders rewrite them to timestamps (frame N → {N/fps}s) before the model sees them. Per-turn point ids are per-step slot indices (the sorted track ids of that step), so they are not stable across turns.

masks: list of {object_id, masks: [RLE | null]} — pycocotools RLE ({size: [h, w], counts}), null meaning the object is absent in that frame. For most correction configs these are the base-video ground-truth masks, whose slot order (sorted video track ids) may differ from the per-turn point slots — match by mask content, as the Molmo2Fish eval does. For cfc_synthetic_correction_targeted they encode the final correction step per trajectory instead.

Usage

Just the annotations

import datasets

# pure tracking
track = datasets.load_dataset("tidalove/cfc-track-instruction", "cfc_track", split="validation")

# a correction set: real Molmo2 predictions + fully detailed instructions
corr = datasets.load_dataset(
    "tidalove/cfc-track-instruction", "cfc_correction_molmo_low_full", split="validation")

row = corr[0]
for turn in sorted(row["turns"], key=lambda t: t["correction_step"]):
    print(turn["correction_step"], turn["prompt"][:100])

Decoding masks

from pycocotools import mask as mask_utils

entry = row["masks"][0]                  # one tracked object
rle = next(m for m in entry["masks"] if m is not None)
binary = mask_utils.decode({"size": rle["size"], "counts": rle["counts"].encode()})
# mask entry i corresponds to native frame 3 * i (2 fps annotations over 6 fps video)

With the Molmo2Fish codebase

olmo/data/cfc_hf_datasets.py downloads every config, rehydrates the masks into local MasksRLE/ files, stages frames from perona-lab/cfc26, and encodes the mp4s:

git clone https://github.com/tidalove/molmo2fish.git && cd molmo2fish
pip install torchcodec && pip install -e .[all]

export MOLMO_DATA_DIR=./data
python -m scripts.download_datasets cfc --n-procs 8

Everything lands under $MOLMO_DATA_DIR/video_datasets/video_track/CFC/. Each config is then available under its registered name — the hub config name with a cfc_hf_ prefix, e.g. cfc_correction_molmo_low_full → cfc_hf_correction_molmo_low_full:

# fine-tune on the full correction mixture
torchrun --nproc-per-node=8 launch_scripts/sft.py /path/to/Molmo2-8B cfc_correction \
  --lora_llm --lora_vit --lora_connector --lora_rank 64 --save_folder=/path/to/save

# evaluate a checkpoint on one config
python launch_scripts/hf_eval.py /path/to/hf/checkpoint \
  cfc_hf_correction_molmo_low_full_eval_2fps

Optionally set CFC_STAGE_FRAMES=0 to skip frame staging if you have already placed frames at $MOLMO_DATA_DIR/video_datasets/video_track/CFC/JPEGImages/{video_id}/*.jpg, and CFC_REQUIRE_VIDEO=0 to keep rows whose mp4 is not on disk.

Citation

@article{molmo2fish,
    title={Teach a Molmo2Fish: Towards interactive fish tracking with natural language guidance},
    author={Kai van Brunt and Justin Kay and Sara Beery},
    year={2026}
}