Anonymous WildfireIA canonical dataset release

.gitattributes

@@ -1,60 +1,4 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
 *.npy filter=lfs diff=lfs merge=lfs -text
 *.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text

DATA_LICENSES.md

@@ -0,0 +1,16 @@
+# Data Licenses and Provenance
+
+This release is a derived benchmark artifact built from public data sources.
+Source-specific terms still apply.
+
+- FPA-FOD wildfire occurrence data: USDA Forest Service Research Data Archive.
+- FIRMS/VIIRS active fire detections: NASA FIRMS.
+- gridMET meteorology and fire-danger variables.
+- LANDFIRE vegetation, fuel, and topography rasters.
+- OpenStreetMap roads and fire-station features. OSM-derived access features
+  are subject to OpenStreetMap/ODbL terms.
+- WorldPop population rasters.
+
+The code in `code/` may be redistributed under the repository license chosen
+for the anonymous submission. The data are distributed under source-compatible
+terms rather than a single newly asserted license.

README.md

@@ -0,0 +1,73 @@
+---
+license: other
+pretty_name: WildfireIA Anonymous Benchmark Release
+task_categories:
+- tabular-classification
+- tabular-regression
+- time-series-classification
+- image-classification
+tags:
+- wildfire
+- benchmark
+- geospatial
+- multimodal
+- croissant
+size_categories:
+- 10K<n<100K
+---
+
+# WildfireIA Anonymous Benchmark Release
+
+This anonymous release contains the WildfireIA benchmark data used for review.
+WildfireIA is an event-level benchmark for predicting whether a reported
+Natural wildfire escapes initial attack from public information available at
+fire discovery time.
+
+## Contents
+
+- `data/canonical/raw_feature_tables/`: canonical benchmark tables. These are
+  the primary dataset artifact. They contain event-level tables, source-level
+  feature tables, patch-level canonical tables, labels, splits, and manifests.
+- Model-ready caches are not included in this compact release; regenerate
+  them deterministically from the canonical tables with `code/dataloader.py`.
+- `code/`: anonymous copies of the cache generation, training, and summary
+  scripts.
+- `metadata/`: release manifest and cache generation commands.
+- `croissant.json`: Croissant metadata with Responsible AI fields.
+
+## Tasks
+
+Task 1 predicts initial attack failure. The sample unit is one FPA-FOD Natural
+wildfire event. Events with final size at most 10 ha are labeled 0, events with
+final size at least 50 ha are labeled 1, and intermediate-size events are
+excluded from the Task 1 supervised split.
+
+Task 2 predicts remaining time-to-containment as a regression target,
+`log(1 + containment_hours)`, using the same discovery-time input contract.
+
+## Rebuilding Model-Ready Caches
+
+The canonical tables can regenerate all official model-ready caches:
+
+```bash
+python code/dataloader.py \
+  --base_dir . \
+  --canonical_dir data/canonical/raw_feature_tables \
+  --output_dir data/model_ready \
+  --task ia_failure \
+  --representation all \
+  --weather_days 5 \
+  --input_protocol all \
+  --overwrite
+```
+
+Additional ablation caches are generated by changing `--input_protocol` and
+`--weather_days`; see `metadata/cache_generation_commands.md`.
+
+## Responsible Use
+
+The benchmark is intended for reproducible scientific comparison and ablation
+analysis. It should not be used as a standalone operational dispatch system
+without agency validation. The data are public-source derived, but they include
+wildfire locations, fire-station locations, roads, population density, and other
+geospatial context.

UPLOAD_INSTRUCTIONS.md

@@ -0,0 +1,21 @@
+# Upload Instructions
+
+This folder is a staging copy for the anonymous Hugging Face dataset repository.
+
+Recommended upload workflow:
+
+```bash
+cd <local-project-root>
+git xet install
+git clone <anonymous-huggingface-dataset-ssh-url> <hf-clone>
+rsync -a --info=progress2 <staging-folder>/ <hf-clone>/
+cd <hf-clone>
+git status --short
+git add .
+git commit -m "Anonymous WildfireIA dataset release"
+git push
+```
+
+Before pushing, run a local identity scan for personal names, local usernames,
+absolute machine paths, affiliations, and email addresses. The release should
+only contain anonymous creator metadata during review.

code/dataloader.py

@@ -0,0 +1,1459 @@
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Iterable
+
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import StandardScaler
+
+
+PROJECT_ROOT = Path(".")
+PATCH_SIZE = 29
+CELLS_PER_PATCH = PATCH_SIZE * PATCH_SIZE
+WEATHER_DAY_MAP = {
+    1: [0],
+    2: [-1, 0],
+    3: [-2, -1, 0],
+    4: [-3, -2, -1, 0],
+    5: [-4, -3, -2, -1, 0],
+}
+
+TASKS = {
+    "ia_failure": {
+        "target_column": "ia_failure_label",
+        "task_type": "binary_classification",
+        "raw_column": None,
+    },
+    "containment_time": {
+        "target_column": "log_containment_hours",
+        "task_type": "regression",
+        "raw_column": "containment_hours",
+    },
+}
+
+PROTOCOL_GROUPS = {
+    "metadata": ["metadata"],
+    "firms": ["fire_strict"],
+    "fire": ["fire_strict"],
+    "fire_wide": ["fire_strict", "fire_wide"],
+    "weather": ["weather_aggregate", "fire_danger_aggregate"],
+    "fuel": ["fuel"],
+    "vegetation": ["vegetation"],
+    "topography": ["topography"],
+    "access": ["access"],
+    "human": ["human"],
+    "metadata_vegetation": ["metadata", "vegetation"],
+    "metadata_fuel": ["metadata", "fuel"],
+    "metadata_topography": ["metadata", "topography"],
+    "metadata_access": ["metadata", "access"],
+    "metadata_human": ["metadata", "human"],
+    "all": [
+        "metadata",
+        "fire_strict",
+        "weather_aggregate",
+        "fire_danger_aggregate",
+        "fuel",
+        "vegetation",
+        "topography",
+        "access",
+        "human",
+    ],
+    "all_without_fire": [
+        "metadata",
+        "weather_aggregate",
+        "fire_danger_aggregate",
+        "fuel",
+        "vegetation",
+        "topography",
+        "access",
+        "human",
+    ],
+    "all_without_weather": [
+        "metadata",
+        "fire_strict",
+        "fuel",
+        "vegetation",
+        "topography",
+        "access",
+        "human",
+    ],
+    "all_without_vegetation": [
+        "metadata",
+        "fire_strict",
+        "weather_aggregate",
+        "fire_danger_aggregate",
+        "fuel",
+        "topography",
+        "access",
+        "human",
+    ],
+    "all_without_fuel": [
+        "metadata",
+        "fire_strict",
+        "weather_aggregate",
+        "fire_danger_aggregate",
+        "vegetation",
+        "topography",
+        "access",
+        "human",
+    ],
+    "all_without_topography": [
+        "metadata",
+        "fire_strict",
+        "weather_aggregate",
+        "fire_danger_aggregate",
+        "fuel",
+        "vegetation",
+        "access",
+        "human",
+    ],
+    "all_without_access": [
+        "metadata",
+        "fire_strict",
+        "weather_aggregate",
+        "fire_danger_aggregate",
+        "fuel",
+        "vegetation",
+        "topography",
+        "human",
+    ],
+    "all_without_human": [
+        "metadata",
+        "fire_strict",
+        "weather_aggregate",
+        "fire_danger_aggregate",
+        "fuel",
+        "vegetation",
+        "topography",
+        "access",
+    ],
+}
+
+TEMPORAL_WEATHER_CHANNELS = [
+    "tmmx",
+    "tmmn",
+    "pr",
+    "rmax",
+    "rmin",
+    "sph",
+    "vpd",
+    "vs",
+    "srad",
+    "erc",
+    "bi",
+    "fm100",
+    "fm1000",
+    "wind_dir_sin",
+    "wind_dir_cos",
+]
+
+FUEL_PATCH_CHANNELS = ["fbfm40", "cbd", "cbh", "cc", "ch", "fd", "fvt", "fvc", "fvh"]
+VEGETATION_PATCH_CHANNELS = ["evt", "evc", "evh"]
+STATIC_PATCH_CHANNELS = [*FUEL_PATCH_CHANNELS, *VEGETATION_PATCH_CHANNELS, "elev", "slope", "aspect_sin", "aspect_cos", "pop_density"]
+VIIRS_PATCH_CHANNELS = [
+    "viirs_cell_count_D",
+    "viirs_cell_sum_frp_D",
+    "viirs_cell_max_frp_D",
+    "viirs_cell_mean_frp_D",
+    "viirs_cell_max_bright_ti4_D",
+    "viirs_cell_mean_bright_ti4_D",
+    "viirs_cell_day_count_D",
+    "viirs_cell_night_count_D",
+    "viirs_cell_has_detection_D",
+]
+OSM_PATCH_CHANNELS = [
+    "cell_distance_to_nearest_drivable_road_m",
+    "cell_distance_to_nearest_fire_station_m",
+    "cell_road_length_375m_m",
+    "cell_has_drivable_road",
+    "cell_distance_to_nearest_major_road_m",
+    "cell_distance_to_nearest_track_or_service_road_m",
+]
+TOPO_PATCH_CHANNELS = ["elev", "slope", "aspect_sin", "aspect_cos"]
+PATCH_METADATA_CHANNELS = ["lat", "lon", "discovery_month", "discovery_doy", "discovery_hour"]
+
+KNOWN_CATEGORICAL_COLUMNS = {
+    "state",
+    "county",
+    "cause_classification",
+    "general_cause",
+    "fbfm40_point",
+    "fd_point",
+    "fvt_point",
+    "fvc_point",
+    "fvh_point",
+    "evt_point",
+    "evc_point",
+    "evh_point",
+    "fbfm40_mode_1km",
+    "fbfm40_mode_3km",
+    "fbfm40_mode_5km",
+    "fd_mode_1km",
+    "fd_mode_3km",
+    "fd_mode_5km",
+    "fvt_mode_1km",
+    "fvt_mode_3km",
+    "fvt_mode_5km",
+    "fvc_mode_1km",
+    "fvc_mode_3km",
+    "fvc_mode_5km",
+    "fvh_mode_1km",
+    "fvh_mode_3km",
+    "fvh_mode_5km",
+    "evt_mode_1km",
+    "evt_mode_3km",
+    "evt_mode_5km",
+    "evc_mode_1km",
+    "evc_mode_3km",
+    "evc_mode_5km",
+    "evh_mode_1km",
+    "evh_mode_3km",
+    "evh_mode_5km",
+}
+
+CORE_INDEX_COLUMNS = {"fire_id", "year", "split"}
+
+
+def protocol_groups(input_protocol: str) -> list[str]:
+    if input_protocol not in PROTOCOL_GROUPS:
+        raise KeyError(f"Unknown input_protocol: {input_protocol}")
+    return PROTOCOL_GROUPS[input_protocol]
+
+
+def protocol_includes_weather(input_protocol: str) -> bool:
+    groups = protocol_groups(input_protocol)
+    return "weather_aggregate" in groups or "fire_danger_aggregate" in groups
+
+
+def ensure_project_path(path: Path) -> Path:
+    resolved = path.resolve()
+    if not str(resolved).startswith(str(PROJECT_ROOT)):
+        raise ValueError(f"Path must stay inside {PROJECT_ROOT}: {resolved}")
+    return resolved
+
+
+def load_json(path: Path) -> dict:
+    with path.open("r", encoding="utf-8") as file:
+        return json.load(file)
+
+
+def write_json(path: Path, payload: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as file:
+        json.dump(payload, file, indent=2, sort_keys=True)
+        file.write("\n")
+
+
+def remove_output_dir(path: Path, overwrite: bool) -> None:
+    if path.exists() and overwrite:
+        shutil.rmtree(path)
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def created_at() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def canonical_paths(canonical_dir: Path) -> dict[str, Path]:
+    return {
+        "master": canonical_dir / "master_features_natural_2016_2020.parquet",
+        "weather_daily_event": canonical_dir / "gridmet_daily_event_features_natural_2016_2020.parquet",
+        "grid_index": canonical_dir / "event_grid_375m_index_natural_2016_2020.parquet",
+        "static_patch": canonical_dir / "event_static_patch_375m_natural_2016_2020.parquet",
+        "viirs_patch": canonical_dir / "event_viirs_patch_375m_D_natural_2016_2020.parquet",
+        "weather_daily_patch": canonical_dir / "event_weather_daily_patch_375m_natural_2016_2020.parquet",
+        "weather_aggregate_patch": canonical_dir / "event_weather_aggregate_patch_375m_natural_2016_2020.parquet",
+        "osm_patch": canonical_dir / "event_osm_patch_375m_natural_2016_2020.parquet",
+        "feature_manifest": canonical_dir / "feature_manifest_natural.json",
+        "label_manifest": canonical_dir / "label_manifest_natural.json",
+        "patch_manifest": canonical_dir / "event_patch_manifest_375m_natural.json",
+        "temporal_manifest": canonical_dir / "temporal_protocol_manifest_natural.json",
+    }
+
+
+def required_path_keys() -> list[str]:
+    return [
+        "master",
+        "weather_daily_event",
+        "grid_index",
+        "static_patch",
+        "viirs_patch",
+        "weather_daily_patch",
+        "weather_aggregate_patch",
+        "osm_patch",
+        "feature_manifest",
+        "label_manifest",
+        "patch_manifest",
+        "temporal_manifest",
+    ]
+
+
+def load_manifests(paths: dict[str, Path]) -> tuple[dict, dict, dict, dict]:
+    return (
+        load_json(paths["feature_manifest"]),
+        load_json(paths["label_manifest"]),
+        load_json(paths["patch_manifest"]),
+        load_json(paths["temporal_manifest"]),
+    )
+
+
+def output_subdir(output_dir: Path, task: str, representation: str, weather_days: int, input_protocol: str) -> Path:
+    return output_dir / task / representation / f"weather{weather_days}_{input_protocol}"
+
+
+def target_info(task: str) -> dict:
+    if task not in TASKS:
+        raise KeyError(f"Unknown task: {task}")
+    return TASKS[task]
+
+
+def filter_task_samples(master: pd.DataFrame, task: str) -> pd.DataFrame:
+    info = target_info(task)
+    target_col = info["target_column"]
+    if target_col not in master.columns:
+        raise KeyError(f"Target column not found in master_features: {target_col}")
+    filtered = master.loc[master[target_col].notna()].copy()
+    filtered["target"] = filtered[target_col]
+    if task == "ia_failure":
+        filtered["target"] = filtered["target"].astype(int)
+    return filtered
+
+
+def apply_input_protocol_sample_filter(samples: pd.DataFrame, input_protocol: str) -> pd.DataFrame:
+    """Apply protocol-level sample restrictions without changing task labels."""
+    if input_protocol != "firms":
+        return samples
+    match_col = "viirs_num_assigned_detections_D"
+    fallback_col = "has_viirs_detection_1km_D"
+    filtered = samples.copy()
+    if match_col in filtered.columns:
+        mask = pd.to_numeric(filtered[match_col], errors="coerce").fillna(0) > 0
+    elif fallback_col in filtered.columns:
+        mask = pd.to_numeric(filtered[fallback_col], errors="coerce").fillna(0) > 0
+    else:
+        raise KeyError(
+            "input_protocol=firms requires viirs_num_assigned_detections_D "
+            "or has_viirs_detection_1km_D in master_features."
+        )
+    before = len(filtered)
+    filtered = filtered.loc[mask].copy()
+    print(f"FIRMS-only sample filter retained {len(filtered)} / {before} task samples.")
+    return filtered
+
+
+def normalize_master_metadata(master: pd.DataFrame) -> pd.DataFrame:
+    master = master.copy()
+    if "year" not in master.columns:
+        for candidate in ["year_x", "year_y", "FIRE_YEAR"]:
+            if candidate in master.columns:
+                master["year"] = master[candidate]
+                break
+    if "split" not in master.columns and "split_x" in master.columns:
+        master["split"] = master["split_x"]
+    if "year" in master.columns:
+        master["year"] = pd.to_numeric(master["year"], errors="coerce").astype("Int64")
+    return master
+
+
+def build_sample_index(samples: pd.DataFrame, master: pd.DataFrame, task: str) -> pd.DataFrame:
+    samples = normalize_master_metadata(samples)
+    master = normalize_master_metadata(master)
+    info = target_info(task)
+    target_col = info["target_column"]
+    raw_col = info["raw_column"]
+    sample_index = samples.copy()
+    recover_cols = ["fire_id", "year", "split", target_col]
+    if raw_col:
+        recover_cols.append(raw_col)
+    missing = [col for col in recover_cols if col not in sample_index.columns]
+    if missing:
+        recovered = master[[col for col in recover_cols if col in master.columns]].copy()
+        recovered["fire_id"] = recovered["fire_id"].astype(str)
+        sample_index["fire_id"] = sample_index["fire_id"].astype(str)
+        sample_index = sample_index.merge(recovered, on="fire_id", how="left", suffixes=("", "_from_master"))
+        for col in missing:
+            from_master = f"{col}_from_master"
+            if from_master in sample_index.columns:
+                sample_index[col] = sample_index[from_master]
+
+    if target_col not in sample_index.columns and "target" in sample_index.columns:
+        sample_index[target_col] = sample_index["target"]
+    required = ["fire_id", "year", "split", target_col]
+    if raw_col:
+        required.append(raw_col)
+    still_missing = [col for col in required if col not in sample_index.columns]
+    if still_missing:
+        raise KeyError(f"Sample index is missing required metadata columns: {still_missing}")
+    sample_index = sample_index[required].copy()
+    sample_index["fire_id"] = sample_index["fire_id"].astype(str)
+    return sample_index
+
+
+def split_frames(samples: pd.DataFrame) -> dict[str, pd.DataFrame]:
+    return {
+        "train": samples.loc[samples["split"] == "train"].copy(),
+        "val": samples.loc[samples["split"] == "val"].copy(),
+        "test": samples.loc[samples["split"] == "test"].copy(),
+    }
+
+
+def split_years(split: str) -> list[int]:
+    if split == "train":
+        return [2016, 2017, 2018]
+    if split == "val":
+        return [2019]
+    if split == "test":
+        return [2020]
+    raise ValueError(split)
+
+
+def weather_feature_allowed(col: str, weather_days: int) -> bool:
+    suffix_windows = {
+        "lag1": 2,
+        "mean2": 2,
+        "sum2": 2,
+        "mean3": 3,
+        "sum3": 3,
+        "mean4": 4,
+        "sum4": 4,
+        "mean5": 5,
+        "sum5": 5,
+    }
+    if col.endswith("_day0"):
+        return True
+    for suffix, min_days in suffix_windows.items():
+        if col.endswith(f"_{suffix}"):
+            return weather_days >= min_days
+    return True
+
+
+def requested_feature_columns(
+    feature_manifest: dict,
+    input_protocol: str,
+    weather_days: int,
+    master_columns: Iterable[str],
+    target_col: str,
+) -> tuple[list[str], list[str]]:
+    forbidden = set(feature_manifest.get("forbidden_as_features", []))
+    forbidden.update(
+        [
+            target_col,
+            "fire_size_acres",
+            "fire_size_ha",
+            "ia_failure_label",
+            "contain_dt",
+            "containment_hours",
+            "log_containment_hours",
+            "log_fire_size_ha",
+        ]
+    )
+    master_columns = set(master_columns)
+    requested = []
+    for group in protocol_groups(input_protocol):
+        requested.extend(feature_manifest.get(group, []))
+    requested = list(dict.fromkeys(requested))
+    removed = [col for col in requested if col in forbidden]
+    selected = []
+    missing = []
+    for col in requested:
+        if col in forbidden:
+            continue
+        if col not in master_columns:
+            missing.append(col)
+            continue
+        if col in feature_manifest.get("weather_aggregate", []) or col in feature_manifest.get("fire_danger_aggregate", []):
+            if not weather_feature_allowed(col, weather_days):
+                removed.append(col)
+                continue
+        selected.append(col)
+    return selected, sorted(set(removed + missing))
+
+
+def static_protocol_columns(
+    feature_manifest: dict,
+    input_protocol: str,
+    weather_days: int,
+    master_columns: Iterable[str],
+    target_col: str,
+) -> tuple[list[str], list[str]]:
+    if input_protocol == "weather":
+        return [], []
+    if input_protocol == "all" or input_protocol.startswith("all_without_"):
+        groups = [
+            group
+            for group in protocol_groups(input_protocol)
+            if group not in {"weather_aggregate", "fire_danger_aggregate"}
+        ]
+    elif input_protocol == "fire_wide":
+        groups = ["fire_strict", "fire_wide"]
+    else:
+        groups = protocol_groups(input_protocol)
+    pseudo_manifest = dict(feature_manifest)
+    selected_requested = []
+    for group in groups:
+        selected_requested.extend(feature_manifest.get(group, []))
+    pseudo_manifest["_static"] = selected_requested
+    old = PROTOCOL_GROUPS.get("_static")
+    PROTOCOL_GROUPS["_static"] = ["_static"]
+    try:
+        cols, removed = requested_feature_columns(pseudo_manifest, "_static", weather_days, master_columns, target_col)
+    finally:
+        if old is None:
+            PROTOCOL_GROUPS.pop("_static", None)
+        else:
+            PROTOCOL_GROUPS["_static"] = old
+    return cols, removed
+
+
+def infer_categorical_columns(df: pd.DataFrame, columns: list[str]) -> list[str]:
+    categorical = []
+    for col in columns:
+        if col in KNOWN_CATEGORICAL_COLUMNS:
+            categorical.append(col)
+        elif (
+            pd.api.types.is_object_dtype(df[col])
+            or pd.api.types.is_string_dtype(df[col])
+            or isinstance(df[col].dtype, pd.CategoricalDtype)
+        ):
+            categorical.append(col)
+    return categorical
+
+
+def fit_transform_event_features(
+    train_df: pd.DataFrame,
+    val_df: pd.DataFrame,
+    test_df: pd.DataFrame,
+    feature_cols: list[str],
+    standardize: bool,
+) -> tuple[dict[str, np.ndarray], list[str], dict]:
+    if not feature_cols:
+        arrays = {
+            "train": np.zeros((len(train_df), 0), dtype=np.float32),
+            "val": np.zeros((len(val_df), 0), dtype=np.float32),
+            "test": np.zeros((len(test_df), 0), dtype=np.float32),
+        }
+        return arrays, [], {
+            "categorical_columns": [],
+            "numeric_columns": [],
+            "imputer_policy": "none",
+            "scaler_policy": "none",
+        }
+
+    categorical_cols = infer_categorical_columns(train_df, feature_cols)
+    numeric_cols = [col for col in feature_cols if col not in categorical_cols]
+
+    numeric_train = train_df[numeric_cols].apply(pd.to_numeric, errors="coerce") if numeric_cols else pd.DataFrame(index=train_df.index)
+    numeric_val = val_df[numeric_cols].apply(pd.to_numeric, errors="coerce") if numeric_cols else pd.DataFrame(index=val_df.index)
+    numeric_test = test_df[numeric_cols].apply(pd.to_numeric, errors="coerce") if numeric_cols else pd.DataFrame(index=test_df.index)
+
+    medians = numeric_train.median()
+    medians = medians.fillna(0.0)
+    numeric_train = numeric_train.fillna(medians)
+    numeric_val = numeric_val.fillna(medians)
+    numeric_test = numeric_test.fillna(medians)
+
+    scaler_metadata = {"standardize": bool(standardize), "mean": {}, "scale": {}}
+    if standardize and numeric_cols:
+        scaler = StandardScaler()
+        train_numeric_values = scaler.fit_transform(numeric_train.to_numpy(dtype=np.float64))
+        val_numeric_values = scaler.transform(numeric_val.to_numpy(dtype=np.float64))
+        test_numeric_values = scaler.transform(numeric_test.to_numpy(dtype=np.float64))
+        scaler_metadata["mean"] = dict(zip(numeric_cols, scaler.mean_.tolist()))
+        scaler_metadata["scale"] = dict(zip(numeric_cols, scaler.scale_.tolist()))
+    else:
+        train_numeric_values = numeric_train.to_numpy(dtype=np.float64)
+        val_numeric_values = numeric_val.to_numpy(dtype=np.float64)
+        test_numeric_values = numeric_test.to_numpy(dtype=np.float64)
+
+    if categorical_cols:
+        train_cat = pd.get_dummies(train_df[categorical_cols].fillna("Unknown").astype(str), columns=categorical_cols)
+        val_cat = pd.get_dummies(val_df[categorical_cols].fillna("Unknown").astype(str), columns=categorical_cols)
+        test_cat = pd.get_dummies(test_df[categorical_cols].fillna("Unknown").astype(str), columns=categorical_cols)
+        cat_cols = list(train_cat.columns)
+        val_cat = val_cat.reindex(columns=cat_cols, fill_value=0)
+        test_cat = test_cat.reindex(columns=cat_cols, fill_value=0)
+        train_values = np.concatenate([train_numeric_values, train_cat.to_numpy(dtype=np.float64)], axis=1)
+        val_values = np.concatenate([val_numeric_values, val_cat.to_numpy(dtype=np.float64)], axis=1)
+        test_values = np.concatenate([test_numeric_values, test_cat.to_numpy(dtype=np.float64)], axis=1)
+    else:
+        cat_cols = []
+        train_values = train_numeric_values
+        val_values = val_numeric_values
+        test_values = test_numeric_values
+
+    feature_names = numeric_cols + cat_cols
+    arrays = {
+        "train": train_values.astype(np.float32),
+        "val": val_values.astype(np.float32),
+        "test": test_values.astype(np.float32),
+    }
+    metadata = {
+        "categorical_columns": categorical_cols,
+        "numeric_columns": numeric_cols,
+        "categorical_encoder": "pandas.get_dummies_fit_on_train_align_val_test",
+        "categorical_dummy_columns": cat_cols,
+        "imputer_policy": "numeric train median, categorical Unknown",
+        "numeric_medians": medians.to_dict(),
+        "scaler_policy": "StandardScaler fit on train numeric columns" if standardize and numeric_cols else "not_standardized",
+        "scaler": scaler_metadata,
+    }
+    return arrays, feature_names, metadata
+
+
+def write_sample_index_outputs(
+    out_dir: Path,
+    split: str,
+    n_rows: int,
+    y: np.ndarray,
+    sample_index: pd.DataFrame,
+    task: str,
+) -> None:
+    target_col = target_info(task)["target_column"]
+    raw_col = target_info(task)["raw_column"]
+    expected_cols = ["fire_id", "year", "split", target_col]
+    if raw_col:
+        expected_cols.append(raw_col)
+    missing = [col for col in expected_cols if col not in sample_index.columns]
+    if missing:
+        raise KeyError(f"sample_index for {split} missing columns: {missing}")
+    if n_rows != len(y):
+        raise ValueError(f"{split}: n_rows={n_rows} does not match len(y)={len(y)}")
+    if n_rows != len(sample_index):
+        raise ValueError(f"{split}: n_rows={n_rows} does not match len(sample_index)={len(sample_index)}")
+    target_values = sample_index[target_col].to_numpy()
+    if not np.allclose(y.astype(float), target_values.astype(float), equal_nan=True):
+        raise ValueError(f"{split}: y array order/values do not match sample_index {target_col}")
+    fire_ids = sample_index["fire_id"].astype(str).to_numpy()
+    if len(fire_ids) != n_rows:
+        raise ValueError(f"{split}: fire_id order length does not match row count")
+
+    np.save(out_dir / f"y_{split}.npy", y)
+    np.save(out_dir / f"fire_id_{split}.npy", fire_ids)
+    saved_fire_ids = np.load(out_dir / f"fire_id_{split}.npy", allow_pickle=True).astype(str)
+    if not np.array_equal(saved_fire_ids, fire_ids):
+        raise ValueError(f"{split}: saved fire_id array does not match sample_index order")
+    if raw_col:
+        np.save(out_dir / f"{raw_col}_{split}.npy", sample_index[raw_col].to_numpy(dtype=np.float32))
+    sample_index[expected_cols].to_parquet(out_dir / f"sample_index_{split}.parquet", index=False)
+
+
+def write_split_outputs(
+    out_dir: Path,
+    split: str,
+    X: np.ndarray,
+    y: np.ndarray,
+    sample_index: pd.DataFrame,
+    task: str,
+) -> None:
+    write_sample_index_outputs(out_dir, split, len(X), y, sample_index, task)
+    np.save(out_dir / f"X_{split}.npy", X)
+
+
+def write_seq_split_outputs(
+    out_dir: Path,
+    split: str,
+    X_seq: np.ndarray,
+    X_static: np.ndarray,
+    y: np.ndarray,
+    sample_index: pd.DataFrame,
+    task: str,
+) -> None:
+    if len(X_seq) != len(y):
+        raise ValueError(f"{split}: len(X_seq)={len(X_seq)} does not match len(y)={len(y)}")
+    if len(X_static) != len(y):
+        raise ValueError(f"{split}: len(X_static)={len(X_static)} does not match len(y)={len(y)}")
+    write_sample_index_outputs(out_dir, split, len(X_seq), y, sample_index, task)
+    np.save(out_dir / f"X_seq_{split}.npy", X_seq)
+    np.save(out_dir / f"X_static_{split}.npy", X_static)
+
+
+def save_metadata(out_dir: Path, metadata: dict) -> None:
+    write_json(out_dir / "metadata.json", metadata)
+
+
+def build_tabular_cache(args, paths: dict[str, Path], feature_manifest: dict) -> Path:
+    out_dir = output_subdir(args.output_dir, args.task, "tabular", args.weather_days, args.input_protocol)
+    if (out_dir / "X_train.npy").exists() and not args.overwrite:
+        print(f"Reusing existing tabular cache: {out_dir}")
+        return out_dir
+    remove_output_dir(out_dir, args.overwrite)
+
+    master = normalize_master_metadata(read_parquet_robust(paths["master"]))
+    samples = apply_input_protocol_sample_filter(filter_task_samples(master, args.task), args.input_protocol)
+    splits = split_frames(samples)
+    sample_index_splits = split_frames(build_sample_index(samples, master, args.task))
+    target_col = target_info(args.task)["target_column"]
+    feature_cols, removed = requested_feature_columns(
+        feature_manifest, args.input_protocol, args.weather_days, master.columns, target_col
+    )
+    arrays, feature_names, preprocessing = fit_transform_event_features(
+        splits["train"], splits["val"], splits["test"], feature_cols, args.standardize
+    )
+    for split, frame in splits.items():
+        y = frame["target"].to_numpy(dtype=np.float32)
+        write_split_outputs(out_dir, split, arrays[split], y, sample_index_splits[split], args.task)
+    write_json(out_dir / "feature_names.json", {"feature_names": feature_names})
+    save_metadata(
+        out_dir,
+        {
+            "task": args.task,
+            "representation": "tabular",
+            "input_protocol": args.input_protocol,
+            "weather_days": args.weather_days,
+            "feature_names": feature_names,
+            "source_feature_columns": feature_cols,
+            "target_column": target_col,
+            "split_counts": {split: int(len(frame)) for split, frame in splits.items()},
+            "forbidden_columns_removed": removed,
+            "missing_value_policy": preprocessing["imputer_policy"],
+            "imputer_policy": preprocessing["imputer_policy"],
+            "scaler_policy": preprocessing["scaler_policy"],
+            "preprocessing": preprocessing,
+            "created_at": created_at(),
+        },
+    )
+    print(f"Wrote tabular cache: {out_dir}")
+    return out_dir
+
+
+def train_weather_medians(weather_daily: pd.DataFrame, train_fire_ids: np.ndarray, rel_days: list[int], channels: list[str]) -> pd.Series:
+    train_weather = weather_daily.loc[
+        weather_daily["fire_id"].astype(str).isin(set(train_fire_ids.astype(str)))
+        & weather_daily["relative_day"].isin(rel_days)
+    ]
+    medians = train_weather[channels].apply(pd.to_numeric, errors="coerce").median()
+    return medians.fillna(0.0)
+
+
+def build_sequence_array(
+    weather_daily: pd.DataFrame,
+    sample_df: pd.DataFrame,
+    rel_days: list[int],
+    channels: list[str],
+    medians: pd.Series,
+    scaler: StandardScaler | None,
+) -> np.ndarray:
+    n = len(sample_df)
+    t = len(rel_days)
+    if not channels:
+        return np.zeros((n, t, 0), dtype=np.float32)
+    fire_order = sample_df[["fire_id"]].copy()
+    fire_order["fire_order"] = np.arange(n)
+    base = pd.MultiIndex.from_product(
+        [sample_df["fire_id"].astype(str).to_list(), rel_days],
+        names=["fire_id", "relative_day"],
+    ).to_frame(index=False)
+    base = base.merge(fire_order, on="fire_id", how="left")
+    weather = weather_daily[["fire_id", "relative_day"] + channels].copy()
+    weather["fire_id"] = weather["fire_id"].astype(str)
+    merged = base.merge(weather, on=["fire_id", "relative_day"], how="left")
+    values = merged[channels].apply(pd.to_numeric, errors="coerce").fillna(medians).to_numpy(dtype=np.float64)
+    if scaler is not None and channels:
+        values = scaler.transform(values)
+    merged_values = values.reshape(n, t, len(channels))
+    return merged_values.astype(np.float32)
+
+
+def build_temporal_cache(args, paths: dict[str, Path], feature_manifest: dict) -> Path:
+    out_dir = output_subdir(args.output_dir, args.task, "temporal", args.weather_days, args.input_protocol)
+    if (out_dir / "X_seq_train.npy").exists() and not args.overwrite:
+        print(f"Reusing existing temporal cache: {out_dir}")
+        return out_dir
+    remove_output_dir(out_dir, args.overwrite)
+
+    master = normalize_master_metadata(read_parquet_robust(paths["master"]))
+    weather_daily = read_parquet_robust(paths["weather_daily_event"])
+    samples = apply_input_protocol_sample_filter(filter_task_samples(master, args.task), args.input_protocol)
+    splits = split_frames(samples)
+    sample_index_splits = split_frames(build_sample_index(samples, master, args.task))
+    rel_days = WEATHER_DAY_MAP[args.weather_days]
+    target_col = target_info(args.task)["target_column"]
+
+    seq_channels = TEMPORAL_WEATHER_CHANNELS if protocol_includes_weather(args.input_protocol) else []
+    seq_channels = [col for col in seq_channels if col in weather_daily.columns]
+    medians = train_weather_medians(weather_daily, splits["train"]["fire_id"].astype(str).to_numpy(), rel_days, seq_channels) if seq_channels else pd.Series(dtype=float)
+    seq_scaler = None
+    if args.standardize and seq_channels:
+        train_long = weather_daily.loc[
+            weather_daily["fire_id"].astype(str).isin(set(splits["train"]["fire_id"].astype(str)))
+            & weather_daily["relative_day"].isin(rel_days),
+            seq_channels,
+        ].apply(pd.to_numeric, errors="coerce").fillna(medians)
+        seq_scaler = StandardScaler().fit(train_long.to_numpy(dtype=np.float64))
+
+    static_cols, removed = static_protocol_columns(
+        feature_manifest, args.input_protocol, args.weather_days, master.columns, target_col
+    )
+    static_arrays, static_feature_names, static_preprocessing = fit_transform_event_features(
+        splits["train"], splits["val"], splits["test"], static_cols, args.standardize
+    )
+
+    for split, frame in splits.items():
+        X_seq = build_sequence_array(weather_daily, frame, rel_days, seq_channels, medians, seq_scaler)
+        X_static = static_arrays[split]
+        y = frame["target"].to_numpy(dtype=np.float32)
+        write_seq_split_outputs(out_dir, split, X_seq, X_static, y, sample_index_splits[split], args.task)
+    write_json(out_dir / "temporal_feature_names.json", {"feature_names": seq_channels})
+    write_json(out_dir / "static_feature_names.json", {"feature_names": static_feature_names})
+    save_metadata(
+        out_dir,
+        {
+            "task": args.task,
+            "representation": "temporal",
+            "input_protocol": args.input_protocol,
+            "weather_days": args.weather_days,
+            "relative_days": rel_days,
+            "temporal_feature_names": seq_channels,
+            "static_feature_names": static_feature_names,
+            "target_column": target_col,
+            "split_counts": {split: int(len(frame)) for split, frame in splits.items()},
+            "forbidden_columns_removed": removed,
+            "missing_value_policy": "weather numeric train median; static uses tabular policy",
+            "scaler_policy": "StandardScaler fit on train only" if args.standardize else "not_standardized",
+            "static_preprocessing": static_preprocessing,
+            "created_at": created_at(),
+        },
+    )
+    print(f"Wrote temporal cache: {out_dir}")
+    return out_dir
+
+
+def parquet_files_under(path: Path) -> list[Path]:
+    if path.is_file():
+        return [path]
+    return sorted(p for p in path.rglob("*.parquet") if p.is_file())
+
+
+def _file_parquet_columns(path: Path) -> set[str]:
+    try:
+        import pyarrow.parquet as pq
+
+        return set(pq.ParquetFile(path).schema.names)
+    except Exception:
+        return set(pd.read_parquet(path).columns)
+
+
+def _read_parquet_file_existing_columns(path: Path, columns: list[str] | None = None) -> pd.DataFrame:
+    if columns is None:
+        return pd.read_parquet(path)
+    available = _file_parquet_columns(path)
+    keep = [col for col in columns if col in available]
+    if not keep:
+        return pd.DataFrame(index=range(0))
+    return pd.read_parquet(path, columns=keep)
+
+
+def read_parquet_robust(path: Path, columns: list[str] | None = None) -> pd.DataFrame:
+    """Read parquet files without asking pyarrow to merge hive partitions."""
+    path = Path(path)
+    if path.is_file():
+        return _read_parquet_file_existing_columns(path, columns=columns)
+    files = parquet_files_under(path)
+    if not files:
+        return pd.DataFrame()
+    frames = [_read_parquet_file_existing_columns(part, columns=columns) for part in files]
+    return pd.concat(frames, ignore_index=True)
+
+
+def read_parquet_parts_sample(path: Path, columns: list[str] | None = None, max_parts: int = 2) -> pd.DataFrame:
+    """Read a few physical parquet part files for cheap validation."""
+    path = Path(path)
+    files = parquet_files_under(path)[:max_parts]
+    if not files:
+        return pd.DataFrame()
+    frames = [_read_parquet_file_existing_columns(part, columns=columns) for part in files]
+    return pd.concat(frames, ignore_index=True)
+
+
+def read_parquet_files(files: list[Path], columns: list[str] | None = None) -> pd.DataFrame:
+    if not files:
+        return pd.DataFrame()
+    return pd.concat([_read_parquet_file_existing_columns(file, columns=columns) for file in files], ignore_index=True)
+
+
+def read_patch_table(path: Path, years: list[int], columns: list[str] | None = None, relative_days: list[int] | None = None) -> pd.DataFrame:
+    files = []
+    if path.is_file():
+        frame = read_parquet_robust(path, columns=columns)
+        if "year" in frame.columns:
+            frame = frame.loc[frame["year"].isin(years)]
+        if relative_days is not None and "relative_day" in frame.columns:
+            frame = frame.loc[frame["relative_day"].isin(relative_days)]
+        return frame
+    for year in years:
+        year_dir = path / f"year={year}"
+        if not year_dir.exists():
+            continue
+        if relative_days is None:
+            files.extend(parquet_files_under(year_dir))
+        else:
+            for rel in relative_days:
+                rel_dir = year_dir / f"relative_day={rel}"
+                files.extend(parquet_files_under(rel_dir))
+    return read_parquet_files(files, columns=columns)
+
+
+def protocol_patch_sources(input_protocol: str, weather_days: int) -> dict[str, list[str]]:
+    sources = {"metadata": [], "static": [], "viirs": [], "weather": [], "osm": []}
+    if input_protocol.startswith("metadata_"):
+        sources["metadata"] = PATCH_METADATA_CHANNELS
+        input_protocol = input_protocol.replace("metadata_", "", 1)
+    if input_protocol in {"firms", "fire"}:
+        sources["viirs"] = VIIRS_PATCH_CHANNELS
+    elif input_protocol == "fire_wide":
+        sources["viirs"] = VIIRS_PATCH_CHANNELS
+    elif input_protocol == "weather":
+        sources["weather"] = None
+    elif input_protocol == "fuel":
+        sources["static"] = FUEL_PATCH_CHANNELS
+    elif input_protocol == "vegetation":
+        sources["static"] = VEGETATION_PATCH_CHANNELS
+    elif input_protocol == "topography":
+        sources["static"] = TOPO_PATCH_CHANNELS
+    elif input_protocol == "access":
+        sources["osm"] = OSM_PATCH_CHANNELS
+    elif input_protocol == "human":
+        sources["static"] = ["pop_density"]
+    elif input_protocol == "all":
+        sources["static"] = STATIC_PATCH_CHANNELS
+        sources["viirs"] = VIIRS_PATCH_CHANNELS
+        sources["weather"] = None
+        sources["osm"] = OSM_PATCH_CHANNELS
+    elif input_protocol.startswith("all_without_"):
+        removed = input_protocol.replace("all_without_", "", 1)
+        static_channels = list(STATIC_PATCH_CHANNELS)
+        if removed == "fire":
+            sources["static"] = static_channels
+            sources["weather"] = None
+            sources["osm"] = OSM_PATCH_CHANNELS
+        elif removed == "weather":
+            sources["static"] = static_channels
+            sources["viirs"] = VIIRS_PATCH_CHANNELS
+            sources["osm"] = OSM_PATCH_CHANNELS
+        elif removed == "vegetation":
+            sources["static"] = [ch for ch in static_channels if ch not in VEGETATION_PATCH_CHANNELS]
+            sources["viirs"] = VIIRS_PATCH_CHANNELS
+            sources["weather"] = None
+            sources["osm"] = OSM_PATCH_CHANNELS
+        elif removed == "fuel":
+            sources["static"] = [ch for ch in static_channels if ch not in FUEL_PATCH_CHANNELS]
+            sources["viirs"] = VIIRS_PATCH_CHANNELS
+            sources["weather"] = None
+            sources["osm"] = OSM_PATCH_CHANNELS
+        elif removed == "topography":
+            sources["static"] = [ch for ch in static_channels if ch not in TOPO_PATCH_CHANNELS]
+            sources["viirs"] = VIIRS_PATCH_CHANNELS
+            sources["weather"] = None
+            sources["osm"] = OSM_PATCH_CHANNELS
+        elif removed == "access":
+            sources["static"] = static_channels
+            sources["viirs"] = VIIRS_PATCH_CHANNELS
+            sources["weather"] = None
+        elif removed == "human":
+            sources["static"] = [ch for ch in static_channels if ch != "pop_density"]
+            sources["viirs"] = VIIRS_PATCH_CHANNELS
+            sources["weather"] = None
+            sources["osm"] = OSM_PATCH_CHANNELS
+        else:
+            raise KeyError(input_protocol)
+    elif input_protocol == "metadata":
+        sources["metadata"] = PATCH_METADATA_CHANNELS
+    else:
+        raise KeyError(input_protocol)
+    return sources
+
+
+def weather_aggregate_patch_channels(path: Path, years: list[int], weather_days: int) -> list[str]:
+    sample = read_patch_table(path, years[:1], columns=None)
+    if sample.empty:
+        return []
+    key_cols = {"fire_id", "year", "split", "row", "col", "cell_id"}
+    channels = [col for col in sample.columns if col not in key_cols and weather_feature_allowed(col, weather_days)]
+    return channels
+
+
+def read_joined_spatial_patch(
+    paths: dict[str, Path],
+    sample_df: pd.DataFrame,
+    input_protocol: str,
+    weather_days: int,
+    include_weather_daily: bool = False,
+    relative_days: list[int] | None = None,
+) -> tuple[pd.DataFrame, list[str]]:
+    years = sorted(sample_df["year"].unique().tolist())
+    fire_ids = set(sample_df["fire_id"].astype(str))
+    patch_key_cols = ["fire_id", "row", "col", "cell_id"]
+    base_cols = patch_key_cols
+    base = read_patch_table(paths["grid_index"], years, columns=base_cols)
+    if base.empty:
+        raise ValueError("Grid index patch table is empty or missing for requested years.")
+    base["fire_id"] = base["fire_id"].astype(str)
+    base = base.loc[base["fire_id"].isin(fire_ids)].copy()
+
+    channel_names = []
+    sources = protocol_patch_sources(input_protocol, weather_days)
+
+    if sources["metadata"]:
+        present = [c for c in sources["metadata"] if c in sample_df.columns]
+        if present:
+            metadata = sample_df[["fire_id"] + present].copy()
+            metadata["fire_id"] = metadata["fire_id"].astype(str)
+            base = base.merge(metadata, on="fire_id", how="left")
+            channel_names.extend(present)
+
+    if sources["static"]:
+        cols = patch_key_cols + sources["static"]
+        static = read_patch_table(paths["static_patch"], years, columns=cols)
+        static["fire_id"] = static["fire_id"].astype(str)
+        keep_cols = [c for c in cols if c in static.columns]
+        static = static.loc[static["fire_id"].isin(fire_ids), keep_cols]
+        present = [c for c in sources["static"] if c in static.columns]
+        base = base.merge(static[["fire_id", "row", "col", "cell_id"] + present], on=["fire_id", "row", "col", "cell_id"], how="left")
+        channel_names.extend(present)
+
+    if sources["viirs"]:
+        viirs = read_patch_table(paths["viirs_patch"], years, columns=patch_key_cols + sources["viirs"])
+        viirs["fire_id"] = viirs["fire_id"].astype(str)
+        present = [c for c in sources["viirs"] if c in viirs.columns]
+        viirs = viirs.loc[viirs["fire_id"].isin(fire_ids), ["fire_id", "row", "col", "cell_id"] + present]
+        base = base.merge(viirs, on=["fire_id", "row", "col", "cell_id"], how="left")
+        channel_names.extend(present)
+
+    if sources["weather"] is None and protocol_includes_weather(input_protocol) and not include_weather_daily:
+        weather_channels = weather_aggregate_patch_channels(paths["weather_aggregate_patch"], years, weather_days)
+        weather = read_patch_table(paths["weather_aggregate_patch"], years, columns=patch_key_cols + weather_channels)
+        weather["fire_id"] = weather["fire_id"].astype(str)
+        weather = weather.loc[weather["fire_id"].isin(fire_ids), ["fire_id", "row", "col", "cell_id"] + weather_channels]
+        base = base.merge(weather, on=["fire_id", "row", "col", "cell_id"], how="left")
+        channel_names.extend(weather_channels)
+
+    if sources["osm"]:
+        osm = read_patch_table(paths["osm_patch"], years, columns=patch_key_cols + sources["osm"])
+        osm["fire_id"] = osm["fire_id"].astype(str)
+        present = [c for c in sources["osm"] if c in osm.columns]
+        osm = osm.loc[osm["fire_id"].isin(fire_ids), ["fire_id", "row", "col", "cell_id"] + present]
+        base = base.merge(osm, on=["fire_id", "row", "col", "cell_id"], how="left")
+        channel_names.extend(present)
+
+    return base, list(dict.fromkeys(channel_names))
+
+
+def patch_to_array(patch: pd.DataFrame, sample_df: pd.DataFrame, channels: list[str]) -> np.ndarray:
+    n = len(sample_df)
+    c = len(channels)
+    if c == 0:
+        return np.zeros((n, 0, PATCH_SIZE, PATCH_SIZE), dtype=np.float32)
+    order = pd.DataFrame({"fire_id": sample_df["fire_id"].astype(str), "fire_order": np.arange(n)})
+    patch = patch.copy()
+    patch["fire_id"] = patch["fire_id"].astype(str)
+    patch = patch.merge(order, on="fire_id", how="inner")
+    patch = patch.sort_values(["fire_order", "row", "col"])
+    expected = n * CELLS_PER_PATCH
+    if len(patch) != expected:
+        raise ValueError(f"Patch cannot reshape: got {len(patch)} rows, expected {expected}.")
+    values = patch[channels].apply(pd.to_numeric, errors="coerce").fillna(0.0).to_numpy(dtype=np.float32)
+    return values.reshape(n, PATCH_SIZE, PATCH_SIZE, c).transpose(0, 3, 1, 2)
+
+
+def standardizable_patch_indices(channels: list[str]) -> list[int]:
+    skip_exact = {
+        "fbfm40",
+        "fd",
+        "fvt",
+        "fvc",
+        "fvh",
+        "evt",
+        "evc",
+        "evh",
+        "viirs_cell_has_detection_D",
+        "cell_has_drivable_road",
+    }
+    return [idx for idx, ch in enumerate(channels) if ch not in skip_exact and not ch.endswith("_missing_mask")]
+
+
+def fit_patch_stats_train(X_train: np.ndarray, channels: list[str], spatiotemporal: bool = False) -> dict:
+    indices = standardizable_patch_indices(channels)
+    if not indices:
+        return {"indices": [], "mean": [], "std": []}
+    if spatiotemporal:
+        mean = X_train[:, :, indices, :, :].mean(axis=(0, 1, 3, 4))
+        std = X_train[:, :, indices, :, :].std(axis=(0, 1, 3, 4))
+    else:
+        mean = X_train[:, indices, :, :].mean(axis=(0, 2, 3))
+        std = X_train[:, indices, :, :].std(axis=(0, 2, 3))
+    std = np.where(std == 0, 1.0, std)
+    return {"indices": indices, "mean": mean.tolist(), "std": std.tolist()}
+
+
+def apply_patch_standardization(X: np.ndarray, stats: dict, spatiotemporal: bool = False) -> np.ndarray:
+    indices = stats["indices"]
+    if not indices:
+        return X
+    mean = np.array(stats["mean"], dtype=np.float32)
+    std = np.array(stats["std"], dtype=np.float32)
+    X = X.copy()
+    if spatiotemporal:
+        X[:, :, indices, :, :] = (X[:, :, indices, :, :] - mean.reshape(1, 1, -1, 1, 1)) / std.reshape(1, 1, -1, 1, 1)
+    else:
+        X[:, indices, :, :] = (X[:, indices, :, :] - mean.reshape(1, -1, 1, 1)) / std.reshape(1, -1, 1, 1)
+    return X
+
+
+def build_spatial_cache(args, paths: dict[str, Path]) -> Path:
+    out_dir = output_subdir(args.output_dir, args.task, "spatial", args.weather_days, args.input_protocol)
+    if (out_dir / "X_train.npy").exists() and not args.overwrite:
+        print(f"Reusing existing spatial cache: {out_dir}")
+        return out_dir
+    remove_output_dir(out_dir, args.overwrite)
+
+    master = normalize_master_metadata(read_parquet_robust(paths["master"]))
+    samples = apply_input_protocol_sample_filter(filter_task_samples(master, args.task), args.input_protocol)
+    splits = split_frames(samples)
+    sample_index_splits = split_frames(build_sample_index(samples, master, args.task))
+
+    split_arrays = {}
+    channel_names = None
+    for split, frame in splits.items():
+        patch, channels = read_joined_spatial_patch(paths, frame, args.input_protocol, args.weather_days)
+        if channel_names is None:
+            channel_names = channels
+        X = patch_to_array(patch, frame, channel_names)
+        split_arrays[split] = X
+
+    patch_stats = {"indices": [], "mean": [], "std": []}
+    if args.standardize and channel_names:
+        patch_stats = fit_patch_stats_train(split_arrays["train"], channel_names, spatiotemporal=False)
+        for split in split_arrays:
+            split_arrays[split] = apply_patch_standardization(split_arrays[split], patch_stats, spatiotemporal=False)
+
+    for split, frame in splits.items():
+        y = frame["target"].to_numpy(dtype=np.float32)
+        write_split_outputs(out_dir, split, split_arrays[split], y, sample_index_splits[split], args.task)
+    write_json(out_dir / "channel_names.json", {"channel_names": channel_names or []})
+    save_metadata(
+        out_dir,
+        {
+            "task": args.task,
+            "representation": "spatial",
+            "input_protocol": args.input_protocol,
+            "weather_days": args.weather_days,
+            "target_column": target_info(args.task)["target_column"],
+            "channel_names": channel_names or [],
+            "split_counts": {split: int(len(frame)) for split, frame in splits.items()},
+            "missing_value_policy": "patch NaN filled with 0; no mask channels in v1",
+            "scaler_policy": "channel-wise train mean/std for non-categorical non-binary patch channels" if args.standardize else "not_standardized",
+            "channel_stats": patch_stats,
+            "created_at": created_at(),
+        },
+    )
+    print(f"Wrote spatial cache: {out_dir}")
+    return out_dir
+
+
+def daily_weather_patch_channels(paths: dict[str, Path], years: list[int]) -> list[str]:
+    sample = read_patch_table(paths["weather_daily_patch"], years[:1], columns=None, relative_days=[0])
+    if sample.empty:
+        return []
+    key_cols = {"fire_id", "year", "split", "row", "col", "cell_id", "date", "relative_day"}
+    return [col for col in sample.columns if col not in key_cols and col in TEMPORAL_WEATHER_CHANNELS]
+
+
+def weather_daily_patch_to_array(
+    paths: dict[str, Path],
+    sample_df: pd.DataFrame,
+    rel_days: list[int],
+    channels: list[str],
+) -> np.ndarray:
+    n = len(sample_df)
+    t = len(rel_days)
+    c = len(channels)
+    if c == 0:
+        return np.zeros((n, t, 0, PATCH_SIZE, PATCH_SIZE), dtype=np.float32)
+    years = sorted(sample_df["year"].unique().tolist())
+    fire_ids = set(sample_df["fire_id"].astype(str))
+    order = pd.DataFrame({"fire_id": sample_df["fire_id"].astype(str), "fire_order": np.arange(n)})
+    rel_order = pd.DataFrame({"relative_day": rel_days, "time_order": np.arange(t)})
+    weather = read_patch_table(
+        paths["weather_daily_patch"],
+        years,
+        columns=["fire_id", "relative_day", "row", "col", "cell_id"] + channels,
+        relative_days=rel_days,
+    )
+    weather["fire_id"] = weather["fire_id"].astype(str)
+    weather = weather.loc[weather["fire_id"].isin(fire_ids), ["fire_id", "relative_day", "row", "col", "cell_id"] + channels]
+    weather = weather.merge(order, on="fire_id", how="inner").merge(rel_order, on="relative_day", how="inner")
+    weather = weather.sort_values(["fire_order", "time_order", "row", "col"])
+    expected = n * t * CELLS_PER_PATCH
+    if len(weather) != expected:
+        raise ValueError(f"Weather daily patch cannot reshape: got {len(weather)} rows, expected {expected}.")
+    values = weather[channels].apply(pd.to_numeric, errors="coerce").fillna(0.0).to_numpy(dtype=np.float32)
+    return values.reshape(n, t, PATCH_SIZE, PATCH_SIZE, c).transpose(0, 1, 4, 2, 3)
+
+
+def build_spatiotemporal_cache(args, paths: dict[str, Path]) -> Path:
+    out_dir = output_subdir(args.output_dir, args.task, "spatiotemporal", args.weather_days, args.input_protocol)
+    if (out_dir / "X_train.npy").exists() and not args.overwrite:
+        print(f"Reusing existing spatiotemporal cache: {out_dir}")
+        return out_dir
+    remove_output_dir(out_dir, args.overwrite)
+
+    master = normalize_master_metadata(read_parquet_robust(paths["master"]))
+    samples = apply_input_protocol_sample_filter(filter_task_samples(master, args.task), args.input_protocol)
+    splits = split_frames(samples)
+    sample_index_splits = split_frames(build_sample_index(samples, master, args.task))
+    rel_days = WEATHER_DAY_MAP[args.weather_days]
+
+    split_arrays = {}
+    channel_names = None
+    for split, frame in splits.items():
+        years = sorted(frame["year"].unique().tolist())
+        dynamic_channels = daily_weather_patch_channels(paths, years) if protocol_includes_weather(args.input_protocol) else []
+        X_weather = weather_daily_patch_to_array(paths, frame, rel_days, dynamic_channels)
+
+        static_patch, static_channels = read_joined_spatial_patch(
+            paths, frame, args.input_protocol, args.weather_days, include_weather_daily=True
+        )
+        X_static = patch_to_array(static_patch, frame, static_channels)
+        X_static_repeated = np.repeat(X_static[:, None, :, :, :], len(rel_days), axis=1)
+        X = np.concatenate([X_weather, X_static_repeated], axis=2)
+        split_arrays[split] = X
+        if channel_names is None:
+            channel_names = dynamic_channels + static_channels
+
+    patch_stats = {"indices": [], "mean": [], "std": []}
+    if args.standardize and channel_names:
+        patch_stats = fit_patch_stats_train(split_arrays["train"], channel_names, spatiotemporal=True)
+        for split in split_arrays:
+            split_arrays[split] = apply_patch_standardization(split_arrays[split], patch_stats, spatiotemporal=True)
+
+    for split, frame in splits.items():
+        y = frame["target"].to_numpy(dtype=np.float32)
+        write_split_outputs(out_dir, split, split_arrays[split], y, sample_index_splits[split], args.task)
+    write_json(out_dir / "channel_names.json", {"channel_names": channel_names or []})
+    write_json(out_dir / "relative_days.json", {"relative_days": rel_days})
+    save_metadata(
+        out_dir,
+        {
+            "task": args.task,
+            "representation": "spatiotemporal",
+            "input_protocol": args.input_protocol,
+            "weather_days": args.weather_days,
+            "relative_days": rel_days,
+            "target_column": target_info(args.task)["target_column"],
+            "channel_names": channel_names or [],
+            "split_counts": {split: int(len(frame)) for split, frame in splits.items()},
+            "fire_signal_policy": "VIIRS discovery-day D patch repeated across all T time steps when selected",
+            "missing_value_policy": "patch NaN filled with 0; no mask channels in v1",
+            "scaler_policy": "channel-wise train mean/std for non-categorical non-binary patch channels" if args.standardize else "not_standardized",
+            "channel_stats": patch_stats,
+            "created_at": created_at(),
+        },
+    )
+    print(f"Wrote spatiotemporal cache: {out_dir}")
+    return out_dir
+
+
+def build_representation(args, paths: dict[str, Path], feature_manifest: dict, representation: str) -> Path:
+    if representation == "tabular":
+        return build_tabular_cache(args, paths, feature_manifest)
+    if representation == "temporal":
+        return build_temporal_cache(args, paths, feature_manifest)
+    if representation == "spatial":
+        return build_spatial_cache(args, paths)
+    if representation == "spatiotemporal":
+        return build_spatiotemporal_cache(args, paths)
+    raise ValueError(representation)
+
+
+def pass_fail(name: str, ok: bool, detail: str = "") -> bool:
+    status = "PASS" if ok else "FAIL"
+    print(f"[{status}] {name}{': ' + detail if detail else ''}")
+    return ok
+
+
+def validate_patch_table_sample(name: str, path: Path, max_parts: int = 1, sample_fire_count: int = 3) -> bool:
+    required = ["fire_id", "row", "col", "cell_id"]
+    df = read_parquet_parts_sample(path, columns=required + ["relative_day"], max_parts=max_parts)
+    if df.empty:
+        return pass_fail(f"patch table sample reshape: {name}", False, "no parquet part files read")
+    missing = [col for col in required if col not in df.columns]
+    if missing:
+        return pass_fail(f"patch table sample reshape: {name}", False, f"missing keys={missing}")
+
+    if "relative_day" in df.columns:
+        first_rel = sorted(int(day) for day in df["relative_day"].dropna().unique())[0]
+        df = df.loc[df["relative_day"].astype(int) == first_rel].copy()
+
+    fire_ids = df["fire_id"].astype(str).drop_duplicates().head(sample_fire_count).tolist()
+    if not fire_ids:
+        return pass_fail(f"patch table sample reshape: {name}", False, "no fire_id values in sample")
+
+    details = []
+    ok = True
+    df = df.copy()
+    df["fire_id"] = df["fire_id"].astype(str)
+    duplicate_count = int(df.duplicated(subset=required).sum())
+    if duplicate_count:
+        ok = False
+        details.append(f"duplicate key rows={duplicate_count}")
+
+    for fire_id in fire_ids:
+        group = df.loc[df["fire_id"] == fire_id]
+        checks = {
+            "rows": len(group) == CELLS_PER_PATCH,
+            "row_range": int(group["row"].min()) == 0 and int(group["row"].max()) == PATCH_SIZE - 1,
+            "col_range": int(group["col"].min()) == 0 and int(group["col"].max()) == PATCH_SIZE - 1,
+            "cell_id_nunique": int(group["cell_id"].nunique()) == CELLS_PER_PATCH,
+        }
+        bad = [key for key, passed in checks.items() if not passed]
+        if bad:
+            ok = False
+            details.append(f"fire_id={fire_id} failed {bad}")
+
+    detail = f"sampled_fire_ids={fire_ids}" if ok else "; ".join(details)
+    return pass_fail(f"patch table sample reshape: {name}", ok, detail)
+
+
+def validate(args, paths: dict[str, Path]) -> bool:
+    print("Validation checks")
+    ok_all = True
+    for key in required_path_keys():
+        ok_all &= pass_fail(f"canonical input exists: {key}", paths[key].exists(), str(paths[key]))
+    if not paths["master"].exists():
+        return False
+
+    feature_manifest = load_json(paths["feature_manifest"]) if paths["feature_manifest"].exists() else {"forbidden_as_features": []}
+    master = normalize_master_metadata(read_parquet_robust(paths["master"]))
+    ok_all &= pass_fail("master_features has one row per fire_id", not master["fire_id"].duplicated().any())
+
+    samples = apply_input_protocol_sample_filter(filter_task_samples(master, args.task), args.input_protocol)
+    splits = split_frames(samples)
+    ok_all &= pass_fail("task filtering works", len(samples) > 0, f"{len(samples)} samples")
+    ok_all &= pass_fail(
+        "train/val/test split counts are nonzero",
+        all(len(frame) > 0 for frame in splits.values()),
+        str({split: len(frame) for split, frame in splits.items()}),
+    )
+
+    target_col = target_info(args.task)["target_column"]
+    feature_cols, removed = requested_feature_columns(
+        feature_manifest, args.input_protocol, args.weather_days, master.columns, target_col
+    )
+    forbidden = set(feature_manifest.get("forbidden_as_features", []))
+    ok_all &= pass_fail("no forbidden columns used as input features", not bool(set(feature_cols) & forbidden))
+    ok_all &= pass_fail("target column is not an input feature", target_col not in feature_cols)
+    future_cols = [col for col in feature_cols if any(token in col.lower() for token in ["d+1", "dplus", "early_48", "post"])]
+    ok_all &= pass_fail("no D+1/D+2/future fire columns are used", len(future_cols) == 0, str(future_cols))
+
+    if paths["weather_daily_event"].exists():
+        weather_days = set(
+            int(day)
+            for day in read_parquet_robust(paths["weather_daily_event"], columns=["relative_day"])["relative_day"].unique()
+        )
+        need = set(WEATHER_DAY_MAP[args.weather_days])
+        ok_all &= pass_fail(
+            "weather relative days exist",
+            need <= weather_days,
+            f"need={sorted(int(day) for day in need)} have={sorted(int(day) for day in weather_days)}",
+        )
+
+    patch_tables = {
+        "grid_index": paths["grid_index"],
+        "static_patch": paths["static_patch"],
+        "viirs_patch": paths["viirs_patch"],
+        "weather_daily_patch": paths["weather_daily_patch"],
+        "weather_aggregate_patch": paths["weather_aggregate_patch"],
+        "osm_patch": paths["osm_patch"],
+    }
+    for name, path in patch_tables.items():
+        if path.exists():
+            ok_all &= validate_patch_table_sample(name, path)
+
+    if args.representation != "all":
+        cache_dir = output_subdir(args.output_dir, args.task, args.representation, args.weather_days, args.input_protocol)
+        if (cache_dir / "X_train.npy").exists():
+            X = np.load(cache_dir / "X_train.npy", mmap_mode="r")
+            ok_all &= pass_fail("output arrays have expected shapes", X.shape[0] == len(splits["train"]), str(X.shape))
+            ok_all &= pass_fail("no NaN remains in saved X arrays", not np.isnan(np.asarray(X[: min(len(X), 10)])).any())
+        else:
+            ok_all &= pass_fail("output arrays have expected shapes", False, f"cache not found: {cache_dir}")
+    return ok_all
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Build Phase 2 model-ready wildfire benchmark caches.")
+    parser.add_argument("--base_dir", default=".")
+    parser.add_argument("--canonical_dir", default="./data/cache/raw_feature_tables")
+    parser.add_argument("--output_dir", default="./data/cache/model_ready")
+    parser.add_argument("--task", choices=["ia_failure", "containment_time"], default="ia_failure")
+    parser.add_argument(
+        "--representation",
+        choices=["tabular", "temporal", "spatial", "spatiotemporal", "all"],
+        default="all",
+    )
+    parser.add_argument("--weather_days", choices=[1, 2, 3, 4, 5], type=int, default=5)
+    parser.add_argument(
+        "--input_protocol",
+        choices=[
+            "metadata",
+            "firms",
+            "fire",
+            "fire_wide",
+            "weather",
+            "fuel",
+            "vegetation",
+            "topography",
+            "access",
+            "human",
+            "metadata_vegetation",
+            "metadata_fuel",
+            "metadata_topography",
+            "metadata_access",
+            "metadata_human",
+            "all_without_fire",
+            "all_without_weather",
+            "all_without_vegetation",
+            "all_without_fuel",
+            "all_without_topography",
+            "all_without_access",
+            "all_without_human",
+            "all",
+        ],
+        default="all",
+    )
+    parser.add_argument("--standardize", dest="standardize", action="store_true", default=True)
+    parser.add_argument("--no-standardize", dest="standardize", action="store_false")
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument("--validate-only", action="store_true")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    args.base_dir = ensure_project_path(Path(args.base_dir))
+    args.canonical_dir = ensure_project_path(Path(args.canonical_dir))
+    args.output_dir = ensure_project_path(Path(args.output_dir))
+    paths = canonical_paths(args.canonical_dir)
+
+    if args.validate_only:
+        ok = validate(args, paths)
+        raise SystemExit(0 if ok else 1)
+
+    missing = [key for key in required_path_keys() if not paths[key].exists()]
+    if missing:
+        details = "\n".join(f"  {key}: {paths[key]}" for key in missing)
+        raise FileNotFoundError(f"Missing required Phase 1 canonical inputs:\n{details}")
+
+    feature_manifest, _, _, _ = load_manifests(paths)
+    reps = ["tabular", "temporal", "spatial", "spatiotemporal"] if args.representation == "all" else [args.representation]
+    for representation in reps:
+        build_representation(args, paths, feature_manifest, representation)
+
+
+if __name__ == "__main__":
+    main()

code/summarize_task1_full_all_seeds.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pandas as pd
+
+
+BASE_DIR = Path(".")
+EXP_DIR = BASE_DIR / "experiments" / "ia_failure" / "full"
+RESULTS_DIR = BASE_DIR / "results"
+RAW_OUT = RESULTS_DIR / "ia_failure_full_all_seeds_raw.csv"
+AGG_OUT = RESULTS_DIR / "ia_failure_full_all_seeds_mean_std.csv"
+MD_OUT = RESULTS_DIR / "ia_failure_full_all_seeds_mean_std.md"
+
+
+METRIC_COLUMNS = [
+    "val_auprc",
+    "test_auprc",
+    "val_auroc",
+    "test_auroc",
+    "test_f1",
+    "test_precision",
+    "test_recall",
+    "test_iou",
+    "test_brier",
+    "test_ece",
+    "test_precision_at_1",
+    "test_recall_at_1",
+    "test_precision_at_5",
+    "test_recall_at_5",
+    "test_precision_at_10",
+    "test_recall_at_10",
+    "best_epoch",
+    "runtime_seconds",
+]
+
+
+def read_metrics(path: Path) -> dict:
+    with path.open("r", encoding="utf-8") as file:
+        payload = json.load(file)
+    row = {
+        "task": payload.get("task", "ia_failure"),
+        "experiment_type": payload.get("experiment_type", "full"),
+        "representation": payload.get("representation", path.parents[2].name if len(path.parents) > 2 else None),
+        "model_name": payload.get("model_name", path.parent.name.split("_seed")[0]),
+        "seed": payload.get("seed"),
+        "output_dir": payload.get("output_dir", str(path.parent)),
+    }
+    # Backfill from path: full/{representation}/weather5_all/{model}_seed{seed}/metrics.json
+    try:
+        row["representation"] = path.parents[2].name
+    except Exception:
+        pass
+    for col in METRIC_COLUMNS:
+        row[col] = payload.get(col)
+    return row
+
+
+def main() -> None:
+    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    metrics_paths = sorted(EXP_DIR.glob("*/*/*_seed*/metrics.json"))
+    rows = [read_metrics(path) for path in metrics_paths]
+    columns = [
+        "task",
+        "experiment_type",
+        "representation",
+        "model_name",
+        "seed",
+        *METRIC_COLUMNS,
+        "output_dir",
+    ]
+    raw = pd.DataFrame(rows, columns=columns)
+    raw.to_csv(RAW_OUT, index=False)
+
+    if raw.empty:
+        agg = pd.DataFrame(columns=["representation", "model_name", "num_seeds_completed"])
+    else:
+        numeric_metrics = [col for col in METRIC_COLUMNS if col in raw.columns]
+        grouped = raw.groupby(["representation", "model_name"], dropna=False)
+        count = grouped["seed"].nunique().rename("num_seeds_completed")
+        means = grouped[numeric_metrics].mean(numeric_only=True).add_suffix("_mean")
+        stds = grouped[numeric_metrics].std(numeric_only=True).add_suffix("_std")
+        agg = pd.concat([count, means, stds], axis=1).reset_index()
+        if "test_auprc_mean" in agg.columns:
+            agg = agg.sort_values("test_auprc_mean", ascending=False, na_position="last")
+    agg.to_csv(AGG_OUT, index=False)
+    MD_OUT.write_text(agg.to_markdown(index=False) + "\n", encoding="utf-8")
+
+    print(f"Read {len(raw)} metrics files from {EXP_DIR}")
+    print(f"Wrote {RAW_OUT}")
+    print(f"Wrote {AGG_OUT}")
+    print(f"Wrote {MD_OUT}")
+
+
+if __name__ == "__main__":
+    main()

code/summarize_task2_full_all_seeds.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pandas as pd
+
+
+BASE_DIR = Path(".")
+ROOT = BASE_DIR / "experiments" / "containment_time" / "full"
+RESULTS_DIR = BASE_DIR / "results"
+
+METRICS = [
+    "val_mae_hours",
+    "test_mae_hours",
+    "val_rmse_hours",
+    "test_rmse_hours",
+    "val_median_ae_hours",
+    "test_median_ae_hours",
+    "val_log_mae",
+    "test_log_mae",
+    "val_log_rmse",
+    "test_log_rmse",
+    "val_r2",
+    "test_r2",
+    "val_spearman",
+    "test_spearman",
+    "val_pearson",
+    "test_pearson",
+]
+
+
+def read_json(path: Path) -> dict:
+    with path.open("r") as f:
+        return json.load(f)
+
+
+def main() -> None:
+    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    rows = []
+    for metrics_path in sorted(ROOT.glob("*/*/*_seed*/metrics.json")):
+        m = read_json(metrics_path)
+        row = {
+            "task": m.get("task"),
+            "experiment_type": m.get("experiment_type"),
+            "representation": m.get("representation"),
+            "model_name": m.get("model_name"),
+            "seed": m.get("seed"),
+            "best_epoch": m.get("best_epoch"),
+            "runtime_seconds": m.get("runtime_seconds"),
+            "output_dir": str(metrics_path.parent),
+        }
+        for metric in METRICS:
+            row[metric] = m.get(metric)
+        rows.append(row)
+
+    raw = pd.DataFrame(rows)
+    raw_path = RESULTS_DIR / "containment_time_full_all_seeds_raw.csv"
+    raw.to_csv(raw_path, index=False)
+
+    if raw.empty:
+        summary = pd.DataFrame()
+    else:
+        grouped = raw.groupby(["representation", "model_name"], dropna=False)
+        parts = []
+        for (representation, model_name), g in grouped:
+            row = {
+                "representation": representation,
+                "model_name": model_name,
+                "num_seeds_completed": int(g["seed"].nunique()),
+            }
+            for metric in METRICS:
+                row[f"{metric}_mean"] = g[metric].mean()
+                row[f"{metric}_std"] = g[metric].std()
+            row["best_epoch_mean"] = g["best_epoch"].mean()
+            row["runtime_seconds_mean"] = g["runtime_seconds"].mean()
+            parts.append(row)
+        summary = pd.DataFrame(parts)
+        if "test_mae_hours_mean" in summary.columns:
+            summary = summary.sort_values("test_mae_hours_mean", ascending=True)
+
+    summary_path = RESULTS_DIR / "containment_time_full_all_seeds_mean_std.csv"
+    md_path = RESULTS_DIR / "containment_time_full_all_seeds_mean_std.md"
+    summary.to_csv(summary_path, index=False)
+    summary.to_markdown(md_path, index=False)
+
+    print(f"Read {len(raw)} metrics files from {ROOT}")
+    print(f"Wrote {raw_path}")
+    print(f"Wrote {summary_path}")
+    print(f"Wrote {md_path}")
+
+
+if __name__ == "__main__":
+    main()

croissant.json

@@ -0,0 +1,529 @@
+{
+  "@context": {
+    "@language": "en",
+    "@vocab": "https://schema.org/",
+    "cr": "http://mlcommons.org/croissant/",
+    "prov": "http://www.w3.org/ns/prov#",
+    "rai": "http://mlcommons.org/croissant/RAI/"
+  },
+  "@type": "Dataset",
+  "alternateName": "WildfireIA",
+  "creator": [
+    {
+      "@type": "Organization",
+      "name": "Anonymous Authors"
+    }
+  ],
+  "datePublished": "2026-05-07",
+  "description": "Event-level multimodal benchmark for predicting whether a Natural wildfire escapes initial attack from public discovery-time data.",
+  "distribution": [
+    {
+      "@id": "canonical_event_grid_375m_index_natural_2016_2020.parquet",
+      "@type": "cr:FileSet",
+      "contentSize": 573952054,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "event_grid_375m_index_natural_2016_2020.parquet"
+    },
+    {
+      "@id": "canonical_event_osm_patch_375m_natural_2016_2020.parquet",
+      "@type": "cr:FileSet",
+      "contentSize": 1202885293,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "event_osm_patch_375m_natural_2016_2020.parquet"
+    },
+    {
+      "@id": "canonical_event_patch_manifest_375m_natural.json",
+      "@type": "cr:FileObject",
+      "contentSize": 747,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/event_patch_manifest_375m_natural.json",
+      "encodingFormat": "application/json",
+      "name": "event_patch_manifest_375m_natural.json"
+    },
+    {
+      "@id": "canonical_event_static_patch_375m_natural_2016_2020.parquet",
+      "@type": "cr:FileSet",
+      "contentSize": 507810394,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "event_static_patch_375m_natural_2016_2020.parquet"
+    },
+    {
+      "@id": "canonical_event_viirs_patch_375m_D_natural_2016_2020.parquet",
+      "@type": "cr:FileSet",
+      "contentSize": 15698914,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "event_viirs_patch_375m_D_natural_2016_2020.parquet"
+    },
+    {
+      "@id": "canonical_event_weather_aggregate_patch_375m_natural_2016_2020.parquet",
+      "@type": "cr:FileSet",
+      "contentSize": 28359527,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "event_weather_aggregate_patch_375m_natural_2016_2020.parquet"
+    },
+    {
+      "@id": "canonical_event_weather_daily_patch_375m_natural_2016_2020.parquet",
+      "@type": "cr:FileSet",
+      "contentSize": 56466736,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "event_weather_daily_patch_375m_natural_2016_2020.parquet"
+    },
+    {
+      "@id": "canonical_feature_manifest_natural.json",
+      "@type": "cr:FileObject",
+      "contentSize": 5736,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/feature_manifest_natural.json",
+      "encodingFormat": "application/json",
+      "name": "feature_manifest_natural.json"
+    },
+    {
+      "@id": "canonical_fire_events_natural_2016_2020.parquet",
+      "@type": "cr:FileObject",
+      "contentSize": 2088352,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/fire_events_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "fire_events_natural_2016_2020.parquet"
+    },
+    {
+      "@id": "canonical_gridmet_daily_event_features_natural_2016_2020.parquet",
+      "@type": "cr:FileObject",
+      "contentSize": 4188091,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/gridmet_daily_event_features_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "gridmet_daily_event_features_natural_2016_2020.parquet"
+    },
+    {
+      "@id": "canonical_gridmet_features_natural_2016_2020.parquet",
+      "@type": "cr:FileObject",
+      "contentSize": 7569654,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/gridmet_features_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "gridmet_features_natural_2016_2020.parquet"
+    },
+    {
+      "@id": "canonical_label_manifest_natural.json",
+      "@type": "cr:FileObject",
+      "contentSize": 1211,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/label_manifest_natural.json",
+      "encodingFormat": "application/json",
+      "name": "label_manifest_natural.json"
+    },
+    {
+      "@id": "canonical_landfire_fuel_veg_features_natural_2016_2020.parquet",
+      "@type": "cr:FileObject",
+      "contentSize": 2460578,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/landfire_fuel_veg_features_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "landfire_fuel_veg_features_natural_2016_2020.parquet"
+    },
+    {
+      "@id": "canonical_master_features_natural_2016_2020.parquet",
+      "@type": "cr:FileObject",
+      "contentSize": 15340791,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/master_features_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "master_features_natural_2016_2020.parquet"
+    },
+    {
+      "@id": "canonical_osm_access_features_natural_2016_2020.parquet",
+      "@type": "cr:FileObject",
+      "contentSize": 1261348,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/osm_access_features_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "osm_access_features_natural_2016_2020.parquet"
+    },
+    {
+      "@id": "canonical_population_features_natural_2016_2020.parquet",
+      "@type": "cr:FileObject",
+      "contentSize": 1597827,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/population_features_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "population_features_natural_2016_2020.parquet"
+    },
+    {
+      "@id": "canonical_temporal_protocol_manifest_natural.json",
+      "@type": "cr:FileObject",
+      "contentSize": 960,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/temporal_protocol_manifest_natural.json",
+      "encodingFormat": "application/json",
+      "name": "temporal_protocol_manifest_natural.json"
+    },
+    {
+      "@id": "canonical_topography_features_natural_2016_2020.parquet",
+      "@type": "cr:FileObject",
+      "contentSize": 1485867,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/topography_features_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "topography_features_natural_2016_2020.parquet"
+    },
+    {
+      "@id": "canonical_viirs_features_natural_2016_2020.parquet",
+      "@type": "cr:FileObject",
+      "contentSize": 489315,
+      "contentUrl": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA/resolve/main/data/canonical/raw_feature_tables/viirs_features_natural_2016_2020.parquet",
+      "encodingFormat": "application/x-parquet",
+      "name": "viirs_features_natural_2016_2020.parquet"
+    }
+  ],
+  "keywords": [
+    "wildfire",
+    "initial attack",
+    "benchmark",
+    "geospatial",
+    "multimodal"
+  ],
+  "license": "other",
+  "name": "WildfireIA Anonymous Benchmark Release",
+  "prov:wasDerivedFrom": [
+    "FPA-FOD",
+    "NASA FIRMS/VIIRS",
+    "gridMET",
+    "LANDFIRE",
+    "OpenStreetMap",
+    "WorldPop"
+  ],
+  "prov:wasGeneratedBy": "Canonicalization with pipeline.py followed by deterministic cache generation with dataloader.py using chronological splits and discovery-time input restrictions.",
+  "rai:dataBiases": "Potential biases include FPA-FOD reporting practices, VIIRS overpass and cloud/smoke limitations, gridMET gridding uncertainty, LANDFIRE static-layer mismatch, OSM mapping completeness, and WorldPop population-model uncertainty.",
+  "rai:dataLimitations": "The benchmark covers 2016--2020 contiguous United States Natural wildfire events that pass quality filters. It does not represent Alaska, Hawaii, non-natural fires, or non-US initial attack systems. The binary failure label is a final-size proxy.",
+  "rai:dataSocialImpact": "The benchmark may support transparent research on early wildfire risk ranking. Misuse as an unvalidated operational dispatch tool could reinforce geographic or reporting biases.",
+  "rai:dataUseCases": "Reproducible benchmark evaluation, representation comparison, source ablation, and scientific analysis of public discovery-time signals for wildfire initial attack.",
+  "rai:hasSyntheticData": false,
+  "rai:personalSensitiveInformation": "No direct personal identifiers are included. The data include public wildfire locations, dates, roads, fire-station locations, and population density, which are geospatially sensitive contextual information.",
+  "recordSet": [
+    {
+      "@type": "cr:RecordSet",
+      "dataType": "cr:Parquet",
+      "description": "FPA-FOD event-level tables, labels, splits, and source-level features.",
+      "name": "canonical_event_tables"
+    },
+    {
+      "@type": "cr:RecordSet",
+      "dataType": "cr:Parquet",
+      "description": "Event-centered 375 m patch canonical tables for spatial and spatiotemporal representations.",
+      "name": "canonical_patch_tables"
+    }
+  ],
+  "url": "https://huggingface.co/datasets/WildfireIA/Anonymous-WildfireIA",
+  "wildfireia:fileInventory": [
+    {
+      "bytes": 117740069,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2016/part-0.parquet"
+    },
+    {
+      "bytes": 129356687,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2017/part-0.parquet"
+    },
+    {
+      "bytes": 115464826,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2018/part-0.parquet"
+    },
+    {
+      "bytes": 112205544,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2019/part-0.parquet"
+    },
+    {
+      "bytes": 99184928,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2020/part-0.parquet"
+    },
+    {
+      "bytes": 247222585,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2016/part-0.parquet"
+    },
+    {
+      "bytes": 269190752,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2017/part-0.parquet"
+    },
+    {
+      "bytes": 242095433,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2018/part-0.parquet"
+    },
+    {
+      "bytes": 236244864,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2019/part-0.parquet"
+    },
+    {
+      "bytes": 208131659,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2020/part-0.parquet"
+    },
+    {
+      "bytes": 747,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_patch_manifest_375m_natural.json"
+    },
+    {
+      "bytes": 104714374,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2016/part-0.parquet"
+    },
+    {
+      "bytes": 112345739,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2017/part-0.parquet"
+    },
+    {
+      "bytes": 101964135,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2018/part-0.parquet"
+    },
+    {
+      "bytes": 100989221,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2019/part-0.parquet"
+    },
+    {
+      "bytes": 87796925,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2020/part-0.parquet"
+    },
+    {
+      "bytes": 3185696,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2016/part-0.parquet"
+    },
+    {
+      "bytes": 3519412,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2017/part-0.parquet"
+    },
+    {
+      "bytes": 3182548,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2018/part-0.parquet"
+    },
+    {
+      "bytes": 3065909,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2019/part-0.parquet"
+    },
+    {
+      "bytes": 2745349,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2020/part-0.parquet"
+    },
+    {
+      "bytes": 5825261,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2016/part-0.parquet"
+    },
+    {
+      "bytes": 6274227,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2017/part-0.parquet"
+    },
+    {
+      "bytes": 5728277,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2018/part-0.parquet"
+    },
+    {
+      "bytes": 5596110,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2019/part-0.parquet"
+    },
+    {
+      "bytes": 4935652,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2020/part-0.parquet"
+    },
+    {
+      "bytes": 2314177,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-1/part-0.parquet"
+    },
+    {
+      "bytes": 2315838,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-2/part-0.parquet"
+    },
+    {
+      "bytes": 2316300,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-3/part-0.parquet"
+    },
+    {
+      "bytes": 2316140,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-4/part-0.parquet"
+    },
+    {
+      "bytes": 2315203,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=0/part-0.parquet"
+    },
+    {
+      "bytes": 2521934,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-1/part-0.parquet"
+    },
+    {
+      "bytes": 2525345,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-2/part-0.parquet"
+    },
+    {
+      "bytes": 2523928,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-3/part-0.parquet"
+    },
+    {
+      "bytes": 2525109,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-4/part-0.parquet"
+    },
+    {
+      "bytes": 2521295,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=0/part-0.parquet"
+    },
+    {
+      "bytes": 2276868,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-1/part-0.parquet"
+    },
+    {
+      "bytes": 2281029,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-2/part-0.parquet"
+    },
+    {
+      "bytes": 2276931,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-3/part-0.parquet"
+    },
+    {
+      "bytes": 2278307,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-4/part-0.parquet"
+    },
+    {
+      "bytes": 2273496,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=0/part-0.parquet"
+    },
+    {
+      "bytes": 2213472,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-1/part-0.parquet"
+    },
+    {
+      "bytes": 2212169,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-2/part-0.parquet"
+    },
+    {
+      "bytes": 2212340,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-3/part-0.parquet"
+    },
+    {
+      "bytes": 2213338,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-4/part-0.parquet"
+    },
+    {
+      "bytes": 2214069,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=0/part-0.parquet"
+    },
+    {
+      "bytes": 1964914,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-1/part-0.parquet"
+    },
+    {
+      "bytes": 1963442,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-2/part-0.parquet"
+    },
+    {
+      "bytes": 1964110,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-3/part-0.parquet"
+    },
+    {
+      "bytes": 1963620,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-4/part-0.parquet"
+    },
+    {
+      "bytes": 1963362,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=0/part-0.parquet"
+    },
+    {
+      "bytes": 5736,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/feature_manifest_natural.json"
+    },
+    {
+      "bytes": 2088352,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/fire_events_natural_2016_2020.parquet"
+    },
+    {
+      "bytes": 4188091,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/gridmet_daily_event_features_natural_2016_2020.parquet"
+    },
+    {
+      "bytes": 7569654,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/gridmet_features_natural_2016_2020.parquet"
+    },
+    {
+      "bytes": 1211,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/label_manifest_natural.json"
+    },
+    {
+      "bytes": 2460578,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/landfire_fuel_veg_features_natural_2016_2020.parquet"
+    },
+    {
+      "bytes": 15340791,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/master_features_natural_2016_2020.parquet"
+    },
+    {
+      "bytes": 1261348,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/osm_access_features_natural_2016_2020.parquet"
+    },
+    {
+      "bytes": 1597827,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/population_features_natural_2016_2020.parquet"
+    },
+    {
+      "bytes": 960,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/temporal_protocol_manifest_natural.json"
+    },
+    {
+      "bytes": 1485867,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/topography_features_natural_2016_2020.parquet"
+    },
+    {
+      "bytes": 489315,
+      "hardlinked": false,
+      "path": "data/canonical/raw_feature_tables/viirs_features_natural_2016_2020.parquet"
+    }
+  ]
+}

data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2016/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cafcf142739f258a1e219d13c7ba4a532070bd24f3de1e4fe6a3dadeaad07e60
+size 117740069

data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2017/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a0ecb037c6a91d5aef2e579cd1ddf0a6e14d6ed121031c3d3c7134bbb4943e20
+size 129356687

data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2018/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c53695496c1ea1c77acded13503b692f88944e7e71fb131db0370c6c2b840dc
+size 115464826

data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2019/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d23d69fcc5d985804517f7bc79f991a1bae0f8c33c45eee1c90deba94eff4c2
+size 112205544

data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2020/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09bbb4c0704ffdda70eb37ff10b534831f926df404c9ee0be035da5ac2c03bb9
+size 99184928

data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2016/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c5815e4782283bc46897342e3837916e14402c41d90cabcfd9d94911f06f7d6b
+size 247222585

data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2017/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c0494108823b2742ede3da0065998a3c1c822606211f22dc21c518e110754ba
+size 269190752

data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2018/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21d95550f4ebafc74782fe98d49cc94cd5caf19f5a1621a6cb79ffea161b93df
+size 242095433

data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2019/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6215d3aaf6b87b9f4e5114fff6781fca4dc24e2b6ae587f870ef82ff2dd5298
+size 236244864

data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2020/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f12187926aa3556fcfa796d16a780bca1e60f3d0b6a1cf1cc35be065c59a5c4
+size 208131659

data/canonical/raw_feature_tables/event_patch_manifest_375m_natural.json

@@ -0,0 +1,23 @@
+{
+  "cell_size_m": 375,
+  "center_cell": [
+    14,
+    14
+  ],
+  "crs": "EPSG:5070",
+  "outputs": {
+    "grid_index": "event_grid_375m_index_natural_2016_2020.parquet",
+    "osm_patch": "event_osm_patch_375m_natural_2016_2020.parquet",
+    "static_patch": "event_static_patch_375m_natural_2016_2020.parquet",
+    "viirs_patch_D": "event_viirs_patch_375m_D_natural_2016_2020.parquet",
+    "weather_aggregate_patch": "event_weather_aggregate_patch_375m_natural_2016_2020.parquet",
+    "weather_daily_patch": "event_weather_daily_patch_375m_natural_2016_2020.parquet"
+  },
+  "patch_radius_m": 5000,
+  "patch_size": [
+    29,
+    29
+  ],
+  "sample_unit": "FPA-FOD Natural wildfire event",
+  "spatial_unit": "fire_id x 375m event-centered grid cell"
+}

data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2016/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f43e32cf4f2d20bbd79c51db8e285df9b32108f28098700821f86b6b5c378303
+size 104714374

data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2017/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1d397a0ef0e77ffb19175fad3b9d16343a11e469d42cc4b062f9b53a2bc9d42
+size 112345739

data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2018/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:682c0ad7411b75c18ff1f2f0d4bbad35931cee4a4343c9c934fa145c0408769a
+size 101964135

data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2019/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d0dc064fe78f40f6af812bd27b9442ef3d20d2b5ac54c8d1ac465104b0bb9af2
+size 100989221

data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2020/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b2d717848887fb9af74de4343075444c4be1dc0f05001a393b03b7e425ae697
+size 87796925

data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2016/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99186a9bb88075d77c19d743bebb24ac759bfeef38bf3e95cee3972fc3aeb2b4
+size 3185696

data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2017/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:833591ec15b1a698537145d908f357884120662c0640fe684dc6b6aa74a8ddda
+size 3519412

data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2018/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:216f961a4e12abf7d70bfeae0f1c965d0dee6bcf06d0d455adaf8f1313b1162e
+size 3182548

data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2019/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:345d9d23d2f7812b00594051433a4a0d7b88b905a3e98b78a4a4adb3e5f8bbc6
+size 3065909

data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2020/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9466b9c6c17c95164efa3834e838e25b4eae276f8079bd81c5c47be05ad32448
+size 2745349

data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2016/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d28cc76b4d61f2e188601071203917a7a4a70cc0efe13cd5540666af4cca0a47
+size 5825261

data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2017/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b6fc5f12fe8969281aa574c212ef4cf20c427996eac50ffbda7284f8d2a1527f
+size 6274227

data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2018/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50657d11e27ae1d4d31025174a617e32ef393026f56ba3b922007bf38f6d90c7
+size 5728277

data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2019/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4ca05eee871c9e0086f0e85c045878013521305c01d9c22a2ff58b18edead29f
+size 5596110

data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2020/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d86e2ef3579c5d8e16efe0ad86cdd77754a2a3701ff5509615ca608faf54f278
+size 4935652

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-1/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe079d4acb4d93c6bf478f7aea00920a67f163889e4e458cd7ee08f69c1c9a83
+size 2314177

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-2/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:adf1de20b39b3e888ce580985b30f65711ee7e5a90cd831d29f1cc5a86251211
+size 2315838

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-3/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8da6ae39e0eeab0d54edb55399f0732f1086cba7022cf92b8efacc83991f1dd3
+size 2316300

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-4/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f381784b01db8683f3393a3abae1fdbde9fd5a61212f10ab1ddbb743f9ab9e9f
+size 2316140

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=0/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3dbec44ddb0120c9030d45ff3bdf54212241d39c2bfd4f1ef75a1fcc33798a59
+size 2315203

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-1/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be2e1c6138bdbb01b3007582a7fe80358f3f5a71bd1213c43ec722d9ad3c3f32
+size 2521934

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-2/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:46b769c42c0126a9c299e1cbdf766ad3c0b696fb911e606eb99d249ee00571e4
+size 2525345

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-3/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b190bba44468964be4fa91d31d2c732c8a41cf74eab1a531e21ddef8fa74387
+size 2523928

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-4/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a816da28164576b9272c260f0612bdcc07a0526e52f8dfbb771261b6f97ee6ec
+size 2525109

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=0/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac2aaff1b13c590c28ccfaf91d41534d15d3583929cb70af166a56d80d03782a
+size 2521295

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-1/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d631037294036e25033bcfcd73fadd08600e9c2245b785d33c768ccaf4afed27
+size 2276868

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-2/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7272ccc8fa00482ddbc1b2e2d6e4d1d230c8f6cc6fce51f64d9627fea61c774b
+size 2281029

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-3/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76143c9b3a0296b544ada667d6f6d38ef984c5d58bddadd4dc2d9ca94570cff2
+size 2276931

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-4/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4830159585cd146d9608f1bc235ad7680ce7e4d577f0603db957966c7a5dd0aa
+size 2278307

data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=0/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:148418e46b1ab4bc1399d41ea7a7826a55ae9a388ba4ee288e319522e754a812
+size 2273496