sevir-lr-custom

A custom variant of the SEVIR-LR dataset, created specifically for DFv2 (diffusion-forcing) training.

Why "custom"?

The original full SEVIR dataset contains VIL radar events at 384×384 resolution with 49 frames per event (5-min interval). SEVIR-LR is a spatially and temporally downsampled version created via the save_downsampled_dataset() function in sevir_dataloader.py, which accepts a downsample_dict of (t_factor, h_factor, w_factor).

• Standard SEVIR-LR (used by FlowDAS / PreDiff): created with t_factor=2, h_factor=3, w_factor=3 → 25 frames, 128×128, 10-min interval.
• This custom SEVIR-LR: created with t_factor=1, h_factor=3, w_factor=3 → 49 frames, 128×128, 5-min interval (full temporal resolution).

The data/ folder here contains the custom HDF5 files (with all 49 frames preserved), not the standard SEVIR-LR.

Data flow

(Full SEVIR dataset, 384×384, 49 frames, elsewhere)
        │
        │  save_downsampled_dataset()
        │  downsample_dict = {'vil': (1, 3, 3)}
        │  t_factor=1 (keep all 49 frames), h/w_factor=3 (384→128)
        ▼
data/                          (custom SEVIR-LR HDF5, 128×128, 49 frames)
  └── vil/
      ├── 2017/  SEVIR_VIL_*.h5
      ├── 2018/  SEVIR_VIL_*.h5
      └── 2019/  SEVIR_VIL_*.h5
CATALOG.csv                    (event metadata, filters on pct_missing == 0)
        │
        │  convert_sevirlr_to_pt.py
        │  Reads CATALOG.csv + HDF5 files.
        │  Filters VIL events (pct_missing == 0) → 19207 events.
        │  Rescales uint8 [0,255] → float32 [0,1].
        │  Transposes (H,W,T) → (T,H,W), stacks all events.
        ▼
sevirlr.pt                     (19207, 49, 128, 128)  ~57 GB
        │
        ├──── split_sevirlr.py --src sevirlr.pt --dst sevirlr
        │     Shuffles with seed=42, splits 90/10.
        │
        │         ▼
        │     sevirlr/
        │       ├── train/
        │       │   ├── data.pt   (17287, 49, 128, 128)  ~52 GB
        │       │   └── data.npy  (17287, 49, 128, 128)  ~52 GB  ← used by DFv2
        │       └── val/
        │           ├── data.pt   (1920, 49, 128, 128)   ~5.7 GB
        │           └── data.npy  (1920, 49, 128, 128)   ~5.7 GB ← used by DFv2
        │
        └──── make_sevirlr_tiny.py
              Takes the first 100 trajectories from sevirlr.pt.
                  ▼
              sevirlr_tiny.pt            (100, 49, 128, 128)  ~300 MB
                  │
                  │  split_sevirlr.py --src sevirlr_tiny.pt
                  │  Same 90/10 split.
                  ▼
              sevirlr_tiny/
                ├── train/
                │   ├── data.pt   (90, 49, 128, 128)   ~270 MB
                │   └── data.npy  (90, 49, 128, 128)   ~270 MB
                └── val/
                    ├── data.pt   (10, 49, 128, 128)   ~30 MB
                    └── data.npy  (10, 49, 128, 128)   ~30 MB

The .npy files are produced by convert_pt_to_npy.py from the corresponding .pt files. DFv2's SEVIRDataset loads data.npy with numpy memory-mapping (mmap_mode='r') so DDP workers share the OS page cache instead of each loading a full copy into RAM.

Scripts

Script	Purpose
convert_sevirlr_to_pt.py	HDF5 → single sevirlr.pt
split_sevirlr.py	sevirlr.pt → train/data.pt + val/data.pt (90/10, seed 42)
convert_pt_to_npy.py	data.pt → data.npy (memmap-friendly)
make_sevirlr_tiny.py	First 100 trajectories → sevirlr_tiny.pt (for debugging)
visualize_sevirlr.py	Generates sample GIF grid for visual inspection
visualize_val_gifs.py	Generates per-trajectory val GIFs: python visualize_val_gifs.py <dataset>

Downstream consumer

DFv2's training script (train_sevir_full.sh) sets:

dataset.data_dir=/.../sevir-lr-custom/sevirlr

The SEVIRDataset class then loads <data_dir>/train/data.npy for training and <data_dir>/val/data.npy for validation. No further splitting is done in code — train and val are fully separated on disk.

FlowDAS — different dataset, different pipeline

FlowDAS uses the standard SEVIR-LR dataset (created with t_factor=2, giving 25 frames per event), not this custom version. It reads HDF5 files directly and never touches the .pt / .npy files produced above.

When launched with --sevir_datapath <path_to_standard_sevirlr>, FlowDAS's SEVIRLightningDataModule (in utils_forlookback_sevir_vil.py) expects:

<sevir_dir>/
  ├── CATALOG.csv
  └── data/
      └── vil/
          ├── 2017/  SEVIR_VIL_*.h5   (standard SEVIR-LR: 25 frames, 128×128)
          ├── 2018/  SEVIR_VIL_*.h5
          └── 2019/  SEVIR_VIL_*.h5

All train/val/test splitting is handled internally at runtime:

1. Train+Val vs Test — split by date cutoff train_test_split_date = (2019, 6, 1). Events before the date go to train+val; events on or after go to test.
2. Train vs Val — the train+val portion is further split with random_split(val_ratio=0.1, seed=0).
3. Data loading is done on-the-fly from HDF5 via SEVIRDataLoader (adapted from EarthFormer). Each event is read, rescaled to float32 [0,1] (rescale_method="01"), and returned in NTHWC layout.

The dataset_name is set to "sevirlr", which configures:

• raw_seq_len = 25, interval_real_time = 10 min, img = 128×128

Key differences from DFv2

	DFv2 (this repo)	FlowDAS
Source dataset	Custom SEVIR-LR (t_factor=1)	Standard SEVIR-LR (t_factor=2)
Frames per event	49 (5-min interval)	25 (10-min interval)
Reads from	sevirlr/train/data.npy, sevirlr/val/data.npy	CATALOG.csv + data/vil/*.h5 (raw HDF5)
Preprocessing	Offline (this pipeline)	On-the-fly in dataloader
Train/val split	On disk (90/10, seed 42)	Runtime random_split (90/10, seed 0)
Train/test split	N/A (no test set)	By date (2019, 6, 1)
Loading strategy	numpy memmap (shared page cache)	HDF5 random access per event

sevirlr_paper — curated evaluation subset

sevirlr_paper/val/ contains 24 curated trajectories for paper figures and fair evaluation. It is constructed to guarantee zero overlap with the full training set (sevirlr/train/).

Construction

1. Source: 30 trajectories randomly sampled from sevirlr/val/data.npy (1920 events, seed=2026). Since these come from the held-out val split, none appear in sevirlr/train/.

2. Curation: trajectories with insufficient weather activity were removed. The criterion: for each trajectory, compute the fraction of pixels (across all 49 frames) with VIL intensity > 16 on the uint8 [0, 255] scale — i.e. above the first SEVIR VIL colormap boundary. Trajectories where this fraction is < 5% were dropped. This removes near-empty events and events with only faint noise.

   Dropped (6 trajectories):

   Original index	>16 pixel %	Reason
   2	1.13%	Faint scattered noise
   5	1.28%	Faint scattered noise
   7	0.07%	Near-empty (max intensity 72)
   19	2.39%	Faint haze, no structure
   21	0.00%	Completely empty (all zeros)
   27	4.84%	Very faint, below threshold

3. Result: 24 trajectories, shape (24, 49, 128, 128), float32 [0, 1].

sevirlr_paper/
  └── val/
      ├── data.pt   (24, 49, 128, 128)
      └── data.npy  (24, 49, 128, 128)

GIF visualizations of all 24 trajectories are in visualizations/sevirlr_paper/.

sevirlr_paper_small — truncated subset of sevirlr_paper

A smaller variant of sevirlr_paper for quick experiments or models that use fewer frames.

• Trajectories: first 8 from sevirlr_paper/val/ (indices 0–7).
• Frames: first 20 of 49 (frames 0–19, covering 0–95 min at 5-min interval). The tail 29 frames are discarded.
• Guaranteed no training leakage — inherits from sevirlr_paper, which is sourced entirely from sevirlr/val/.

sevirlr_paper_small/
  └── val/
      ├── data.pt   (8, 20, 128, 128)
      └── data.npy  (8, 20, 128, 128)

GIF visualizations are in visualizations/sevirlr_paper_small/.

sevirlr_paper_small_but_long — few trajectories, full length

Same first 8 trajectories as sevirlr_paper_small, but keeps the full 49 frames (0–240 min) instead of truncating to 20.

sevirlr_paper_small_but_long/
  └── val/
      ├── data.pt   (8, 49, 128, 128)
      └── data.npy  (8, 49, 128, 128)

GIF visualizations are in visualizations/sevirlr_paper_small_but_long/.