diff --git a/.gitattributes b/.gitattributes index bed0738c7eeb449bca98b5d2f33c89a1ee56349a..a9981deac325f7725902ec48f9bd83bd3ebef09c 100644 --- a/.gitattributes +++ b/.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 diff --git a/DATA_LICENSES.md b/DATA_LICENSES.md new file mode 100644 index 0000000000000000000000000000000000000000..cc4f7075ecf0ceeb95c00315a7cdf29e83c3254d --- /dev/null +++ b/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. diff --git a/README.md b/README.md new file mode 100644 index 0000000000000000000000000000000000000000..27663d6786b2e359c08b3ac97fdfc375da7b08d6 --- /dev/null +++ b/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 +git xet install +git clone +rsync -a --info=progress2 / / +cd +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. diff --git a/code/dataloader.py b/code/dataloader.py new file mode 100644 index 0000000000000000000000000000000000000000..9a88374152ddc88249b349f1b6473b71a660c76d --- /dev/null +++ b/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() diff --git a/code/summarize_task1_full_all_seeds.py b/code/summarize_task1_full_all_seeds.py new file mode 100644 index 0000000000000000000000000000000000000000..d2bc88d74e318c05cbafa1106dd6cc63053e9bc9 --- /dev/null +++ b/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() diff --git a/code/summarize_task2_full_all_seeds.py b/code/summarize_task2_full_all_seeds.py new file mode 100644 index 0000000000000000000000000000000000000000..61e021b39567b0f16e095d49f92953aeb5f147a3 --- /dev/null +++ b/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() diff --git a/code/train.py b/code/train.py new file mode 100644 index 0000000000000000000000000000000000000000..183c06912de26accafc523ec97d4e20134efc74e --- /dev/null +++ b/code/train.py @@ -0,0 +1,2541 @@ +from __future__ import annotations + +import argparse +import json +import math +import os +import pickle +import random +import shutil +import time +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import numpy as np +import pandas as pd +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt +from scipy.stats import pearsonr, spearmanr +from sklearn.linear_model import LogisticRegression, Ridge +from sklearn.metrics import ( + average_precision_score, + balanced_accuracy_score, + brier_score_loss, + f1_score, + log_loss, + mean_absolute_error, + mean_squared_error, + median_absolute_error, + precision_score, + r2_score, + recall_score, + roc_auc_score, +) + + +PROJECT_ROOT = Path(".") +MODEL_READY_ROOT = Path("data/cache/model_ready") +EXPERIMENT_ROOT = Path("experiments") + +MODEL_REGISTRY = { + "logistic_regression": {"families": ["tabular"], "implemented": True}, + "xgboost": {"families": ["tabular"], "implemented": True}, + "mlp": {"families": ["tabular"], "implemented": True}, + "gru": {"families": ["temporal", "sequence"], "implemented": True}, + "tcn": {"families": ["temporal", "sequence"], "implemented": True}, + "transformer": {"families": ["temporal", "sequence"], "implemented": True}, + "resnet18_unet": {"families": ["spatial"], "implemented": True}, + "resnet50_unet": {"families": ["spatial"], "implemented": True}, + "swin_unet": {"families": ["spatial"], "implemented": True}, + "segformer": {"families": ["spatial"], "implemented": True}, + "convlstm": {"families": ["spatiotemporal"], "implemented": True}, + "convgru": {"families": ["spatiotemporal"], "implemented": True}, + "predrnn_v2": {"families": ["spatiotemporal"], "implemented": True}, + "utae": {"families": ["spatiotemporal"], "implemented": True}, + "swinlstm": {"families": ["spatiotemporal"], "implemented": True}, + "resnet3d": {"families": ["spatiotemporal"], "implemented": True}, +} + + +def created_at() -> str: + return datetime.now(timezone.utc).isoformat() + + +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 json_ready(value): + if isinstance(value, Path): + return str(value) + if isinstance(value, np.generic): + return value.item() + if isinstance(value, np.ndarray): + return value.tolist() + if isinstance(value, dict): + return {str(k): json_ready(v) for k, v in value.items()} + if isinstance(value, (list, tuple)): + return [json_ready(v) for v in value] + return value + + +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(json_ready(payload), file, indent=2, sort_keys=True) + file.write("\n") + + +def set_seed(seed: int) -> None: + random.seed(seed) + np.random.seed(seed) + try: + import torch + + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.deterministic = False + torch.backends.cudnn.benchmark = True + except Exception: + pass + + +def sigmoid(x: np.ndarray) -> np.ndarray: + x = np.asarray(x, dtype=np.float64) + return 1.0 / (1.0 + np.exp(-np.clip(x, -80, 80))) + + +def safe_logit(p: np.ndarray) -> np.ndarray: + p = np.asarray(p, dtype=np.float64) + p = np.clip(p, 1e-7, 1.0 - 1e-7) + return np.log(p / (1.0 - p)) + + +def output_model_name(task: str, model_name: str) -> str: + if task == "containment_time" and model_name == "logistic_regression": + return "ridge_regression" + return model_name + + +def cache_representation_name(representation: str) -> str: + return "temporal" if representation == "sequence" else representation + + +def canonical_representation_name(representation: str) -> str: + return "temporal" if representation == "sequence" else representation + + +def cache_dir(base_dir: Path, task: str, representation: str, weather_days: int, input_protocol: str) -> Path: + rep = cache_representation_name(representation) + primary = base_dir / MODEL_READY_ROOT / task / rep / f"weather{weather_days}_{input_protocol}" + if primary.exists(): + return primary + if representation == "sequence": + fallback = base_dir / MODEL_READY_ROOT / task / "sequence" / f"weather{weather_days}_{input_protocol}" + if fallback.exists(): + return fallback + return primary + + +def run_dir( + base_dir: Path, + task: str, + experiment_type: str, + ablation_name: str | None, + run_tag: str | None, + representation: str, + weather_days: int, + input_protocol: str, + model_name: str, + seed: int, +) -> Path: + if experiment_type == "ablation" and ablation_name == "protocol_sweep" and run_tag: + return ( + base_dir + / EXPERIMENT_ROOT + / task + / "ablation" + / "protocol_sweep" + / run_tag + / representation + / f"weather{weather_days}_{input_protocol}" + / f"{model_name}_seed{seed}" + ) + if experiment_type == "ablation" and ablation_name: + return ( + base_dir + / EXPERIMENT_ROOT + / task + / "ablation" + / ablation_name + / representation + / f"weather{weather_days}_{input_protocol}" + / f"{model_name}_seed{seed}" + ) + return ( + base_dir + / EXPERIMENT_ROOT + / task + / experiment_type + / representation + / f"weather{weather_days}_{input_protocol}" + / f"{model_name}_seed{seed}" + ) + + +def prepare_run_dir(path: Path, overwrite: bool) -> None: + if path.exists(): + if not overwrite: + raise FileExistsError(f"Run directory already exists. Pass --overwrite to replace it: {path}") + shutil.rmtree(path) + path.mkdir(parents=True, exist_ok=True) + + +def load_json_if_exists(path: Path) -> dict: + if not path.exists(): + return {} + with path.open("r", encoding="utf-8") as file: + return json.load(file) + + +def is_temporal_representation(representation: str) -> bool: + return representation in {"temporal", "sequence"} + + +def load_split_array(cache: Path, split: str, representation: str) -> np.ndarray: + if is_temporal_representation(representation): + candidates = [cache / f"X_seq_{split}.npy", cache / f"X_{split}.npy"] + else: + candidates = [cache / f"X_{split}.npy"] + for path in candidates: + if path.exists(): + mmap_mode = "r" if canonical_representation_name(representation) in {"spatial", "spatiotemporal"} else None + return np.load(path, mmap_mode=mmap_mode) + raise FileNotFoundError(f"Missing X array for {split}. Tried: {candidates}") + + +def finite_check_array(x: np.ndarray, max_exact_values: int = 50_000_000) -> bool: + """Avoid a full multi-GB scan for patch caches during smoke runs.""" + if x.size <= max_exact_values: + return bool(np.isfinite(x).all()) + rng = np.random.default_rng(0) + sample_size = min(512, x.shape[0]) + rows = rng.choice(x.shape[0], size=sample_size, replace=False) + return bool(np.isfinite(x[rows]).all()) + + +def load_cache(cache: Path, task: str, representation: str) -> dict[str, Any]: + required_common = ["y", "fire_id", "sample_index"] + data: dict[str, Any] = {"cache_dir": str(cache)} + for split in ["train", "val", "test"]: + for kind in required_common: + suffix = "npy" if kind in {"y", "fire_id"} else "parquet" + file = cache / f"{kind}_{split}.{suffix}" + if not file.exists(): + raise FileNotFoundError(f"Missing required cache file: {file}") + if is_temporal_representation(representation): + x_seq_path = cache / f"X_seq_{split}.npy" + x_static_path = cache / f"X_static_{split}.npy" + if not x_seq_path.exists() or not x_static_path.exists(): + raise FileNotFoundError(f"Missing temporal cache arrays: {x_seq_path}, {x_static_path}") + X = { + "seq": np.load(x_seq_path), + "static": np.load(x_static_path), + } + else: + X = load_split_array(cache, split, representation) + y = np.load(cache / f"y_{split}.npy") + fire_id = np.load(cache / f"fire_id_{split}.npy", allow_pickle=True).astype(str) + index = pd.read_parquet(cache / f"sample_index_{split}.parquet") + data[split] = {"X": X, "y": y, "fire_id": fire_id, "index": index} + data["metadata"] = load_json_if_exists(cache / "metadata.json") + data["feature_names"] = load_json_if_exists(cache / "feature_names.json").get("feature_names", []) + data["channel_names"] = load_json_if_exists(cache / "channel_names.json").get("channel_names", []) + data["relative_days"] = load_json_if_exists(cache / "relative_days.json").get("relative_days", []) + data["temporal_feature_names"] = load_json_if_exists(cache / "temporal_feature_names.json").get("feature_names", []) + data["static_feature_names"] = load_json_if_exists(cache / "static_feature_names.json").get("feature_names", []) + validate_cache(data, task) + return data + + +def validate_cache(data: dict[str, Any], task: str) -> None: + target_col = "ia_failure_label" if task == "ia_failure" else "log_containment_hours" + print("Pre-training cache validation") + for split in ["train", "val", "test"]: + X = data[split]["X"] + y = data[split]["y"] + fire_id = data[split]["fire_id"] + index = data[split]["index"].copy() + if isinstance(X, dict): + x_len = len(X["seq"]) + if len(X["static"]) != x_len: + raise ValueError(f"{split}: X_seq and X_static lengths do not match.") + x_shape = f"X_seq={X['seq'].shape}, X_static={X['static'].shape}" + finite_ok = np.isfinite(X["seq"]).all() and np.isfinite(X["static"]).all() + else: + x_len = len(X) + x_shape = f"X={X.shape}" + finite_ok = finite_check_array(X) + if x_len != len(y) or x_len != len(fire_id) or x_len != len(index): + raise ValueError(f"{split}: X/y/fire_id/sample_index lengths do not match.") + for col in ["fire_id", "year", "split"]: + if col not in index.columns: + raise ValueError(f"{split}: sample_index missing required column {col}") + if target_col not in index.columns: + raise ValueError(f"{split}: sample_index missing target column {target_col}") + if not np.array_equal(index["fire_id"].astype(str).to_numpy(), fire_id): + raise ValueError(f"{split}: fire_id array order does not match sample_index.") + if task == "ia_failure": + values = set(np.unique(y).astype(int).tolist()) + if not values <= {0, 1}: + raise ValueError(f"{split}: ia_failure y has invalid values: {values}") + else: + if not np.isfinite(y).all(): + raise ValueError(f"{split}: containment_time y has non-finite values.") + if not finite_ok: + raise ValueError(f"{split}: X contains NaN or infinite values.") + if task == "ia_failure": + print(f" {split}: {x_shape}, N={len(y)}, positive_rate={float(np.mean(y)):.4f}") + else: + print( + f" {split}: {x_shape}, N={len(y)}, y_log_mean={float(np.mean(y)):.4f}, " + f"y_log_std={float(np.std(y)):.4f}" + ) + + +def device_info(device_arg: str, gpu_id: int | None) -> dict[str, Any]: + info = {"device": "cpu", "gpu_name": None, "gpu_memory_total": None, "torch_cuda_available": False} + try: + import torch + + cuda_available = torch.cuda.is_available() + info["torch_cuda_available"] = bool(cuda_available) + if device_arg == "cuda" and not cuda_available: + raise RuntimeError("CUDA requested but torch.cuda.is_available() is false.") + if device_arg == "auto": + device = "cuda" if cuda_available else "cpu" + else: + device = device_arg + if device == "cuda": + index = gpu_id if gpu_id is not None else 0 + info["device"] = f"cuda:{index}" + info["gpu_name"] = torch.cuda.get_device_name(index) + info["gpu_memory_total"] = int(torch.cuda.get_device_properties(index).total_memory) + else: + info["device"] = "cpu" + except ImportError: + if device_arg == "cuda": + raise + return info + + +def expected_calibration_error(y_true: np.ndarray, y_score: np.ndarray, n_bins: int = 15) -> float: + y_true = np.asarray(y_true).astype(float) + y_score = np.asarray(y_score).astype(float) + edges = np.linspace(0.0, 1.0, n_bins + 1) + ece = 0.0 + for i in range(n_bins): + lo, hi = edges[i], edges[i + 1] + mask = (y_score >= lo) & (y_score <= hi if i == n_bins - 1 else y_score < hi) + if not np.any(mask): + continue + confidence = float(np.mean(y_score[mask])) + accuracy = float(np.mean(y_true[mask])) + ece += float(np.mean(mask)) * abs(accuracy - confidence) + return ece + + +def precision_recall_at_k(y_true: np.ndarray, y_score: np.ndarray, percent: int) -> tuple[float, float]: + n = len(y_true) + k = max(1, int(math.ceil((percent / 100.0) * n))) + order = np.argsort(-y_score)[:k] + positives = float(np.sum(y_true == 1)) + top_pos = float(np.sum(y_true[order] == 1)) + precision = top_pos / k + recall = top_pos / positives if positives > 0 else float("nan") + return precision, recall + + +def safe_metric(fn, default: float = float("nan")) -> float: + try: + return float(fn()) + except Exception: + return default + + +def classification_metrics(y_true: np.ndarray, y_score: np.ndarray, threshold: float) -> dict[str, float]: + y_true = np.asarray(y_true).astype(int) + y_score = np.clip(np.asarray(y_score).astype(float), 1e-7, 1.0 - 1e-7) + y_pred = (y_score >= threshold).astype(int) + metrics = { + "auprc": safe_metric(lambda: average_precision_score(y_true, y_score)), + "auroc": safe_metric(lambda: roc_auc_score(y_true, y_score)), + "f1": safe_metric(lambda: f1_score(y_true, y_pred, zero_division=0)), + "precision": safe_metric(lambda: precision_score(y_true, y_pred, zero_division=0)), + "recall": safe_metric(lambda: recall_score(y_true, y_pred, zero_division=0)), + "balanced_accuracy": safe_metric(lambda: balanced_accuracy_score(y_true, y_pred)), + "brier": safe_metric(lambda: brier_score_loss(y_true, y_score)), + "bce": safe_metric(lambda: log_loss(y_true, y_score, labels=[0, 1])), + "ece": expected_calibration_error(y_true, y_score), + } + for percent in [1, 5, 10]: + precision, recall = precision_recall_at_k(y_true, y_score, percent) + metrics[f"precision_at_{percent}"] = precision + metrics[f"recall_at_{percent}"] = recall + return metrics + + +def score_logit_diagnostics(y_score: np.ndarray, prefix: str) -> dict[str, float]: + score = np.clip(np.asarray(y_score).astype(float), 1e-7, 1.0 - 1e-7) + logit = safe_logit(score) + return { + f"{prefix}_y_score_mean": float(np.mean(score)), + f"{prefix}_y_score_std": float(np.std(score)), + f"{prefix}_y_score_min": float(np.min(score)), + f"{prefix}_y_score_max": float(np.max(score)), + f"{prefix}_y_logit_mean": float(np.mean(logit)), + f"{prefix}_y_logit_std": float(np.std(logit)), + f"{prefix}_y_logit_min": float(np.min(logit)), + f"{prefix}_y_logit_max": float(np.max(logit)), + } + + +def train_epoch_metrics(y_true: np.ndarray, y_score: np.ndarray) -> dict[str, float]: + threshold, _ = best_f1_threshold(y_true, y_score) + metrics = classification_metrics(y_true, y_score, threshold) + return { + "train_auprc": metrics["auprc"], + "train_auroc": metrics["auroc"], + "train_f1": metrics["f1"], + } + + +def subset_indices(y: np.ndarray, limit: int | None, seed: int) -> np.ndarray: + n = len(y) + if limit is None or limit >= n: + return np.arange(n) + if limit <= 0: + raise ValueError("Sample limits must be positive when provided.") + rng = np.random.default_rng(seed) + y = np.asarray(y) + if set(np.unique(y).astype(int).tolist()) <= {0, 1} and len(np.unique(y)) == 2: + pos = np.where(y == 1)[0] + neg = np.where(y == 0)[0] + n_pos = max(1, int(round(limit * len(pos) / n))) + n_pos = min(n_pos, len(pos), limit) + n_neg = min(limit - n_pos, len(neg)) + chosen = np.concatenate([rng.choice(pos, size=n_pos, replace=False), rng.choice(neg, size=n_neg, replace=False)]) + if len(chosen) < limit: + remaining = np.setdiff1d(np.arange(n), chosen, assume_unique=False) + chosen = np.concatenate([chosen, rng.choice(remaining, size=limit - len(chosen), replace=False)]) + return np.sort(chosen) + return np.arange(limit) + + +def subset_split(split_data: dict[str, Any], indices: np.ndarray) -> dict[str, Any]: + X = split_data["X"] + if isinstance(X, dict): + X = {name: value[indices] for name, value in X.items()} + else: + X = X[indices] + return { + "X": X, + "y": split_data["y"][indices], + "fire_id": split_data["fire_id"][indices], + "index": split_data["index"].iloc[indices].reset_index(drop=True), + } + + +def apply_debug_sample_limits(data: dict[str, Any], args) -> dict[str, Any]: + limits = {"train": args.limit_train_samples, "val": args.limit_val_samples} + if limits["train"] is None and limits["val"] is None: + return data + new_data = data.copy() + for split, limit in limits.items(): + if limit is not None: + idx = subset_indices(data[split]["y"], int(limit), args.seed) + new_data[split] = subset_split(data[split], idx) + print(f"Debug subset: {split} limited to {len(idx)} samples.") + return new_data + + +def compute_channel_standardization_stats(X: np.ndarray, out_dir: Path, chunk_size: int = 256) -> tuple[np.ndarray, np.ndarray]: + shape = X.shape + if len(shape) == 4: + channels = shape[1] + reduce_axes = (0, 2, 3) + count_per_sample = shape[2] * shape[3] + elif len(shape) == 5: + channels = shape[2] + reduce_axes = (0, 1, 3, 4) + count_per_sample = shape[1] * shape[3] * shape[4] + else: + raise ValueError(f"Channel standardization expects spatial or spatiotemporal X, got shape {shape}") + total = np.zeros(channels, dtype=np.float64) + total_sq = np.zeros(channels, dtype=np.float64) + count = 0 + for start_idx in range(0, len(X), chunk_size): + arr = np.asarray(X[start_idx : start_idx + chunk_size], dtype=np.float32) + total += arr.sum(axis=reduce_axes, dtype=np.float64) + total_sq += np.square(arr, dtype=np.float32).sum(axis=reduce_axes, dtype=np.float64) + count += arr.shape[0] * count_per_sample + mean = total / max(1, count) + var = np.maximum(total_sq / max(1, count) - mean**2, 0.0) + std = np.sqrt(var) + std[std < 1e-6] = 1.0 + np.savez(out_dir / "channel_standardization_stats.npz", mean=mean.astype(np.float32), std=std.astype(np.float32)) + return mean.astype(np.float32), std.astype(np.float32) + + +def standardize_patch_batch(batch: np.ndarray, mean: np.ndarray | None, std: np.ndarray | None) -> np.ndarray: + arr = np.asarray(batch, dtype=np.float32) + if mean is None or std is None: + return arr + if arr.ndim == 4: + return (arr - mean[None, :, None, None]) / std[None, :, None, None] + if arr.ndim == 5: + return (arr - mean[None, None, :, None, None]) / std[None, None, :, None, None] + raise ValueError(f"Unexpected patch batch shape: {arr.shape}") + + +def best_f1_threshold(y_true: np.ndarray, y_score: np.ndarray) -> tuple[float, float]: + best_threshold = 0.5 + best_f1 = -1.0 + for threshold in np.arange(0.01, 1.0, 0.01): + pred = (y_score >= threshold).astype(int) + score = f1_score(y_true, pred, zero_division=0) + if score > best_f1: + best_f1 = float(score) + best_threshold = float(threshold) + return best_threshold, best_f1 + + +def regression_metrics(y_true_log: np.ndarray, y_pred_log: np.ndarray, containment_hours_true: np.ndarray | None = None) -> dict[str, float]: + y_true_log = np.asarray(y_true_log).astype(float) + y_pred_log = np.asarray(y_pred_log).astype(float) + if containment_hours_true is None: + containment_hours_true = np.expm1(y_true_log) + containment_hours_pred = np.maximum(0.0, np.expm1(y_pred_log)) + return { + "mae_hours": safe_metric(lambda: mean_absolute_error(containment_hours_true, containment_hours_pred)), + "rmse_hours": safe_metric(lambda: mean_squared_error(containment_hours_true, containment_hours_pred, squared=False)), + "median_ae_hours": safe_metric(lambda: median_absolute_error(containment_hours_true, containment_hours_pred)), + "log_mae": safe_metric(lambda: mean_absolute_error(y_true_log, y_pred_log)), + "log_rmse": safe_metric(lambda: mean_squared_error(y_true_log, y_pred_log, squared=False)), + "r2": safe_metric(lambda: r2_score(y_true_log, y_pred_log)), + "spearman": safe_metric(lambda: spearmanr(y_true_log, y_pred_log).correlation), + "pearson": safe_metric(lambda: pearsonr(y_true_log, y_pred_log)[0]), + } + + +def classification_predictions(index: pd.DataFrame, y_true: np.ndarray, y_score: np.ndarray, threshold: float, model_name: str, seed: int) -> pd.DataFrame: + score = np.clip(np.asarray(y_score).astype(float), 1e-7, 1.0 - 1e-7) + pred = (score >= threshold).astype(int) + return pd.DataFrame( + { + "fire_id": index["fire_id"].astype(str).to_numpy(), + "year": index["year"].to_numpy(), + "split": index["split"].to_numpy(), + "y_true": y_true.astype(int), + "y_score": score, + "y_logit": safe_logit(score), + "y_pred": pred, + "threshold": threshold, + "model_name": model_name, + "seed": seed, + } + ) + + +def regression_predictions(index: pd.DataFrame, y_true_log: np.ndarray, y_pred_log: np.ndarray, model_name: str, seed: int) -> pd.DataFrame: + true_hours = index["containment_hours"].to_numpy(dtype=float) if "containment_hours" in index.columns else np.expm1(y_true_log) + pred_hours = np.maximum(0.0, np.expm1(y_pred_log)) + return pd.DataFrame( + { + "fire_id": index["fire_id"].astype(str).to_numpy(), + "year": index["year"].to_numpy(), + "split": index["split"].to_numpy(), + "y_true_log": y_true_log, + "y_pred_log": y_pred_log, + "containment_hours_true": true_hours, + "containment_hours_pred": pred_hours, + "model_name": model_name, + "seed": seed, + } + ) + + +def base_metrics_payload(args, model_name: str, cache: Path, out_dir: Path, data: dict[str, Any], runtime_seconds: float, device: dict[str, Any]) -> dict[str, Any]: + payload = { + "task": args.task, + "representation": args.representation, + "model_name": model_name, + "weather_days": args.weather_days, + "input_protocol": args.input_protocol, + "seed": args.seed, + "train_size": int(len(data["train"]["y"])), + "val_size": int(len(data["val"]["y"])), + "test_size": int(len(data["test"]["y"])), + "created_at": created_at(), + "runtime_seconds": float(runtime_seconds), + "device": device.get("device"), + "gpu_name": device.get("gpu_name"), + "gpu_memory_total": device.get("gpu_memory_total"), + "input_cache_dir": str(cache), + "output_dir": str(out_dir), + "sampling_strategy": args.sampling_strategy, + "grad_accum_steps": int(args.grad_accum_steps), + "effective_batch_size": int((args.batch_size or default_batch_size(args.representation)) * args.grad_accum_steps), + "standardize_channels": bool(args.standardize_channels), + "limit_train_samples": args.limit_train_samples, + "limit_val_samples": args.limit_val_samples, + "disable_pos_weight": bool(args.disable_pos_weight), + "pos_weight_scale": float(args.pos_weight_scale), + "loss_type": args.loss_type, + "label_smoothing": float(args.label_smoothing), + "focal_gamma": float(args.focal_gamma), + "lr_scheduler_type": args.lr_scheduler_type, + "warmup_epochs": int(args.warmup_epochs), + "min_lr_ratio": float(args.min_lr_ratio), + } + if args.task == "ia_failure": + for split in ["train", "val", "test"]: + y = data[split]["y"].astype(int) + payload[f"{split}_positive"] = int(np.sum(y == 1)) + payload[f"{split}_positive_rate"] = float(np.mean(y)) + return payload + + +def ia_pos_weight_settings(args, y_train: np.ndarray) -> tuple[float, float | None, str]: + """Return raw/effective IA class weight settings without changing defaults.""" + y = np.asarray(y_train).astype(int) + num_pos = int(np.sum(y == 1)) + num_neg = int(np.sum(y == 0)) + raw_pos_weight = float(num_neg / max(1, num_pos)) + if args.disable_pos_weight: + return raw_pos_weight, None, "BCEWithLogitsLoss unweighted" + effective_pos_weight = float(raw_pos_weight * args.pos_weight_scale) + return raw_pos_weight, effective_pos_weight, "BCEWithLogitsLoss pos_weight" + + +def bce_with_optional_pos_weight(nn_module, args, y_train: np.ndarray, torch_device): + import torch + + class SmoothedBCEWithLogitsLoss(nn_module.Module): + def __init__(self, pos_weight=None, smoothing: float = 0.0): + super().__init__() + self.register_buffer("pos_weight", pos_weight if pos_weight is not None else None) + self.smoothing = float(smoothing) + + def forward(self, logits, targets): + targets = targets.float() + if self.smoothing > 0: + targets = targets * (1.0 - self.smoothing) + 0.5 * self.smoothing + return nn_module.functional.binary_cross_entropy_with_logits( + logits, + targets, + pos_weight=self.pos_weight, + ) + + class FocalWithLogitsLoss(nn_module.Module): + def __init__(self, pos_weight=None, smoothing: float = 0.0, gamma: float = 2.0): + super().__init__() + self.register_buffer("pos_weight", pos_weight if pos_weight is not None else None) + self.smoothing = float(smoothing) + self.gamma = float(gamma) + + def forward(self, logits, targets): + targets = targets.float() + if self.smoothing > 0: + targets = targets * (1.0 - self.smoothing) + 0.5 * self.smoothing + bce = nn_module.functional.binary_cross_entropy_with_logits( + logits, + targets, + pos_weight=self.pos_weight, + reduction="none", + ) + prob = torch.sigmoid(logits) + pt = prob * targets + (1.0 - prob) * (1.0 - targets) + focal = (1.0 - pt).clamp(min=1e-6).pow(self.gamma) * bce + return focal.mean() + + raw_pos_weight, effective_pos_weight, strategy = ia_pos_weight_settings(args, y_train) + pos_weight_tensor = None + if effective_pos_weight is None: + strategy = f"{args.loss_type} unweighted" + else: + pos_weight_tensor = torch.tensor(effective_pos_weight, dtype=torch.float32, device=torch_device) + strategy = f"{args.loss_type} pos_weight" + if args.loss_type == "bce": + criterion = SmoothedBCEWithLogitsLoss(pos_weight=pos_weight_tensor, smoothing=args.label_smoothing) + elif args.loss_type == "focal": + criterion = FocalWithLogitsLoss(pos_weight=pos_weight_tensor, smoothing=args.label_smoothing, gamma=args.focal_gamma) + else: + raise ValueError(f"Unsupported loss_type={args.loss_type}") + criterion_unweighted = nn_module.BCEWithLogitsLoss() + return criterion, criterion_unweighted, raw_pos_weight, effective_pos_weight, strategy + + +def build_neural_scheduler(optimizer, args, task: str): + scheduler_type = args.lr_scheduler_type + if args.use_lr_scheduler and scheduler_type == "none": + scheduler_type = "plateau" + if scheduler_type == "none": + return None, "none" + if scheduler_type == "plateau": + mode = "max" if task == "ia_failure" else "min" + return torch_scheduler_reduce_on_plateau(optimizer, mode=mode), "plateau" + if scheduler_type == "cosine": + import math + import torch + + total_epochs = max(1, int(args.max_epochs)) + warmup_epochs = max(0, int(args.warmup_epochs)) + min_lr_ratio = max(0.0, min(1.0, float(args.min_lr_ratio))) + + def lr_lambda(epoch_idx: int): + epoch_num = epoch_idx + 1 + if warmup_epochs > 0 and epoch_num <= warmup_epochs: + return max(min_lr_ratio, epoch_num / warmup_epochs) + decay_steps = max(1, total_epochs - warmup_epochs) + progress = min(1.0, max(0.0, (epoch_num - warmup_epochs) / decay_steps)) + cosine = 0.5 * (1.0 + math.cos(math.pi * progress)) + return min_lr_ratio + (1.0 - min_lr_ratio) * cosine + + return torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lr_lambda), "cosine" + raise ValueError(f"Unsupported lr_scheduler_type={args.lr_scheduler_type}") + + +def torch_scheduler_reduce_on_plateau(optimizer, mode: str): + import torch + + return torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode=mode, factor=0.5, patience=5) + + +def step_neural_scheduler(scheduler, scheduler_type: str, monitor: float | None = None) -> None: + if scheduler is None: + return + if scheduler_type == "plateau": + scheduler.step(monitor) + else: + scheduler.step() + + +def save_common_artifacts(out_dir: Path, cache: Path) -> None: + for name in ["feature_names.json", "channel_names.json", "relative_days.json", "temporal_feature_names.json", "static_feature_names.json"]: + src = cache / name + if src.exists(): + shutil.copy2(src, out_dir / name) + + +def _plot_lines( + history_df: pd.DataFrame, + output_path: Path, + title: str, + y_label: str, + columns: list[tuple[str, str]], + best_epoch: int | None = None, +) -> None: + present = [(col, label) for col, label in columns if col in history_df.columns] + if not present or history_df.empty: + return + epoch = history_df["epoch"] if "epoch" in history_df.columns else np.arange(1, len(history_df) + 1) + plt.figure(figsize=(8, 5)) + for col, label in present: + plt.plot(epoch, history_df[col], marker="o", linewidth=1.8, markersize=3, label=label) + if best_epoch is not None and best_epoch > 0: + plt.axvline(best_epoch, color="black", linestyle="--", linewidth=1.2, alpha=0.7, label=f"best epoch {best_epoch}") + plt.title(title) + plt.xlabel("epoch") + plt.ylabel(y_label) + plt.grid(True, alpha=0.25) + plt.legend() + plt.tight_layout() + plt.savefig(output_path, dpi=160) + plt.close() + + +def plot_training_curves(history_df: pd.DataFrame, output_dir: Path, task: str, best_epoch: int | None = None) -> None: + """Save training-curve PNGs when metric columns are available.""" + if history_df is None or history_df.empty: + return + output_dir = Path(output_dir) + weighted_loss = False + if task == "ia_failure": + if "pos_weight_effective" in history_df.columns: + weights = pd.to_numeric(history_df["pos_weight_effective"], errors="coerce").dropna() + weighted_loss = bool(len(weights) and np.any(np.abs(weights.to_numpy(dtype=float) - 1.0) > 1e-9)) + else: + weighted_loss = "val_bce_unweighted" in history_df.columns or "train_bce_unweighted" in history_df.columns + loss_columns = [ + ("train_loss", "train_loss (weighted objective)" if weighted_loss else "train_loss"), + ("val_loss", "val_loss (weighted objective)" if weighted_loss else "val_loss"), + ] + _plot_lines( + history_df, + output_dir / "loss_curve.png", + "Training and Validation Loss", + "loss", + loss_columns, + best_epoch=best_epoch, + ) + _plot_lines( + history_df, + output_dir / "bce_unweighted_curve.png", + "Unweighted BCE / NLL", + "BCE", + [("train_bce_unweighted", "train_BCE_unweighted"), ("val_bce_unweighted", "val_BCE_unweighted")], + best_epoch=best_epoch, + ) + if task == "ia_failure": + _plot_lines( + history_df, + output_dir / "val_auprc_curve.png", + "Validation AUPRC", + "AUPRC", + [("val_auprc", "val_AUPRC")], + best_epoch=best_epoch, + ) + _plot_lines( + history_df, + output_dir / "val_auroc_curve.png", + "Validation AUROC", + "AUROC", + [("val_auroc", "val_AUROC")], + best_epoch=best_epoch, + ) + _plot_lines( + history_df, + output_dir / "metric_curve.png", + "Validation Metrics", + "metric value", + [("val_auprc", "val_AUPRC"), ("val_auroc", "val_AUROC"), ("val_f1", "val_F1")], + best_epoch=best_epoch, + ) + elif task == "containment_time": + _plot_lines( + history_df, + output_dir / "val_mae_curve.png", + "Validation MAE", + "MAE hours", + [("val_mae_hours", "val_MAE_hours")], + best_epoch=best_epoch, + ) + _plot_lines( + history_df, + output_dir / "val_rmse_curve.png", + "Validation RMSE", + "RMSE hours", + [("val_rmse_hours", "val_RMSE_hours")], + best_epoch=best_epoch, + ) + _plot_lines( + history_df, + output_dir / "metric_curve.png", + "Validation Metrics", + "metric value", + [ + ("val_mae_hours", "val_MAE_hours"), + ("val_rmse_hours", "val_RMSE_hours"), + ("val_log_mae", "val_log_MAE"), + ("val_log_rmse", "val_log_RMSE"), + ], + best_epoch=best_epoch, + ) + + +def train_logistic_or_ridge(args, data: dict[str, Any], out_dir: Path, cache: Path, device: dict[str, Any]) -> None: + start = time.time() + effective_name = output_model_name(args.task, "logistic_regression") + X_train, y_train = data["train"]["X"], data["train"]["y"] + X_val, y_val = data["val"]["X"], data["val"]["y"] + X_test, y_test = data["test"]["X"], data["test"]["y"] + + if args.task == "ia_failure": + try: + model = LogisticRegression( + class_weight="balanced", + max_iter=5000, + solver="lbfgs", + C=1.0, + random_state=args.seed, + n_jobs=-1, + verbose=0, + ) + model.fit(X_train, y_train) + except Exception as exc: + print(f"Warning: LogisticRegression solver='lbfgs' failed ({exc}); retrying solver='saga'.") + model = LogisticRegression( + class_weight="balanced", + max_iter=5000, + solver="saga", + C=1.0, + random_state=args.seed, + n_jobs=-1, + ) + model.fit(X_train, y_train) + val_score = model.predict_proba(X_val)[:, 1] + test_score = model.predict_proba(X_test)[:, 1] + threshold, _ = best_f1_threshold(y_val, val_score) + val_metrics = classification_metrics(y_val, val_score, threshold) + test_metrics = classification_metrics(y_test, test_score, threshold) + history = pd.DataFrame([{f"val_{k}": v for k, v in val_metrics.items()} | {"threshold": threshold}]) + pred_val = classification_predictions(data["val"]["index"], y_val, val_score, threshold, effective_name, args.seed) + pred_test = classification_predictions(data["test"]["index"], y_test, test_score, threshold, effective_name, args.seed) + imbalance = { + "class_imbalance_strategy": 'LogisticRegression class_weight="balanced"', + "pos_weight_or_scale_pos_weight": float(np.sum(y_train == 0) / max(1, np.sum(y_train == 1))), + "best_threshold_from_val": threshold, + } + imbalance.update(score_logit_diagnostics(val_score, "val")) + imbalance.update(score_logit_diagnostics(test_score, "test")) + else: + model = Ridge(alpha=1.0, random_state=args.seed) + model.fit(X_train, y_train) + val_pred = model.predict(X_val) + test_pred = model.predict(X_test) + val_metrics = regression_metrics(y_val, val_pred, data["val"]["index"].get("containment_hours", pd.Series(np.expm1(y_val))).to_numpy(dtype=float)) + test_metrics = regression_metrics(y_test, test_pred, data["test"]["index"].get("containment_hours", pd.Series(np.expm1(y_test))).to_numpy(dtype=float)) + history = pd.DataFrame([{f"val_{k}": v for k, v in val_metrics.items()}]) + pred_val = regression_predictions(data["val"]["index"], y_val, val_pred, effective_name, args.seed) + pred_test = regression_predictions(data["test"]["index"], y_test, test_pred, effective_name, args.seed) + imbalance = {"class_imbalance_strategy": None, "pos_weight_or_scale_pos_weight": None} + + with (out_dir / "model.pkl").open("wb") as file: + pickle.dump(model, file) + history.to_csv(out_dir / "history.csv", index=False) + pred_val.to_parquet(out_dir / "predictions_val.parquet", index=False) + pred_test.to_parquet(out_dir / "predictions_test.parquet", index=False) + runtime = time.time() - start + metrics = base_metrics_payload(args, effective_name, cache, out_dir, data, runtime, device) + metrics.update(imbalance) + metrics.update({f"val_{k}": v for k, v in val_metrics.items()}) + metrics.update({f"test_{k}": v for k, v in test_metrics.items()}) + write_json(out_dir / "metrics.json", metrics) + + +def xgb_predict_scores(model: Any, X: np.ndarray, task: str) -> np.ndarray: + if task == "ia_failure": + return model.predict_proba(X)[:, 1] + return model.predict(X) + + +def build_xgboost_model(args, device: dict[str, Any], use_cuda: bool, scale_pos_weight: float | None): + from xgboost import XGBClassifier, XGBRegressor + + common = { + "n_estimators": 1000, + "learning_rate": 0.03, + "max_depth": 4, + "subsample": 0.8, + "colsample_bytree": 0.8, + "tree_method": "hist", + "device": "cuda" if use_cuda else "cpu", + "random_state": args.seed, + "n_jobs": -1, + } + if args.task == "ia_failure": + kwargs = {**common, "eval_metric": "aucpr"} + if scale_pos_weight is not None: + kwargs["scale_pos_weight"] = scale_pos_weight + return XGBClassifier(**kwargs) + return XGBRegressor( + **common, + objective="reg:squarederror", + eval_metric="rmse", + ) + + +def fit_xgboost_with_fallback(model, X_train, y_train, X_val, y_val): + try: + model.fit(X_train, y_train, eval_set=[(X_val, y_val)], verbose=False, early_stopping_rounds=50) + return model, "early_stopping_rounds=50" + except TypeError as exc: + print(f"Warning: XGBoost early stopping API not supported ({exc}); retrying without early stopping.") + model.fit(X_train, y_train, eval_set=[(X_val, y_val)], verbose=False) + return model, "no_early_stopping_api" + + +def train_xgboost(args, data: dict[str, Any], out_dir: Path, cache: Path, device: dict[str, Any]) -> None: + start = time.time() + try: + import xgboost # noqa: F401 + except ImportError as exc: + raise ImportError("xgboost is required for --model xgboost.") from exc + + X_train, y_train = data["train"]["X"], data["train"]["y"] + X_val, y_val = data["val"]["X"], data["val"]["y"] + X_test, y_test = data["test"]["X"], data["test"]["y"] + scale_pos_weight = None + raw_scale_pos_weight = None + imbalance_strategy = None + if args.task == "ia_failure": + raw_scale_pos_weight, scale_pos_weight, imbalance_strategy = ia_pos_weight_settings(args, y_train) + use_cuda = str(device.get("device", "cpu")).startswith("cuda") + model = build_xgboost_model(args, device, use_cuda=use_cuda, scale_pos_weight=scale_pos_weight) + fit_note = "" + try: + model, fit_note = fit_xgboost_with_fallback(model, X_train, y_train, X_val, y_val) + except Exception as exc: + if use_cuda: + print(f"Warning: XGBoost CUDA fit failed ({exc}); retrying on CPU.") + model = build_xgboost_model(args, device, use_cuda=False, scale_pos_weight=scale_pos_weight) + model, fit_note = fit_xgboost_with_fallback(model, X_train, y_train, X_val, y_val) + else: + raise + + if args.task == "ia_failure": + val_score = xgb_predict_scores(model, X_val, args.task) + test_score = xgb_predict_scores(model, X_test, args.task) + threshold, _ = best_f1_threshold(y_val, val_score) + val_metrics = classification_metrics(y_val, val_score, threshold) + test_metrics = classification_metrics(y_test, test_score, threshold) + pred_val = classification_predictions(data["val"]["index"], y_val, val_score, threshold, "xgboost", args.seed) + pred_test = classification_predictions(data["test"]["index"], y_test, test_score, threshold, "xgboost", args.seed) + extra = { + "class_imbalance_strategy": "XGBClassifier scale_pos_weight" if scale_pos_weight is not None else "XGBClassifier unweighted", + "raw_pos_weight_or_scale_pos_weight": raw_scale_pos_weight, + "pos_weight_or_scale_pos_weight": scale_pos_weight, + "disable_pos_weight": bool(args.disable_pos_weight), + "pos_weight_scale": float(args.pos_weight_scale), + "best_threshold_from_val": threshold, + } + extra.update(score_logit_diagnostics(val_score, "val")) + extra.update(score_logit_diagnostics(test_score, "test")) + else: + val_pred = xgb_predict_scores(model, X_val, args.task) + test_pred = xgb_predict_scores(model, X_test, args.task) + val_metrics = regression_metrics(y_val, val_pred, data["val"]["index"].get("containment_hours", pd.Series(np.expm1(y_val))).to_numpy(dtype=float)) + test_metrics = regression_metrics(y_test, test_pred, data["test"]["index"].get("containment_hours", pd.Series(np.expm1(y_test))).to_numpy(dtype=float)) + pred_val = regression_predictions(data["val"]["index"], y_val, val_pred, "xgboost", args.seed) + pred_test = regression_predictions(data["test"]["index"], y_test, test_pred, "xgboost", args.seed) + extra = {"class_imbalance_strategy": None, "pos_weight_or_scale_pos_weight": None} + + history = pd.DataFrame([{f"val_{k}": v for k, v in val_metrics.items()} | {"fit_note": fit_note}]) + with (out_dir / "model.pkl").open("wb") as file: + pickle.dump(model, file) + history.to_csv(out_dir / "history.csv", index=False) + pred_val.to_parquet(out_dir / "predictions_val.parquet", index=False) + pred_test.to_parquet(out_dir / "predictions_test.parquet", index=False) + runtime = time.time() - start + metrics = base_metrics_payload(args, "xgboost", cache, out_dir, data, runtime, device) + metrics.update(extra) + metrics.update({f"val_{k}": v for k, v in val_metrics.items()}) + metrics.update({f"test_{k}": v for k, v in test_metrics.items()}) + metrics["xgboost_fit_note"] = fit_note + write_json(out_dir / "metrics.json", metrics) + + +def train_mlp(args, data: dict[str, Any], out_dir: Path, cache: Path, device: dict[str, Any]) -> None: + try: + import torch + import torch.nn as nn + from torch.utils.data import DataLoader, TensorDataset, WeightedRandomSampler + except ImportError as exc: + raise ImportError("PyTorch is required for --model mlp.") from exc + + start = time.time() + torch_device = torch.device(device["device"] if str(device.get("device", "cpu")).startswith("cuda") else "cpu") + X_train = torch.tensor(data["train"]["X"], dtype=torch.float32) + y_train = torch.tensor(data["train"]["y"], dtype=torch.float32) + X_val = torch.tensor(data["val"]["X"], dtype=torch.float32) + y_val_np = data["val"]["y"].astype(np.float32) + X_test = torch.tensor(data["test"]["X"], dtype=torch.float32) + y_test_np = data["test"]["y"].astype(np.float32) + + class TabularMLP(nn.Module): + def __init__(self, input_dim: int): + super().__init__() + self.net = nn.Sequential( + nn.Linear(input_dim, 512), + nn.BatchNorm1d(512), + nn.ReLU(), + nn.Dropout(args.dropout), + nn.Linear(512, 256), + nn.BatchNorm1d(256), + nn.ReLU(), + nn.Dropout(args.dropout), + nn.Linear(256, 64), + nn.ReLU(), + nn.Linear(64, 1), + ) + + def forward(self, x): + return self.net(x).squeeze(-1) + + model = TabularMLP(X_train.shape[1]).to(torch_device) + optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) + if args.task == "ia_failure": + criterion, criterion_unweighted, raw_pos_weight, pos_weight, imbalance_strategy = bce_with_optional_pos_weight( + nn, args, data["train"]["y"], torch_device + ) + maximize = True + best_metric_name = "val_auprc" + else: + raw_pos_weight = None + pos_weight = None + imbalance_strategy = None + criterion = nn.HuberLoss() + criterion_unweighted = None + maximize = False + best_metric_name = "val_mae_hours" + scheduler, scheduler_type = build_neural_scheduler(optimizer, args, args.task) + + batch_size = args.batch_size or 512 + sampler = None + shuffle = True + if args.task == "ia_failure" and args.sampling_strategy == "weighted": + y_np = data["train"]["y"].astype(int) + class_counts = np.bincount(y_np, minlength=2).astype(float) + weights = 1.0 / np.maximum(class_counts[y_np], 1.0) + sampler = WeightedRandomSampler(torch.tensor(weights, dtype=torch.double), num_samples=len(weights), replacement=True) + shuffle = False + loader = DataLoader(TensorDataset(X_train, y_train), batch_size=batch_size, shuffle=shuffle, sampler=sampler, num_workers=0) + history = [] + best_value = -float("inf") if maximize else float("inf") + best_epoch = -1 + patience = 0 + + def predict_numpy(X_tensor: Any) -> np.ndarray: + model.eval() + outputs = [] + with torch.no_grad(): + for start_idx in range(0, len(X_tensor), batch_size * 4): + batch = X_tensor[start_idx : start_idx + batch_size * 4].to(torch_device) + outputs.append(model(batch).detach().cpu().numpy()) + return np.concatenate(outputs) + + for epoch in range(1, args.max_epochs + 1): + model.train() + total_loss = 0.0 + total_unweighted_bce = 0.0 + total_n = 0 + train_logits_epoch = [] + train_y_epoch = [] + optimizer.zero_grad(set_to_none=True) + num_batches = len(loader) + for batch_idx, (xb, yb) in enumerate(loader, start=1): + xb = xb.to(torch_device) + yb = yb.to(torch_device) + pred = model(xb) + loss = criterion(pred, yb) + if criterion_unweighted is not None: + unweighted_loss = criterion_unweighted(pred, yb) + total_unweighted_bce += float(unweighted_loss.detach().cpu()) * len(xb) + train_logits_epoch.append(pred.detach().cpu().numpy()) + train_y_epoch.append(yb.detach().cpu().numpy()) + (loss / max(1, args.grad_accum_steps)).backward() + if batch_idx % args.grad_accum_steps == 0 or batch_idx == num_batches: + if args.gradient_clip and args.gradient_clip > 0: + torch.nn.utils.clip_grad_norm_(model.parameters(), args.gradient_clip) + optimizer.step() + optimizer.zero_grad(set_to_none=True) + total_loss += float(loss.detach().cpu()) * len(xb) + total_n += len(xb) + train_loss = total_loss / max(1, total_n) + train_bce_unweighted = total_unweighted_bce / max(1, total_n) if criterion_unweighted is not None else None + val_raw = predict_numpy(X_val) + with torch.no_grad(): + val_loss = float(criterion(torch.tensor(val_raw, dtype=torch.float32, device=torch_device), torch.tensor(y_val_np, dtype=torch.float32, device=torch_device)).detach().cpu()) + val_bce_unweighted = None + if criterion_unweighted is not None: + val_bce_unweighted = float( + criterion_unweighted( + torch.tensor(val_raw, dtype=torch.float32, device=torch_device), + torch.tensor(y_val_np, dtype=torch.float32, device=torch_device), + ).detach().cpu() + ) + + if args.task == "ia_failure": + val_score = sigmoid(val_raw) + threshold, _ = best_f1_threshold(y_val_np, val_score) + metrics = classification_metrics(y_val_np, val_score, threshold) + train_score = sigmoid(np.concatenate(train_logits_epoch)) if train_logits_epoch else np.array([]) + train_y_diag = np.concatenate(train_y_epoch) if train_y_epoch else np.array([]) + train_metrics = train_epoch_metrics(train_y_diag, train_score) if len(train_score) else {} + monitor = metrics["auprc"] + row = { + "epoch": epoch, + "train_loss": train_loss, + "val_loss": val_loss, + "val_auprc": metrics["auprc"], + "val_auroc": metrics["auroc"], + "val_f1": metrics["f1"], + "val_precision": metrics["precision"], + "val_recall": metrics["recall"], + "val_balanced_accuracy": metrics["balanced_accuracy"], + "val_brier": metrics["brier"], + "val_bce": metrics["bce"], + "val_ece": metrics["ece"], + "lr": optimizer.param_groups[0]["lr"], + "train_bce_unweighted": train_bce_unweighted, + "val_bce_unweighted": val_bce_unweighted, + "pos_weight_raw": raw_pos_weight, + "pos_weight_effective": pos_weight, + } + row.update(train_metrics) + else: + hours_true = data["val"]["index"].get("containment_hours", pd.Series(np.expm1(y_val_np))).to_numpy(dtype=float) + metrics = regression_metrics(y_val_np, val_raw, hours_true) + monitor = metrics["mae_hours"] + row = { + "epoch": epoch, + "train_loss": train_loss, + "val_loss": val_loss, + "val_mae_hours": metrics["mae_hours"], + "val_rmse_hours": metrics["rmse_hours"], + "val_median_ae_hours": metrics["median_ae_hours"], + "val_log_mae": metrics["log_mae"], + "val_log_rmse": metrics["log_rmse"], + "val_r2": metrics["r2"], + "val_spearman": metrics["spearman"], + "val_pearson": metrics["pearson"], + "lr": optimizer.param_groups[0]["lr"], + } + if scheduler is not None: + step_neural_scheduler(scheduler, scheduler_type, monitor) + row["lr"] = optimizer.param_groups[0]["lr"] + history.append(row) + improved = monitor > best_value if maximize else monitor < best_value + if improved: + best_value = monitor + best_epoch = epoch + patience = 0 + torch.save({"epoch": epoch, "model_state_dict": model.state_dict(), "metric": best_value}, out_dir / "best_checkpoint.pt") + else: + patience += 1 + torch.save({"epoch": epoch, "model_state_dict": model.state_dict(), "metric": monitor}, out_dir / "last_checkpoint.pt") + if patience >= args.early_stop_patience: + print(f"Early stopping at epoch {epoch}; best_epoch={best_epoch}, {best_metric_name}={best_value:.6f}") + break + + checkpoint = torch.load(out_dir / "best_checkpoint.pt", map_location=torch_device) + model.load_state_dict(checkpoint["model_state_dict"]) + val_raw = predict_numpy(X_val) + test_raw = predict_numpy(X_test) + + if args.task == "ia_failure": + val_score = sigmoid(val_raw) + test_score = sigmoid(test_raw) + threshold, _ = best_f1_threshold(y_val_np, val_score) + val_metrics = classification_metrics(y_val_np, val_score, threshold) + test_metrics = classification_metrics(y_test_np, test_score, threshold) + pred_val = classification_predictions(data["val"]["index"], y_val_np, val_score, threshold, "mlp", args.seed) + pred_test = classification_predictions(data["test"]["index"], y_test_np, test_score, threshold, "mlp", args.seed) + if args.save_train_predictions: + train_raw = predict_numpy(X_train) + train_score = sigmoid(train_raw) + classification_predictions(data["train"]["index"], data["train"]["y"].astype(np.float32), train_score, threshold, "mlp", args.seed).to_parquet( + out_dir / "predictions_train.parquet", index=False + ) + extra = { + "class_imbalance_strategy": imbalance_strategy, + "raw_pos_weight_or_scale_pos_weight": raw_pos_weight, + "pos_weight_or_scale_pos_weight": pos_weight, + "disable_pos_weight": bool(args.disable_pos_weight), + "pos_weight_scale": float(args.pos_weight_scale), + "loss_type": args.loss_type, + "label_smoothing": float(args.label_smoothing), + "focal_gamma": float(args.focal_gamma), + "lr_scheduler_type": scheduler_type, + "best_threshold_from_val": threshold, + } + extra.update(score_logit_diagnostics(val_score, "val")) + extra.update(score_logit_diagnostics(test_score, "test")) + else: + val_hours = data["val"]["index"].get("containment_hours", pd.Series(np.expm1(y_val_np))).to_numpy(dtype=float) + test_hours = data["test"]["index"].get("containment_hours", pd.Series(np.expm1(y_test_np))).to_numpy(dtype=float) + val_metrics = regression_metrics(y_val_np, val_raw, val_hours) + test_metrics = regression_metrics(y_test_np, test_raw, test_hours) + pred_val = regression_predictions(data["val"]["index"], y_val_np, val_raw, "mlp", args.seed) + pred_test = regression_predictions(data["test"]["index"], y_test_np, test_raw, "mlp", args.seed) + extra = {"class_imbalance_strategy": None, "pos_weight_or_scale_pos_weight": None} + + history_df = pd.DataFrame(history) + history_df.to_csv(out_dir / "history.csv", index=False) + plot_training_curves(history_df, out_dir, args.task, best_epoch=best_epoch) + pred_val.to_parquet(out_dir / "predictions_val.parquet", index=False) + pred_test.to_parquet(out_dir / "predictions_test.parquet", index=False) + runtime = time.time() - start + metrics_payload = base_metrics_payload(args, "mlp", cache, out_dir, data, runtime, device) + metrics_payload.update(extra) + metrics_payload.update({f"val_{k}": v for k, v in val_metrics.items()}) + metrics_payload.update({f"test_{k}": v for k, v in test_metrics.items()}) + metrics_payload["best_epoch"] = int(best_epoch) + write_json(out_dir / "metrics.json", metrics_payload) + + +def train_temporal_neural(args, data: dict[str, Any], out_dir: Path, cache: Path, device: dict[str, Any], model_name: str) -> None: + try: + import torch + import torch.nn as nn + from torch.utils.data import DataLoader, TensorDataset, WeightedRandomSampler + except ImportError as exc: + raise ImportError("PyTorch is required for temporal neural models.") from exc + + start = time.time() + torch_device = torch.device(device["device"] if str(device.get("device", "cpu")).startswith("cuda") else "cpu") + X_seq_train = torch.tensor(data["train"]["X"]["seq"], dtype=torch.float32) + X_static_train = torch.tensor(data["train"]["X"]["static"], dtype=torch.float32) + y_train = torch.tensor(data["train"]["y"], dtype=torch.float32) + X_seq_val = torch.tensor(data["val"]["X"]["seq"], dtype=torch.float32) + X_static_val = torch.tensor(data["val"]["X"]["static"], dtype=torch.float32) + y_val_np = data["val"]["y"].astype(np.float32) + X_seq_test = torch.tensor(data["test"]["X"]["seq"], dtype=torch.float32) + X_static_test = torch.tensor(data["test"]["X"]["static"], dtype=torch.float32) + y_test_np = data["test"]["y"].astype(np.float32) + + seq_dim = X_seq_train.shape[-1] + static_dim = X_static_train.shape[-1] + + class StaticEncoder(nn.Module): + def __init__(self, input_dim: int, hidden_dim: int, output_dim: int): + super().__init__() + self.output_dim = output_dim + self.net = nn.Sequential( + nn.Linear(input_dim, hidden_dim), + nn.BatchNorm1d(hidden_dim), + nn.ReLU(), + nn.Dropout(args.dropout), + nn.Linear(hidden_dim, output_dim), + nn.ReLU(), + ) + + def forward(self, x): + if x.shape[1] == 0: + return torch.zeros((x.shape[0], self.output_dim), dtype=x.dtype, device=x.device) + return self.net(x) + + class GRUClassifier(nn.Module): + def __init__(self, seq_dim: int, static_dim: int): + super().__init__() + hidden = 128 + self.gru = nn.GRU(seq_dim, hidden, num_layers=2, batch_first=True, dropout=0.1) + self.static_encoder = StaticEncoder(static_dim, args.static_hidden, args.static_out) + self.head = nn.Sequential( + nn.Linear(hidden + args.static_out, args.fusion_hidden), + nn.ReLU(), + nn.Dropout(args.dropout), + nn.Linear(args.fusion_hidden, 1), + ) + + def forward(self, x_seq, x_static): + _, h = self.gru(x_seq) + seq_emb = h[-1] + static_emb = self.static_encoder(x_static) + return self.head(torch.cat([seq_emb, static_emb], dim=1)).squeeze(-1) + + class TemporalBlock(nn.Module): + def __init__(self, in_channels: int, out_channels: int, dilation: int, dropout: float): + super().__init__() + padding = dilation + self.net = nn.Sequential( + nn.Conv1d(in_channels, out_channels, kernel_size=3, padding=padding, dilation=dilation), + nn.BatchNorm1d(out_channels), + nn.ReLU(), + nn.Dropout(dropout), + nn.Conv1d(out_channels, out_channels, kernel_size=3, padding=padding, dilation=dilation), + nn.BatchNorm1d(out_channels), + nn.ReLU(), + nn.Dropout(dropout), + ) + self.proj = nn.Conv1d(in_channels, out_channels, kernel_size=1) if in_channels != out_channels else nn.Identity() + + def forward(self, x): + out = self.net(x) + if out.shape[-1] != x.shape[-1]: + out = out[..., : x.shape[-1]] + return out + self.proj(x) + + class TCNClassifier(nn.Module): + def __init__(self, seq_dim: int, static_dim: int): + super().__init__() + hidden = 128 + self.tcn = nn.Sequential( + TemporalBlock(seq_dim, hidden, dilation=1, dropout=args.dropout), + TemporalBlock(hidden, hidden, dilation=2, dropout=args.dropout), + TemporalBlock(hidden, hidden, dilation=4, dropout=args.dropout), + ) + self.static_encoder = StaticEncoder(static_dim, args.static_hidden, args.static_out) + self.head = nn.Sequential( + nn.Linear(hidden + args.static_out, args.fusion_hidden), + nn.ReLU(), + nn.Dropout(args.dropout), + nn.Linear(args.fusion_hidden, 1), + ) + + def forward(self, x_seq, x_static): + seq_emb = self.tcn(x_seq.transpose(1, 2)).mean(dim=-1) + static_emb = self.static_encoder(x_static) + return self.head(torch.cat([seq_emb, static_emb], dim=1)).squeeze(-1) + + class PositionalEncoding(nn.Module): + def __init__(self, d_model: int, max_len: int = 64): + super().__init__() + position = torch.arange(max_len).unsqueeze(1) + div_term = torch.exp(torch.arange(0, d_model, 2) * (-math.log(10000.0) / d_model)) + pe = torch.zeros(max_len, d_model) + pe[:, 0::2] = torch.sin(position * div_term) + pe[:, 1::2] = torch.cos(position * div_term) + self.register_buffer("pe", pe.unsqueeze(0)) + + def forward(self, x): + return x + self.pe[:, : x.size(1)] + + class TransformerClassifier(nn.Module): + def __init__(self, seq_dim: int, static_dim: int): + super().__init__() + d_model = 128 + self.input_proj = nn.Linear(seq_dim, d_model) + self.pos = PositionalEncoding(d_model) + layer = nn.TransformerEncoderLayer( + d_model=d_model, + nhead=4, + dim_feedforward=256, + dropout=0.1, + batch_first=True, + activation="gelu", + ) + self.encoder = nn.TransformerEncoder(layer, num_layers=2) + self.static_encoder = StaticEncoder(static_dim, args.static_hidden, args.static_out) + self.head = nn.Sequential( + nn.Linear(d_model + args.static_out, args.fusion_hidden), + nn.ReLU(), + nn.Dropout(args.dropout), + nn.Linear(args.fusion_hidden, 1), + ) + + def forward(self, x_seq, x_static): + seq_tokens = self.pos(self.input_proj(x_seq)) + seq_emb = self.encoder(seq_tokens).mean(dim=1) + static_emb = self.static_encoder(x_static) + return self.head(torch.cat([seq_emb, static_emb], dim=1)).squeeze(-1) + + if model_name == "gru": + model = GRUClassifier(seq_dim, static_dim) + elif model_name == "tcn": + model = TCNClassifier(seq_dim, static_dim) + elif model_name == "transformer": + model = TransformerClassifier(seq_dim, static_dim) + else: + raise ValueError(model_name) + model = model.to(torch_device) + + if args.task == "ia_failure": + criterion, criterion_unweighted, raw_pos_weight, pos_weight, imbalance_strategy = bce_with_optional_pos_weight( + nn, args, data["train"]["y"], torch_device + ) + maximize = True + best_metric_name = "val_auprc" + else: + criterion = nn.HuberLoss() + criterion_unweighted = None + raw_pos_weight = None + pos_weight = None + imbalance_strategy = None + maximize = False + best_metric_name = "val_mae_hours" + optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) + scheduler, scheduler_type = build_neural_scheduler(optimizer, args, args.task) + batch_size = args.batch_size or 256 + sampler = None + shuffle = True + if args.task == "ia_failure" and args.sampling_strategy == "weighted": + y_np = data["train"]["y"].astype(int) + class_counts = np.bincount(y_np, minlength=2).astype(float) + weights = 1.0 / np.maximum(class_counts[y_np], 1.0) + sampler = WeightedRandomSampler(torch.tensor(weights, dtype=torch.double), num_samples=len(weights), replacement=True) + shuffle = False + loader = DataLoader( + TensorDataset(X_seq_train, X_static_train, y_train), + batch_size=batch_size, + shuffle=shuffle, + sampler=sampler, + num_workers=0, + ) + history = [] + best_value = -float("inf") if maximize else float("inf") + best_epoch = -1 + patience = 0 + + def predict_numpy(seq_tensor, static_tensor) -> np.ndarray: + model.eval() + outputs = [] + with torch.no_grad(): + for start_idx in range(0, len(seq_tensor), batch_size * 4): + seq_batch = seq_tensor[start_idx : start_idx + batch_size * 4].to(torch_device) + static_batch = static_tensor[start_idx : start_idx + batch_size * 4].to(torch_device) + outputs.append(model(seq_batch, static_batch).detach().cpu().numpy()) + return np.concatenate(outputs) + + for epoch in range(1, args.max_epochs + 1): + model.train() + total_loss = 0.0 + total_unweighted_bce = 0.0 + total_n = 0 + train_logits_epoch = [] + train_y_epoch = [] + optimizer.zero_grad(set_to_none=True) + num_batches = len(loader) + for batch_idx, (xb_seq, xb_static, yb) in enumerate(loader, start=1): + xb_seq = xb_seq.to(torch_device) + xb_static = xb_static.to(torch_device) + yb = yb.to(torch_device) + pred = model(xb_seq, xb_static) + loss = criterion(pred, yb) + (loss / max(1, args.grad_accum_steps)).backward() + if batch_idx % args.grad_accum_steps == 0 or batch_idx == num_batches: + if args.gradient_clip and args.gradient_clip > 0: + torch.nn.utils.clip_grad_norm_(model.parameters(), args.gradient_clip) + optimizer.step() + optimizer.zero_grad(set_to_none=True) + total_loss += float(loss.detach().cpu()) * len(yb) + if criterion_unweighted is not None: + unweighted_loss = criterion_unweighted(pred, yb) + total_unweighted_bce += float(unweighted_loss.detach().cpu()) * len(yb) + train_logits_epoch.append(pred.detach().cpu().numpy()) + train_y_epoch.append(yb.detach().cpu().numpy()) + total_n += len(yb) + train_loss = total_loss / max(1, total_n) + train_bce_unweighted = total_unweighted_bce / max(1, total_n) if criterion_unweighted is not None else None + val_raw = predict_numpy(X_seq_val, X_static_val) + with torch.no_grad(): + val_loss = float( + criterion( + torch.tensor(val_raw, dtype=torch.float32, device=torch_device), + torch.tensor(y_val_np, dtype=torch.float32, device=torch_device), + ).detach().cpu() + ) + val_bce_unweighted = None + if criterion_unweighted is not None: + val_bce_unweighted = float( + criterion_unweighted( + torch.tensor(val_raw, dtype=torch.float32, device=torch_device), + torch.tensor(y_val_np, dtype=torch.float32, device=torch_device), + ).detach().cpu() + ) + if args.task == "ia_failure": + val_score = sigmoid(val_raw) + threshold, _ = best_f1_threshold(y_val_np, val_score) + metrics = classification_metrics(y_val_np, val_score, threshold) + train_score = sigmoid(np.concatenate(train_logits_epoch)) if train_logits_epoch else np.array([]) + train_y_diag = np.concatenate(train_y_epoch) if train_y_epoch else np.array([]) + train_metrics = train_epoch_metrics(train_y_diag, train_score) if len(train_score) else {} + monitor = metrics["auprc"] + row = { + "epoch": epoch, + "train_loss": train_loss, + "val_loss": val_loss, + "val_auprc": metrics["auprc"], + "val_auroc": metrics["auroc"], + "val_f1": metrics["f1"], + "val_precision": metrics["precision"], + "val_recall": metrics["recall"], + "val_balanced_accuracy": metrics["balanced_accuracy"], + "val_brier": metrics["brier"], + "val_bce": metrics["bce"], + "val_ece": metrics["ece"], + "lr": optimizer.param_groups[0]["lr"], + "train_bce_unweighted": train_bce_unweighted, + "val_bce_unweighted": val_bce_unweighted, + "pos_weight_raw": raw_pos_weight, + "pos_weight_effective": pos_weight, + } + row.update(train_metrics) + else: + hours_true = data["val"]["index"].get("containment_hours", pd.Series(np.expm1(y_val_np))).to_numpy(dtype=float) + metrics = regression_metrics(y_val_np, val_raw, hours_true) + monitor = metrics["mae_hours"] + row = { + "epoch": epoch, + "train_loss": train_loss, + "val_loss": val_loss, + "val_mae_hours": metrics["mae_hours"], + "val_rmse_hours": metrics["rmse_hours"], + "val_median_ae_hours": metrics["median_ae_hours"], + "val_log_mae": metrics["log_mae"], + "val_log_rmse": metrics["log_rmse"], + "val_r2": metrics["r2"], + "val_spearman": metrics["spearman"], + "val_pearson": metrics["pearson"], + "lr": optimizer.param_groups[0]["lr"], + } + if scheduler is not None: + step_neural_scheduler(scheduler, scheduler_type, monitor) + row["lr"] = optimizer.param_groups[0]["lr"] + history.append(row) + improved = monitor > best_value if maximize else monitor < best_value + if improved: + best_value = monitor + best_epoch = epoch + patience = 0 + torch.save( + { + "epoch": epoch, + "model_name": model_name, + "model_state_dict": model.state_dict(), + "metric": best_value, + "seq_dim": int(seq_dim), + "static_dim": int(static_dim), + }, + out_dir / "best_checkpoint.pt", + ) + else: + patience += 1 + torch.save( + { + "epoch": epoch, + "model_name": model_name, + "model_state_dict": model.state_dict(), + "metric": monitor, + "seq_dim": int(seq_dim), + "static_dim": int(static_dim), + }, + out_dir / "last_checkpoint.pt", + ) + if args.task == "ia_failure": + print(f"{model_name} epoch {epoch}: train_loss={train_loss:.4f} val_auprc={metrics['auprc']:.4f} val_auroc={metrics['auroc']:.4f}", flush=True) + else: + print(f"{model_name} epoch {epoch}: train_loss={train_loss:.4f} val_mae_hours={metrics['mae_hours']:.4f} val_rmse_hours={metrics['rmse_hours']:.4f}", flush=True) + if patience >= args.early_stop_patience: + print(f"Early stopping at epoch {epoch}; best_epoch={best_epoch}, {best_metric_name}={best_value:.6f}") + break + + checkpoint = torch.load(out_dir / "best_checkpoint.pt", map_location=torch_device) + model.load_state_dict(checkpoint["model_state_dict"]) + val_raw = predict_numpy(X_seq_val, X_static_val) + test_raw = predict_numpy(X_seq_test, X_static_test) + if args.task == "ia_failure": + val_score = sigmoid(val_raw) + test_score = sigmoid(test_raw) + threshold, _ = best_f1_threshold(y_val_np, val_score) + val_metrics = classification_metrics(y_val_np, val_score, threshold) + test_metrics = classification_metrics(y_test_np, test_score, threshold) + pred_val = classification_predictions(data["val"]["index"], y_val_np, val_score, threshold, model_name, args.seed) + pred_test = classification_predictions(data["test"]["index"], y_test_np, test_score, threshold, model_name, args.seed) + if args.save_train_predictions: + train_raw = predict_numpy(X_seq_train, X_static_train) + train_score = sigmoid(train_raw) + classification_predictions(data["train"]["index"], data["train"]["y"].astype(np.float32), train_score, threshold, model_name, args.seed).to_parquet( + out_dir / "predictions_train.parquet", index=False + ) + extra = { + "class_imbalance_strategy": imbalance_strategy, + "raw_pos_weight_or_scale_pos_weight": raw_pos_weight, + "pos_weight_or_scale_pos_weight": pos_weight, + "disable_pos_weight": bool(args.disable_pos_weight), + "pos_weight_scale": float(args.pos_weight_scale), + "loss_type": args.loss_type, + "label_smoothing": float(args.label_smoothing), + "focal_gamma": float(args.focal_gamma), + "lr_scheduler_type": scheduler_type, + "best_threshold_from_val": threshold, + "best_epoch": int(best_epoch), + "seq_dim": int(seq_dim), + "static_dim": int(static_dim), + } + extra.update(score_logit_diagnostics(val_score, "val")) + extra.update(score_logit_diagnostics(test_score, "test")) + else: + val_hours = data["val"]["index"].get("containment_hours", pd.Series(np.expm1(y_val_np))).to_numpy(dtype=float) + test_hours = data["test"]["index"].get("containment_hours", pd.Series(np.expm1(y_test_np))).to_numpy(dtype=float) + val_metrics = regression_metrics(y_val_np, val_raw, val_hours) + test_metrics = regression_metrics(y_test_np, test_raw, test_hours) + pred_val = regression_predictions(data["val"]["index"], y_val_np, val_raw, model_name, args.seed) + pred_test = regression_predictions(data["test"]["index"], y_test_np, test_raw, model_name, args.seed) + extra = { + "class_imbalance_strategy": None, + "pos_weight_or_scale_pos_weight": None, + "lr_scheduler_type": scheduler_type, + "best_epoch": int(best_epoch), + "seq_dim": int(seq_dim), + "static_dim": int(static_dim), + } + + history_df = pd.DataFrame(history) + history_df.to_csv(out_dir / "history.csv", index=False) + plot_training_curves(history_df, out_dir, args.task, best_epoch=best_epoch) + pred_val.to_parquet(out_dir / "predictions_val.parquet", index=False) + pred_test.to_parquet(out_dir / "predictions_test.parquet", index=False) + runtime = time.time() - start + metrics_payload = base_metrics_payload(args, model_name, cache, out_dir, data, runtime, device) + metrics_payload.update(extra) + metrics_payload.update({f"val_{k}": v for k, v in val_metrics.items()}) + metrics_payload.update({f"test_{k}": v for k, v in test_metrics.items()}) + write_json(out_dir / "metrics.json", metrics_payload) + + +def build_patch_model(model_name: str, input_shape: tuple[int, ...], args, torch_device): + import torch + import torch.nn as nn + import torch.nn.functional as F + + class ConvNormAct(nn.Module): + def __init__(self, in_ch: int, out_ch: int, kernel_size: int = 3, stride: int = 1): + super().__init__() + padding = kernel_size // 2 + self.net = nn.Sequential( + nn.Conv2d(in_ch, out_ch, kernel_size=kernel_size, stride=stride, padding=padding, bias=False), + nn.BatchNorm2d(out_ch), + nn.ReLU(inplace=True), + ) + + def forward(self, x): + return self.net(x) + + class ResidualBlock(nn.Module): + def __init__(self, in_ch: int, out_ch: int, stride: int = 1): + super().__init__() + self.conv1 = ConvNormAct(in_ch, out_ch, stride=stride) + self.conv2 = nn.Sequential( + nn.Conv2d(out_ch, out_ch, kernel_size=3, padding=1, bias=False), + nn.BatchNorm2d(out_ch), + ) + self.skip = ( + nn.Sequential(nn.Conv2d(in_ch, out_ch, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(out_ch)) + if in_ch != out_ch or stride != 1 + else nn.Identity() + ) + + def forward(self, x): + return F.relu(self.conv2(self.conv1(x)) + self.skip(x), inplace=True) + + class BottleneckBlock(nn.Module): + def __init__(self, in_ch: int, out_ch: int, stride: int = 1): + super().__init__() + mid = max(out_ch // 4, 16) + self.net = nn.Sequential( + nn.Conv2d(in_ch, mid, kernel_size=1, bias=False), + nn.BatchNorm2d(mid), + nn.ReLU(inplace=True), + nn.Conv2d(mid, mid, kernel_size=3, stride=stride, padding=1, bias=False), + nn.BatchNorm2d(mid), + nn.ReLU(inplace=True), + nn.Conv2d(mid, out_ch, kernel_size=1, bias=False), + nn.BatchNorm2d(out_ch), + ) + self.skip = ( + nn.Sequential(nn.Conv2d(in_ch, out_ch, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(out_ch)) + if in_ch != out_ch or stride != 1 + else nn.Identity() + ) + + def forward(self, x): + return F.relu(self.net(x) + self.skip(x), inplace=True) + + def make_layer(block, in_ch: int, out_ch: int, blocks: int, stride: int): + layers = [block(in_ch, out_ch, stride=stride)] + for _ in range(1, blocks): + layers.append(block(out_ch, out_ch, stride=1)) + return nn.Sequential(*layers) + + class ResNetUNetClassifier(nn.Module): + def __init__(self, in_channels: int, variant: str): + super().__init__() + base = 32 + if variant == "resnet18_unet": + block, counts = ResidualBlock, [2, 2, 2, 2] + else: + block, counts = BottleneckBlock, [3, 4, 6, 3] + self.stem = ConvNormAct(in_channels, base) + self.enc1 = make_layer(block, base, base, counts[0], stride=1) + self.enc2 = make_layer(block, base, base * 2, counts[1], stride=2) + self.enc3 = make_layer(block, base * 2, base * 4, counts[2], stride=2) + self.enc4 = make_layer(block, base * 4, base * 8, counts[3], stride=2) + self.dec3 = ConvNormAct(base * 8 + base * 4, base * 4) + self.dec2 = ConvNormAct(base * 4 + base * 2, base * 2) + self.dec1 = ConvNormAct(base * 2 + base, base) + self.head = nn.Sequential( + nn.AdaptiveAvgPool2d(1), + nn.Flatten(), + nn.Linear(base, args.fusion_hidden), + nn.ReLU(inplace=True), + nn.Dropout(args.dropout), + nn.Linear(args.fusion_hidden, 1), + ) + + def forward(self, x): + s0 = self.stem(x) + s1 = self.enc1(s0) + s2 = self.enc2(s1) + s3 = self.enc3(s2) + z = self.enc4(s3) + z = F.interpolate(z, size=s3.shape[-2:], mode="bilinear", align_corners=False) + z = self.dec3(torch.cat([z, s3], dim=1)) + z = F.interpolate(z, size=s2.shape[-2:], mode="bilinear", align_corners=False) + z = self.dec2(torch.cat([z, s2], dim=1)) + z = F.interpolate(z, size=s1.shape[-2:], mode="bilinear", align_corners=False) + z = self.dec1(torch.cat([z, s1], dim=1)) + return self.head(z).squeeze(-1) + + class WindowAttentionBlock(nn.Module): + """Lightweight Swin-style local window attention for small wildfire patches.""" + + def __init__(self, dim: int, num_heads: int = 4, window_size: int = 7, dropout: float = 0.0): + super().__init__() + self.window_size = window_size + self.norm1 = nn.LayerNorm(dim) + self.attn = nn.MultiheadAttention(dim, num_heads=num_heads, dropout=dropout, batch_first=True) + self.norm2 = nn.LayerNorm(dim) + self.mlp = nn.Sequential( + nn.Linear(dim, dim * 2), + nn.GELU(), + nn.Dropout(dropout), + nn.Linear(dim * 2, dim), + ) + + def forward(self, x): + b, c, h, w = x.shape + ws = self.window_size + pad_h = (ws - h % ws) % ws + pad_w = (ws - w % ws) % ws + if pad_h or pad_w: + x = F.pad(x, (0, pad_w, 0, pad_h)) + hp, wp = x.shape[-2:] + tokens = x.permute(0, 2, 3, 1).contiguous() + windows = tokens.view(b, hp // ws, ws, wp // ws, ws, c).permute(0, 1, 3, 2, 4, 5).reshape(-1, ws * ws, c) + attn_in = self.norm1(windows) + attn_out, _ = self.attn(attn_in, attn_in, attn_in, need_weights=False) + windows = windows + attn_out + windows = windows + self.mlp(self.norm2(windows)) + tokens = windows.view(b, hp // ws, wp // ws, ws, ws, c).permute(0, 1, 3, 2, 4, 5).reshape(b, hp, wp, c) + out = tokens.permute(0, 3, 1, 2).contiguous() + return out[:, :, :h, :w] + + class SwinUNetClassifier(nn.Module): + def __init__(self, in_channels: int): + super().__init__() + base = 48 + self.stem = ConvNormAct(in_channels, base) + self.enc1 = nn.Sequential(WindowAttentionBlock(base, num_heads=4, window_size=7, dropout=args.dropout), ConvNormAct(base, base)) + self.down = ConvNormAct(base, base * 2, stride=2) + self.enc2 = nn.Sequential(WindowAttentionBlock(base * 2, num_heads=4, window_size=5, dropout=args.dropout), ConvNormAct(base * 2, base * 2)) + self.bottleneck = nn.Sequential(ConvNormAct(base * 2, base * 2), WindowAttentionBlock(base * 2, num_heads=4, window_size=5, dropout=args.dropout)) + self.fuse = ConvNormAct(base * 3, base) + self.dec_attn = WindowAttentionBlock(base, num_heads=4, window_size=7, dropout=args.dropout) + self.head = nn.Sequential( + nn.AdaptiveAvgPool2d(1), + nn.Flatten(), + nn.Linear(base, args.fusion_hidden), + nn.ReLU(inplace=True), + nn.Dropout(args.dropout), + nn.Linear(args.fusion_hidden, 1), + ) + + def forward(self, x): + s1 = self.enc1(self.stem(x)) + z = self.enc2(self.down(s1)) + z = self.bottleneck(z) + z = F.interpolate(z, size=s1.shape[-2:], mode="bilinear", align_corners=False) + z = self.fuse(torch.cat([z, s1], dim=1)) + z = self.dec_attn(z) + return self.head(z).squeeze(-1) + + class MixFFN(nn.Module): + def __init__(self, dim: int, dropout: float): + super().__init__() + self.fc1 = nn.Conv2d(dim, dim * 2, kernel_size=1) + self.dwconv = nn.Conv2d(dim * 2, dim * 2, kernel_size=3, padding=1, groups=dim * 2) + self.fc2 = nn.Conv2d(dim * 2, dim, kernel_size=1) + self.drop = nn.Dropout(dropout) + + def forward(self, x): + return self.fc2(self.drop(F.gelu(self.dwconv(self.fc1(x))))) + + class SpatialTransformerBlock(nn.Module): + def __init__(self, dim: int, num_heads: int, dropout: float): + super().__init__() + self.norm1 = nn.LayerNorm(dim) + self.attn = nn.MultiheadAttention(dim, num_heads=num_heads, dropout=dropout, batch_first=True) + self.norm2 = nn.BatchNorm2d(dim) + self.ffn = MixFFN(dim, dropout) + + def forward(self, x): + b, c, h, w = x.shape + tokens = x.flatten(2).transpose(1, 2) + attn_in = self.norm1(tokens) + attn_out, _ = self.attn(attn_in, attn_in, attn_in, need_weights=False) + x = (tokens + attn_out).transpose(1, 2).reshape(b, c, h, w) + x = x + self.ffn(self.norm2(x)) + return x + + class SegFormerClassifier(nn.Module): + def __init__(self, in_channels: int): + super().__init__() + dims = [48, 96, 160] + self.stage1 = nn.Sequential( + nn.Conv2d(in_channels, dims[0], kernel_size=7, stride=2, padding=3, bias=False), + nn.BatchNorm2d(dims[0]), + nn.ReLU(inplace=True), + SpatialTransformerBlock(dims[0], num_heads=4, dropout=args.dropout), + ) + self.stage2 = nn.Sequential( + nn.Conv2d(dims[0], dims[1], kernel_size=3, stride=2, padding=1, bias=False), + nn.BatchNorm2d(dims[1]), + nn.ReLU(inplace=True), + SpatialTransformerBlock(dims[1], num_heads=4, dropout=args.dropout), + ) + self.stage3 = nn.Sequential( + nn.Conv2d(dims[1], dims[2], kernel_size=3, stride=2, padding=1, bias=False), + nn.BatchNorm2d(dims[2]), + nn.ReLU(inplace=True), + SpatialTransformerBlock(dims[2], num_heads=4, dropout=args.dropout), + ) + self.head = nn.Sequential( + nn.AdaptiveAvgPool2d(1), + nn.Flatten(), + nn.Linear(dims[2], args.fusion_hidden), + nn.ReLU(inplace=True), + nn.Dropout(args.dropout), + nn.Linear(args.fusion_hidden, 1), + ) + + def forward(self, x): + return self.head(self.stage3(self.stage2(self.stage1(x)))).squeeze(-1) + + class ConvLSTMCell(nn.Module): + def __init__(self, in_ch: int, hidden_ch: int): + super().__init__() + self.hidden_ch = hidden_ch + self.gates = nn.Conv2d(in_ch + hidden_ch, hidden_ch * 4, kernel_size=3, padding=1) + + def forward(self, x, h, c): + gates = self.gates(torch.cat([x, h], dim=1)) + i, f, o, g = torch.chunk(gates, 4, dim=1) + i, f, o = torch.sigmoid(i), torch.sigmoid(f), torch.sigmoid(o) + g = torch.tanh(g) + c = f * c + i * g + h = o * torch.tanh(c) + return h, c + + class ConvLSTMClassifier(nn.Module): + def __init__(self, in_ch: int): + super().__init__() + hidden = 64 + self.cell = ConvLSTMCell(in_ch, hidden) + self.head = nn.Sequential(nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.Linear(hidden, args.fusion_hidden), nn.ReLU(), nn.Dropout(args.dropout), nn.Linear(args.fusion_hidden, 1)) + + def forward(self, x): + b, t, _, h, w = x.shape + h_state = x.new_zeros((b, 64, h, w)) + c_state = x.new_zeros((b, 64, h, w)) + for step in range(t): + h_state, c_state = self.cell(x[:, step], h_state, c_state) + return self.head(h_state).squeeze(-1) + + class ConvGRUCell(nn.Module): + def __init__(self, in_ch: int, hidden_ch: int): + super().__init__() + self.hidden_ch = hidden_ch + self.reset_update = nn.Conv2d(in_ch + hidden_ch, hidden_ch * 2, kernel_size=3, padding=1) + self.out_gate = nn.Conv2d(in_ch + hidden_ch, hidden_ch, kernel_size=3, padding=1) + + def forward(self, x, h): + z_r = self.reset_update(torch.cat([x, h], dim=1)) + z, r = torch.chunk(z_r, 2, dim=1) + z, r = torch.sigmoid(z), torch.sigmoid(r) + n = torch.tanh(self.out_gate(torch.cat([x, r * h], dim=1))) + return (1.0 - z) * h + z * n + + class ConvGRUClassifier(nn.Module): + def __init__(self, in_ch: int): + super().__init__() + hidden = 64 + self.cell = ConvGRUCell(in_ch, hidden) + self.head = nn.Sequential(nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.Linear(hidden, args.fusion_hidden), nn.ReLU(), nn.Dropout(args.dropout), nn.Linear(args.fusion_hidden, 1)) + + def forward(self, x): + b, t, _, h, w = x.shape + h_state = x.new_zeros((b, 64, h, w)) + for step in range(t): + h_state = self.cell(x[:, step], h_state) + return self.head(h_state).squeeze(-1) + + class PredRNNV2Cell(nn.Module): + def __init__(self, in_ch: int, hidden_ch: int): + super().__init__() + self.hidden_ch = hidden_ch + self.x_proj = nn.Conv2d(in_ch, hidden_ch * 4, kernel_size=3, padding=1) + self.h_proj = nn.Conv2d(hidden_ch, hidden_ch * 4, kernel_size=3, padding=1) + self.m_proj = nn.Conv2d(hidden_ch, hidden_ch * 3, kernel_size=3, padding=1) + self.fuse = nn.Conv2d(hidden_ch * 2, hidden_ch, kernel_size=1) + + def forward(self, x, h, c, m): + xi, xf, xo, xg = torch.chunk(self.x_proj(x), 4, dim=1) + hi, hf, ho, hg = torch.chunk(self.h_proj(h), 4, dim=1) + mi, mf, mg = torch.chunk(self.m_proj(m), 3, dim=1) + i = torch.sigmoid(xi + hi) + f = torch.sigmoid(xf + hf + 1.0) + g = torch.tanh(xg + hg) + c = f * c + i * g + i_m = torch.sigmoid(xi + mi) + f_m = torch.sigmoid(xf + mf + 1.0) + g_m = torch.tanh(xg + mg) + m = f_m * m + i_m * g_m + fused = self.fuse(torch.cat([c, m], dim=1)) + o = torch.sigmoid(xo + ho) + h = o * torch.tanh(fused) + return h, c, m + + class PredRNNV2Classifier(nn.Module): + def __init__(self, in_ch: int): + super().__init__() + hidden = 64 + self.cell = PredRNNV2Cell(in_ch, hidden) + self.head = nn.Sequential(nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.Linear(hidden, args.fusion_hidden), nn.ReLU(), nn.Dropout(args.dropout), nn.Linear(args.fusion_hidden, 1)) + + def forward(self, x): + b, t, _, h, w = x.shape + h_state = x.new_zeros((b, 64, h, w)) + c_state = x.new_zeros((b, 64, h, w)) + m_state = x.new_zeros((b, 64, h, w)) + for step in range(t): + h_state, c_state, m_state = self.cell(x[:, step], h_state, c_state, m_state) + return self.head(h_state).squeeze(-1) + + class BasicBlock3D(nn.Module): + def __init__(self, in_ch: int, out_ch: int, stride: tuple[int, int, int] = (1, 1, 1)): + super().__init__() + self.net = nn.Sequential( + nn.Conv3d(in_ch, out_ch, kernel_size=3, stride=stride, padding=1, bias=False), + nn.BatchNorm3d(out_ch), + nn.ReLU(inplace=True), + nn.Conv3d(out_ch, out_ch, kernel_size=3, padding=1, bias=False), + nn.BatchNorm3d(out_ch), + ) + self.skip = ( + nn.Sequential(nn.Conv3d(in_ch, out_ch, kernel_size=1, stride=stride, bias=False), nn.BatchNorm3d(out_ch)) + if in_ch != out_ch or stride != (1, 1, 1) + else nn.Identity() + ) + + def forward(self, x): + return F.relu(self.net(x) + self.skip(x), inplace=True) + + class ResNet3DClassifier(nn.Module): + def __init__(self, in_ch: int): + super().__init__() + base = 32 + self.net = nn.Sequential( + nn.Conv3d(in_ch, base, kernel_size=3, padding=1, bias=False), + nn.BatchNorm3d(base), + nn.ReLU(inplace=True), + BasicBlock3D(base, base), + BasicBlock3D(base, base * 2, stride=(1, 2, 2)), + BasicBlock3D(base * 2, base * 4, stride=(1, 2, 2)), + BasicBlock3D(base * 4, base * 8, stride=(1, 2, 2)), + nn.AdaptiveAvgPool3d(1), + nn.Flatten(), + nn.Linear(base * 8, args.fusion_hidden), + nn.ReLU(inplace=True), + nn.Dropout(args.dropout), + nn.Linear(args.fusion_hidden, 1), + ) + + def forward(self, x): + return self.net(x.transpose(1, 2)).squeeze(-1) + + class UTAEClassifier(nn.Module): + def __init__(self, in_ch: int): + super().__init__() + hidden = 64 + self.encoder = nn.Sequential( + ConvNormAct(in_ch, hidden), + ResidualBlock(hidden, hidden), + ConvNormAct(hidden, hidden * 2, stride=2), + ResidualBlock(hidden * 2, hidden * 2), + ) + self.attn = nn.Sequential( + nn.Linear(hidden * 2, hidden), + nn.Tanh(), + nn.Linear(hidden, 1), + ) + self.fuse = ConvNormAct(hidden * 2, hidden * 2) + self.head = nn.Sequential( + nn.AdaptiveAvgPool2d(1), + nn.Flatten(), + nn.Linear(hidden * 2, args.fusion_hidden), + nn.ReLU(inplace=True), + nn.Dropout(args.dropout), + nn.Linear(args.fusion_hidden, 1), + ) + + def forward(self, x): + b, t, c, h, w = x.shape + feat = self.encoder(x.reshape(b * t, c, h, w)) + _, ch, fh, fw = feat.shape + feat = feat.view(b, t, ch, fh, fw) + desc = feat.mean(dim=(-2, -1)) + weights = torch.softmax(self.attn(desc).squeeze(-1), dim=1) + agg = (feat * weights[:, :, None, None, None]).sum(dim=1) + return self.head(self.fuse(agg)).squeeze(-1) + + class SwinLSTMClassifier(nn.Module): + def __init__(self, in_ch: int): + super().__init__() + hidden = 48 + self.hidden = hidden + self.stem = nn.Sequential( + nn.Conv2d(in_ch, hidden, kernel_size=3, stride=2, padding=1, bias=False), + nn.BatchNorm2d(hidden), + nn.ReLU(inplace=True), + WindowAttentionBlock(hidden, num_heads=4, window_size=5, dropout=args.dropout), + ) + self.cell = ConvLSTMCell(hidden, hidden) + self.post_attn = WindowAttentionBlock(hidden, num_heads=4, window_size=5, dropout=args.dropout) + self.head = nn.Sequential( + nn.AdaptiveAvgPool2d(1), + nn.Flatten(), + nn.Linear(hidden, args.fusion_hidden), + nn.ReLU(inplace=True), + nn.Dropout(args.dropout), + nn.Linear(args.fusion_hidden, 1), + ) + + def forward(self, x): + b, t, _, _, _ = x.shape + first = self.stem(x[:, 0]) + h_state = x.new_zeros((b, self.hidden, first.shape[-2], first.shape[-1])) + c_state = x.new_zeros((b, self.hidden, first.shape[-2], first.shape[-1])) + h_state, c_state = self.cell(first, h_state, c_state) + for step in range(t): + if step == 0: + continue + x_step = self.stem(x[:, step]) + h_state, c_state = self.cell(x_step, h_state, c_state) + h_state = self.post_attn(h_state) + return self.head(h_state).squeeze(-1) + + if len(input_shape) == 3: + in_ch = int(input_shape[0]) + if model_name in {"resnet18_unet", "resnet50_unet"}: + return ResNetUNetClassifier(in_ch, model_name).to(torch_device) + if model_name == "swin_unet": + return SwinUNetClassifier(in_ch).to(torch_device) + if model_name == "segformer": + return SegFormerClassifier(in_ch).to(torch_device) + if len(input_shape) == 4: + in_ch = int(input_shape[1]) + if model_name == "convlstm": + return ConvLSTMClassifier(in_ch).to(torch_device) + if model_name == "convgru": + return ConvGRUClassifier(in_ch).to(torch_device) + if model_name == "predrnn_v2": + return PredRNNV2Classifier(in_ch).to(torch_device) + if model_name == "resnet3d": + return ResNet3DClassifier(in_ch).to(torch_device) + if model_name == "utae": + return UTAEClassifier(in_ch).to(torch_device) + if model_name == "swinlstm": + return SwinLSTMClassifier(in_ch).to(torch_device) + raise ValueError(f"Model {model_name} does not match input shape {input_shape}.") + + +def train_patch_neural(args, data: dict[str, Any], out_dir: Path, cache: Path, device: dict[str, Any], model_name: str) -> None: + try: + import torch + import torch.nn as nn + except ImportError as exc: + raise ImportError("PyTorch is required for patch neural models.") from exc + + start = time.time() + torch_device = torch.device(device["device"] if str(device.get("device", "cpu")).startswith("cuda") else "cpu") + X_train = data["train"]["X"] + X_val = data["val"]["X"] + X_test = data["test"]["X"] + y_train_np = data["train"]["y"].astype(np.float32) + y_val_np = data["val"]["y"].astype(np.float32) + y_test_np = data["test"]["y"].astype(np.float32) + channel_mean = None + channel_std = None + if args.standardize_channels: + print("Computing train-only channel standardization stats...", flush=True) + channel_mean, channel_std = compute_channel_standardization_stats(X_train, out_dir) + model = build_patch_model(model_name, tuple(X_train.shape[1:]), args, torch_device) + if args.task == "ia_failure": + criterion, criterion_unweighted, raw_pos_weight, pos_weight, imbalance_strategy = bce_with_optional_pos_weight( + nn, args, y_train_np, torch_device + ) + maximize = True + best_metric_name = "val_auprc" + else: + criterion = nn.HuberLoss() + criterion_unweighted = None + raw_pos_weight = None + pos_weight = None + imbalance_strategy = None + maximize = False + best_metric_name = "val_mae_hours" + optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) + scheduler, scheduler_type = build_neural_scheduler(optimizer, args, args.task) + batch_size = args.batch_size or default_batch_size(canonical_representation_name(args.representation)) + sampling_prob = None + if args.task == "ia_failure" and args.sampling_strategy == "weighted": + class_counts = np.bincount(y_train_np.astype(int), minlength=2).astype(float) + weights = 1.0 / np.maximum(class_counts[y_train_np.astype(int)], 1.0) + sampling_prob = weights / weights.sum() + history = [] + best_value = -float("inf") if maximize else float("inf") + best_epoch = -1 + patience = 0 + + def predict_numpy(X) -> np.ndarray: + model.eval() + outputs = [] + with torch.no_grad(): + for start_idx in range(0, len(X), batch_size * 2): + batch_np = standardize_patch_batch(X[start_idx : start_idx + batch_size * 2], channel_mean, channel_std) + batch = torch.tensor(batch_np, dtype=torch.float32, device=torch_device) + outputs.append(model(batch).detach().cpu().numpy()) + return np.concatenate(outputs) + + for epoch in range(1, args.max_epochs + 1): + model.train() + total_loss = 0.0 + total_unweighted_bce = 0.0 + total_n = 0 + if sampling_prob is None: + order = np.random.permutation(len(y_train_np)) + else: + order = np.random.choice(np.arange(len(y_train_np)), size=len(y_train_np), replace=True, p=sampling_prob) + train_logits_epoch = [] + train_y_epoch = [] + optimizer.zero_grad(set_to_none=True) + num_batches = int(math.ceil(len(order) / batch_size)) + for start_idx in range(0, len(order), batch_size): + batch_number = start_idx // batch_size + 1 + batch_idx = order[start_idx : start_idx + batch_size] + xb_np = standardize_patch_batch(X_train[batch_idx], channel_mean, channel_std) + xb = torch.tensor(xb_np, dtype=torch.float32, device=torch_device) + yb = torch.tensor(y_train_np[batch_idx], dtype=torch.float32, device=torch_device) + pred = model(xb) + loss = criterion(pred, yb) + (loss / max(1, args.grad_accum_steps)).backward() + if batch_number % args.grad_accum_steps == 0 or batch_number == num_batches: + if args.gradient_clip and args.gradient_clip > 0: + torch.nn.utils.clip_grad_norm_(model.parameters(), args.gradient_clip) + optimizer.step() + optimizer.zero_grad(set_to_none=True) + total_loss += float(loss.detach().cpu()) * len(yb) + if criterion_unweighted is not None: + unweighted_loss = criterion_unweighted(pred, yb) + total_unweighted_bce += float(unweighted_loss.detach().cpu()) * len(yb) + train_logits_epoch.append(pred.detach().cpu().numpy()) + train_y_epoch.append(yb.detach().cpu().numpy()) + total_n += len(yb) + train_loss = total_loss / max(1, total_n) + train_bce_unweighted = total_unweighted_bce / max(1, total_n) if criterion_unweighted is not None else None + val_raw = predict_numpy(X_val) + with torch.no_grad(): + val_raw_t = torch.tensor(val_raw, dtype=torch.float32, device=torch_device) + y_val_t = torch.tensor(y_val_np, dtype=torch.float32, device=torch_device) + val_loss = float(criterion(val_raw_t, y_val_t).detach().cpu()) + val_bce_unweighted = None + if criterion_unweighted is not None: + val_bce_unweighted = float(criterion_unweighted(val_raw_t, y_val_t).detach().cpu()) + if args.task == "ia_failure": + val_score = sigmoid(val_raw) + threshold, _ = best_f1_threshold(y_val_np, val_score) + metrics = classification_metrics(y_val_np, val_score, threshold) + train_score = sigmoid(np.concatenate(train_logits_epoch)) if train_logits_epoch else np.array([]) + train_y_diag = np.concatenate(train_y_epoch) if train_y_epoch else np.array([]) + train_metrics = train_epoch_metrics(train_y_diag, train_score) if len(train_score) else {} + monitor = metrics["auprc"] + row = { + "epoch": epoch, + "train_loss": train_loss, + "val_loss": val_loss, + "val_auprc": metrics["auprc"], + "val_auroc": metrics["auroc"], + "val_f1": metrics["f1"], + "val_precision": metrics["precision"], + "val_recall": metrics["recall"], + "val_balanced_accuracy": metrics["balanced_accuracy"], + "val_brier": metrics["brier"], + "val_bce": metrics["bce"], + "val_ece": metrics["ece"], + "lr": optimizer.param_groups[0]["lr"], + "train_bce_unweighted": train_bce_unweighted, + "val_bce_unweighted": val_bce_unweighted, + "pos_weight_raw": raw_pos_weight, + "pos_weight_effective": pos_weight, + } + row.update(train_metrics) + else: + hours_true = data["val"]["index"].get("containment_hours", pd.Series(np.expm1(y_val_np))).to_numpy(dtype=float) + metrics = regression_metrics(y_val_np, val_raw, hours_true) + monitor = metrics["mae_hours"] + row = { + "epoch": epoch, + "train_loss": train_loss, + "val_loss": val_loss, + "val_mae_hours": metrics["mae_hours"], + "val_rmse_hours": metrics["rmse_hours"], + "val_median_ae_hours": metrics["median_ae_hours"], + "val_log_mae": metrics["log_mae"], + "val_log_rmse": metrics["log_rmse"], + "val_r2": metrics["r2"], + "val_spearman": metrics["spearman"], + "val_pearson": metrics["pearson"], + "lr": optimizer.param_groups[0]["lr"], + } + if scheduler is not None: + step_neural_scheduler(scheduler, scheduler_type, monitor) + row["lr"] = optimizer.param_groups[0]["lr"] + history.append(row) + improved = monitor > best_value if maximize else monitor < best_value + if improved: + best_value = monitor + best_epoch = epoch + patience = 0 + torch.save( + { + "epoch": epoch, + "model_name": model_name, + "model_state_dict": model.state_dict(), + "metric": best_value, + "input_shape": list(X_train.shape[1:]), + }, + out_dir / "best_checkpoint.pt", + ) + else: + patience += 1 + torch.save( + { + "epoch": epoch, + "model_name": model_name, + "model_state_dict": model.state_dict(), + "metric": monitor, + "input_shape": list(X_train.shape[1:]), + }, + out_dir / "last_checkpoint.pt", + ) + if args.task == "ia_failure": + print(f"{model_name} epoch {epoch}: train_loss={train_loss:.4f} val_auprc={metrics['auprc']:.4f} val_auroc={metrics['auroc']:.4f}", flush=True) + else: + print(f"{model_name} epoch {epoch}: train_loss={train_loss:.4f} val_mae_hours={metrics['mae_hours']:.4f} val_rmse_hours={metrics['rmse_hours']:.4f}", flush=True) + if patience >= args.early_stop_patience: + print(f"Early stopping at epoch {epoch}; best_epoch={best_epoch}, {best_metric_name}={best_value:.6f}") + break + + checkpoint = torch.load(out_dir / "best_checkpoint.pt", map_location=torch_device) + model.load_state_dict(checkpoint["model_state_dict"]) + val_raw = predict_numpy(X_val) + test_raw = predict_numpy(X_test) + if args.task == "ia_failure": + val_score = sigmoid(val_raw) + test_score = sigmoid(test_raw) + threshold, _ = best_f1_threshold(y_val_np, val_score) + val_metrics = classification_metrics(y_val_np, val_score, threshold) + test_metrics = classification_metrics(y_test_np, test_score, threshold) + pred_val = classification_predictions(data["val"]["index"], y_val_np, val_score, threshold, model_name, args.seed) + pred_test = classification_predictions(data["test"]["index"], y_test_np, test_score, threshold, model_name, args.seed) + if args.save_train_predictions: + train_raw = predict_numpy(X_train) + train_score = sigmoid(train_raw) + classification_predictions(data["train"]["index"], y_train_np, train_score, threshold, model_name, args.seed).to_parquet( + out_dir / "predictions_train.parquet", index=False + ) + extra = { + "class_imbalance_strategy": imbalance_strategy, + "raw_pos_weight_or_scale_pos_weight": raw_pos_weight, + "pos_weight_or_scale_pos_weight": pos_weight, + "disable_pos_weight": bool(args.disable_pos_weight), + "pos_weight_scale": float(args.pos_weight_scale), + "loss_type": args.loss_type, + "label_smoothing": float(args.label_smoothing), + "focal_gamma": float(args.focal_gamma), + "lr_scheduler_type": scheduler_type, + "best_threshold_from_val": threshold, + "best_epoch": int(best_epoch), + "input_shape": list(X_train.shape[1:]), + } + extra.update(score_logit_diagnostics(val_score, "val")) + extra.update(score_logit_diagnostics(test_score, "test")) + else: + val_hours = data["val"]["index"].get("containment_hours", pd.Series(np.expm1(y_val_np))).to_numpy(dtype=float) + test_hours = data["test"]["index"].get("containment_hours", pd.Series(np.expm1(y_test_np))).to_numpy(dtype=float) + val_metrics = regression_metrics(y_val_np, val_raw, val_hours) + test_metrics = regression_metrics(y_test_np, test_raw, test_hours) + pred_val = regression_predictions(data["val"]["index"], y_val_np, val_raw, model_name, args.seed) + pred_test = regression_predictions(data["test"]["index"], y_test_np, test_raw, model_name, args.seed) + extra = { + "class_imbalance_strategy": None, + "pos_weight_or_scale_pos_weight": None, + "lr_scheduler_type": scheduler_type, + "best_epoch": int(best_epoch), + "input_shape": list(X_train.shape[1:]), + } + + history_df = pd.DataFrame(history) + history_df.to_csv(out_dir / "history.csv", index=False) + plot_training_curves(history_df, out_dir, args.task, best_epoch=best_epoch) + pred_val.to_parquet(out_dir / "predictions_val.parquet", index=False) + pred_test.to_parquet(out_dir / "predictions_test.parquet", index=False) + runtime = time.time() - start + metrics_payload = base_metrics_payload(args, model_name, cache, out_dir, data, runtime, device) + metrics_payload.update(extra) + metrics_payload.update({f"val_{k}": v for k, v in val_metrics.items()}) + metrics_payload.update({f"test_{k}": v for k, v in test_metrics.items()}) + write_json(out_dir / "metrics.json", metrics_payload) + + +def train_one(args, model_name: str) -> None: + registry = MODEL_REGISTRY[model_name] + if not registry["implemented"]: + raise NotImplementedError(f"Model {model_name} is registered but not implemented in this first version.") + representation = canonical_representation_name(args.representation) + if representation not in registry["families"] and not (representation == "tabular" and model_name in {"logistic_regression", "xgboost", "mlp"}): + raise ValueError(f"Model {model_name} does not support representation={args.representation}.") + if representation not in {"tabular", "temporal", "spatial", "spatiotemporal"}: + raise NotImplementedError("This train.py version supports tabular, temporal, spatial, and spatiotemporal models.") + + if args.gpu_id is not None: + os.environ.setdefault("CUDA_VISIBLE_DEVICES", str(args.gpu_id)) + set_seed(args.seed) + device = device_info(args.device, None if os.environ.get("CUDA_VISIBLE_DEVICES") else args.gpu_id) + cache = cache_dir(args.base_dir, args.task, args.representation, args.weather_days, args.input_protocol) + if not cache.exists(): + raise FileNotFoundError(f"Input cache directory does not exist: {cache}") + data = load_cache(cache, args.task, args.representation) + data = apply_debug_sample_limits(data, args) + effective_name = output_model_name(args.task, model_name) + out_dir = run_dir( + args.base_dir, + args.task, + args.experiment_type, + args.ablation_name, + args.run_tag, + args.representation, + args.weather_days, + args.input_protocol, + effective_name, + args.seed, + ) + prepare_run_dir(out_dir, args.overwrite) + config = vars(args).copy() + config["model_name"] = effective_name + config["input_cache_dir"] = str(cache) + config["output_dir"] = str(out_dir) + config["created_at"] = created_at() + config["effective_batch_size"] = int((args.batch_size or default_batch_size(args.representation)) * args.grad_accum_steps) + write_json(out_dir / "config.json", config) + save_common_artifacts(out_dir, cache) + + if model_name == "logistic_regression": + train_logistic_or_ridge(args, data, out_dir, cache, device) + elif model_name == "xgboost": + train_xgboost(args, data, out_dir, cache, device) + elif model_name == "mlp": + train_mlp(args, data, out_dir, cache, device) + elif model_name in {"gru", "tcn", "transformer"}: + train_temporal_neural(args, data, out_dir, cache, device, model_name) + elif model_name in {"resnet18_unet", "resnet50_unet", "swin_unet", "segformer", "convlstm", "convgru", "predrnn_v2", "resnet3d", "utae", "swinlstm"}: + train_patch_neural(args, data, out_dir, cache, device, model_name) + else: + raise NotImplementedError(f"Model {model_name} is registered but not implemented in this first version.") + print(f"Wrote experiment: {out_dir}") + + +def default_batch_size(representation: str) -> int: + return { + "tabular": 512, + "temporal": 256, + "sequence": 256, + "spatial": 64, + "spatiotemporal": 32, + }[representation] + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser(description="Train wildfire Initial Attack benchmark models from model-ready caches.") + parser.add_argument("--base_dir", default=".") + parser.add_argument("--task", choices=["ia_failure", "containment_time"], default="ia_failure") + parser.add_argument("--experiment_type", choices=["smoke", "full", "ablation"], default="full") + parser.add_argument("--ablation_name", default=None) + parser.add_argument("--run_tag", default=None) + parser.add_argument("--representation", choices=["tabular", "temporal", "sequence", "spatial", "spatiotemporal"], default="tabular") + parser.add_argument("--weather_days", choices=[1, 2, 3, 4, 5], type=int, default=5) + parser.add_argument("--input_protocol", default="all") + parser.add_argument("--model", choices=list(MODEL_REGISTRY) + ["all"], default="xgboost") + parser.add_argument("--seed", type=int, default=0) + parser.add_argument("--device", choices=["auto", "cpu", "cuda"], default="auto") + parser.add_argument("--gpu_id", type=int, default=None) + parser.add_argument("--max_epochs", type=int, default=100) + parser.add_argument("--batch_size", type=int, default=None) + parser.add_argument("--lr", type=float, default=1e-3) + parser.add_argument("--weight_decay", type=float, default=1e-4) + parser.add_argument("--early_stop_patience", type=int, default=15) + parser.add_argument("--gradient_clip", type=float, default=1.0) + parser.add_argument("--use_lr_scheduler", action="store_true") + parser.add_argument("--lr_scheduler_type", choices=["none", "plateau", "cosine"], default="none") + parser.add_argument("--warmup_epochs", type=int, default=0) + parser.add_argument("--min_lr_ratio", type=float, default=0.05) + parser.add_argument("--standardize_channels", action="store_true") + parser.add_argument("--sampling_strategy", choices=["random", "weighted"], default="random") + parser.add_argument("--disable_pos_weight", action="store_true") + parser.add_argument("--pos_weight_scale", type=float, default=1.0) + parser.add_argument("--loss_type", choices=["bce", "focal"], default="bce") + parser.add_argument("--label_smoothing", type=float, default=0.0) + parser.add_argument("--focal_gamma", type=float, default=2.0) + parser.add_argument("--grad_accum_steps", type=int, default=1) + parser.add_argument("--limit_train_samples", type=int, default=None) + parser.add_argument("--limit_val_samples", type=int, default=None) + parser.add_argument("--save_train_predictions", action="store_true") + parser.add_argument("--dropout", type=float, default=0.2) + parser.add_argument("--static_hidden", type=int, default=256) + parser.add_argument("--static_out", type=int, default=128) + parser.add_argument("--fusion_hidden", type=int, default=128) + parser.add_argument("--overwrite", action="store_true") + args = parser.parse_args() + args.base_dir = ensure_project_path(Path(args.base_dir)) + if args.grad_accum_steps < 1: + raise ValueError("--grad_accum_steps must be >= 1") + if args.pos_weight_scale < 0: + raise ValueError("--pos_weight_scale must be >= 0") + if not (0.0 <= args.label_smoothing < 1.0): + raise ValueError("--label_smoothing must be in [0, 1)") + if args.focal_gamma < 0: + raise ValueError("--focal_gamma must be >= 0") + if args.warmup_epochs < 0: + raise ValueError("--warmup_epochs must be >= 0") + if not (0.0 <= args.min_lr_ratio <= 1.0): + raise ValueError("--min_lr_ratio must be in [0, 1]") + if args.batch_size is None: + args.batch_size = default_batch_size(args.representation) + return args + + +def main() -> None: + args = parse_args() + if args.model == "all": + representation = canonical_representation_name(args.representation) + if representation == "tabular": + model_names = ["logistic_regression", "xgboost", "mlp"] + else: + model_names = [ + name + for name, spec in MODEL_REGISTRY.items() + if representation in spec["families"] and spec["implemented"] + ] + skipped = [ + name + for name, spec in MODEL_REGISTRY.items() + if representation in spec["families"] and not spec["implemented"] + ] + for name in skipped: + print(f"Warning: skipping unimplemented registered model: {name}") + for name in model_names: + train_one(args, name) + else: + train_one(args, args.model) + + +if __name__ == "__main__": + main() diff --git a/croissant.json b/croissant.json new file mode 100644 index 0000000000000000000000000000000000000000..8d5a2c33951c3fcdcaefe3491fd2088fab93a84d --- /dev/null +++ b/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" + } + ] +} diff --git a/data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2016/part-0.parquet b/data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2016/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..4d4a79622e449871482470d00afd66c78f58f8e9 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2017/part-0.parquet b/data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2017/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..30441dce900a63a17d05e256ddd3c60e95ec4541 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2018/part-0.parquet b/data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2018/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..49fff478604176e5b74958c1841172e3026f45c5 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2019/part-0.parquet b/data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2019/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..956f4789ce9a3dc9e9b82a5e7e3c952ac2feffa1 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2020/part-0.parquet b/data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet/year=2020/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..e91c888292cbc41fd0178afba317884a023127a1 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2016/part-0.parquet b/data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2016/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..13dd0c420133aa8a91a4c22bdb71ded0685edab9 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2017/part-0.parquet b/data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2017/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1518600ba40872c61fcd4d6356b07ec3ee4f4c08 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2018/part-0.parquet b/data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2018/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..692b6ef5fc687348d52b139513389e4b296d83d9 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2019/part-0.parquet b/data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2019/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..e308d289e071dd84204d53b17cddcf24cbec9fa6 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2020/part-0.parquet b/data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet/year=2020/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..9bf8374063e712db344166bb280a93938fd501b6 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_patch_manifest_375m_natural.json b/data/canonical/raw_feature_tables/event_patch_manifest_375m_natural.json new file mode 100644 index 0000000000000000000000000000000000000000..21adcb57037823144cc9cea8ae95069f3cc69277 --- /dev/null +++ b/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" +} diff --git a/data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2016/part-0.parquet b/data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2016/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..be1b325f69bd44b14a4e6b0c5170342776f44f68 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2017/part-0.parquet b/data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2017/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fcbd6b6b6f5937c1a8550c00714d04cb2d1de350 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2018/part-0.parquet b/data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2018/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..13ffb3c390598dbab4807554fbe2048ecf436eb3 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2019/part-0.parquet b/data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2019/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..aafdd8695d0d8354748fdab8e71d3a2f4bbba242 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2020/part-0.parquet b/data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet/year=2020/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..9d70a30aa27ffc07ae8782b8ee3ac62f101f4630 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2016/part-0.parquet b/data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2016/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fab66798190405dc110c540c02c2a4ffccc664b2 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2017/part-0.parquet b/data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2017/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..cf4bae57876797cb9a4b0d596cf0c313dd4170cf --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2018/part-0.parquet b/data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2018/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1f5f6f5c40f1d22bf1b9b0bde2423eb9fd8a59d1 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2019/part-0.parquet b/data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2019/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..9c14181ab501dc59c6fd436df0cbdc4d8f0213a9 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2020/part-0.parquet b/data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet/year=2020/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..124c54979a320a985ac87cc0ef46c5446cf5847c --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2016/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2016/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..c2c16bf3fe4a46fd1619c75a6fac0859de801a0c --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2017/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2017/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..7d3afb5af1c1ea738436eb412acceaf08d67fc30 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2018/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2018/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..d28172a9392159edc41c22181682de16cb6d0b11 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2019/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2019/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..2fefa4f5c6af704d221998e6afac5b8724d5904d --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2020/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet/year=2020/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..42413e2d0b44e52adbadca2870bd9f16b9c5ecc1 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-1/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-1/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..3d8b8282d7623c4d8644517020d35305d2fcc7d9 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-2/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-2/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..a44f952f32a12b42446d89909279ddbb468510d3 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-3/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-3/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..afdf8b8cf9d7b1bf4d34c1e2812a665f46c01549 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-4/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=-4/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..d5268f9e568205260031df42faccdd0379044735 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=0/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2016/relative_day=0/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..475e48c8989ce3a985802c54f26f49d40226b5d4 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-1/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-1/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..c5f3fe929a5e242d6c73eb8ecfba78b5d72a6638 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-2/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-2/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..6867ffd2b79e12f38733d0ba7e413604aed08e32 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-3/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-3/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..059fbc20911d174610b9134cf83fd70f3749cb45 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-4/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=-4/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..480f8e01696d9ad379701d49323f50a3126e2b73 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=0/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2017/relative_day=0/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1491705c0722174eefa10a041ea2db90e6b8818e --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-1/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-1/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1537b847aea35136da7820778bcc133047415ea3 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-2/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-2/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..8c02099df26efb041300acf8bd22f04c602cca19 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-3/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-3/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..6961437002f0f13a523eca91fa045e9d8588b051 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-4/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=-4/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..2692cd6262bb6accccf804d5e64b18d877400c9d --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=0/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2018/relative_day=0/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..68fe71aa28619d893692607e780273882c4f05c8 --- /dev/null +++ b/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 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-1/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-1/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..a49d16748ac02ce46d2eaa2380e55769bc05980e --- /dev/null +++ b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-1/part-0.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1620769e478279716936e96b3ad4e0fe4ab5a48a8497dbe72e0088a8cb31c392 +size 2213472 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-2/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-2/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..69aa95b0d9225f4f7cd9a2ffc9b28b66eb2309ea --- /dev/null +++ b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-2/part-0.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3822d1af0270dc8d6b34b5cc14255f514bd3e7b939d37443d116f73b6bc6611b +size 2212169 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-3/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-3/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..ba60ed2cf85dad528e6162b2f1b4621fd4d7b715 --- /dev/null +++ b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-3/part-0.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fda4a7d274d532c7b4c277b11c0c940ceb0dce3dcbb39415c8c538b489c2ac77 +size 2212340 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-4/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-4/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..329ea029c28eb614ed78f07409865b730630fd58 --- /dev/null +++ b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=-4/part-0.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:106c549b8b9f2a26ac03771e535d6838c2c24af552255493b5105a1b7b1db238 +size 2213338 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=0/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=0/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..4f76e8d3bfe277c1222f919a7e4cf357cbcefd9b --- /dev/null +++ b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2019/relative_day=0/part-0.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e9cb0d65a4e9a2f04309b34d147e4caf1b0cff532fa9d707b245e3dc33bddfa8 +size 2214069 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-1/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-1/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..330be4c2ea745a39c748783a43db400735fe2b3f --- /dev/null +++ b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-1/part-0.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3d4694ebd1010c29a1b89d2b120c9e1c9d6a89d4be0613f0e39eb47af1558956 +size 1964914 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-2/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-2/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..c6023b4dfcce07e4465a79dc80ed5f7a20dd0690 --- /dev/null +++ b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-2/part-0.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cc55a46eac04c5608dcd9eb09ad98be10cf0b3e78f24b0fe6cb8df58fc7a4e29 +size 1963442 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-3/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-3/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..21c6f4017762911252683b695e8b85a06c027813 --- /dev/null +++ b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-3/part-0.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a7021f7850646c3bb862d6ac3f934f3545686541c72a366ee4f11e9179b69fd8 +size 1964110 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-4/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-4/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..4f5656b72853c99a3344a8ee225ec91c6a71f9db --- /dev/null +++ b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=-4/part-0.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1977d2084b5fb409bebd075157b47381789e13f37d133f28ac29ef5c52eb7e4f +size 1963620 diff --git a/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=0/part-0.parquet b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=0/part-0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..1cc8dcb3997d733f31733d2c11408e1621fb6ad3 --- /dev/null +++ b/data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet/year=2020/relative_day=0/part-0.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0efe42a553d458800c0952ba09ed0119daaa9d6ff74ec279c35dacea3bd74665 +size 1963362 diff --git a/data/canonical/raw_feature_tables/feature_manifest_natural.json b/data/canonical/raw_feature_tables/feature_manifest_natural.json new file mode 100644 index 0000000000000000000000000000000000000000..9dee90a59d8a1befb30fba62778d14c31a7adfd0 --- /dev/null +++ b/data/canonical/raw_feature_tables/feature_manifest_natural.json @@ -0,0 +1,249 @@ +{ + "access": [ + "distance_to_nearest_drivable_road_m", + "road_density_1km_km_per_km2", + "road_density_3km_km_per_km2", + "road_density_5km_km_per_km2", + "nearest_fire_station_distance_km", + "fire_station_count_10km", + "fire_station_count_20km", + "fire_station_count_50km" + ], + "daily_dynamic_tables": { + "event_weather_daily": "gridmet_daily_event_features_natural_2016_2020.parquet", + "patch_weather_daily": "event_weather_daily_patch_375m_natural_2016_2020.parquet" + }, + "default_training_note": "FPA-FOD Natural wildfire events are the sample unit. FIRMS/VIIRS features are optional D-day thermal features. Events without VIIRS detections remain in the benchmark with zero-valued VIIRS count/FRP/brightness features.", + "events_without_viirs_are_retained": true, + "fire_danger_aggregate": [ + "erc_day0", + "erc_lag1", + "bi_day0", + "bi_lag1", + "fm100_day0", + "fm100_lag1", + "fm1000_day0", + "fm1000_lag1", + "wind_dir_sin_day0", + "wind_dir_sin_lag1", + "wind_dir_cos_day0", + "wind_dir_cos_lag1", + "erc_mean2", + "erc_mean3", + "erc_mean4", + "erc_mean5", + "bi_mean2", + "bi_mean3", + "bi_mean4", + "bi_mean5", + "fm100_mean2", + "fm100_mean3", + "fm100_mean4", + "fm100_mean5", + "fm1000_mean2", + "fm1000_mean3", + "fm1000_mean4", + "fm1000_mean5", + "wind_dir_sin_mean2", + "wind_dir_sin_mean3", + "wind_dir_sin_mean4", + "wind_dir_sin_mean5", + "wind_dir_cos_mean2", + "wind_dir_cos_mean3", + "wind_dir_cos_mean4", + "wind_dir_cos_mean5" + ], + "fire_diagnostics": [ + "viirs_nearest_detection_distance_m_D", + "viirs_min_assigned_distance_m_D", + "viirs_num_assigned_detections_D", + "viirs_ambiguous_match_count_D" + ], + "fire_strict": [ + "has_viirs_detection_1km_D", + "viirs_count_500m_D", + "viirs_count_1km_D", + "viirs_sum_frp_1km_D", + "viirs_max_frp_1km_D", + "viirs_mean_frp_1km_D", + "viirs_max_bright_ti4_1km_D", + "viirs_mean_bright_ti4_1km_D", + "viirs_day_count_1km_D", + "viirs_night_count_1km_D" + ], + "fire_wide": [ + "viirs_count_3km_D", + "viirs_sum_frp_3km_D", + "viirs_max_frp_3km_D", + "viirs_mean_frp_3km_D", + "viirs_max_bright_ti4_3km_D", + "viirs_mean_bright_ti4_3km_D" + ], + "firms_viirs_role": "optional_discovery_day_thermal_feature_not_sample_filter", + "forbidden_as_features": [ + "fire_size_acres", + "fire_size_ha", + "ia_failure_label", + "contain_dt", + "containment_hours", + "log_containment_hours", + "log_fire_size_ha", + "FIRE_SIZE", + "FIRE_SIZE_CLASS", + "CONT_DATE", + "CONT_TIME", + "MTBS_ID", + "MTBS_FIRE_NAME" + ], + "fuel": [ + "fbfm40_point", + "cbd_point", + "cbh_point", + "cc_point", + "ch_point", + "fd_point", + "fvt_point", + "fvc_point", + "fvh_point", + "fbfm40_mode_1km", + "fd_mode_1km", + "fvt_mode_1km", + "fvc_mode_1km", + "fvh_mode_1km", + "cbd_mean_1km", + "cbh_mean_1km", + "cc_mean_1km", + "ch_mean_1km", + "fbfm40_mode_3km", + "fd_mode_3km", + "fvt_mode_3km", + "fvc_mode_3km", + "fvh_mode_3km", + "cbd_mean_3km", + "cbh_mean_3km", + "cc_mean_3km", + "ch_mean_3km", + "fbfm40_mode_5km", + "fd_mode_5km", + "fvt_mode_5km", + "fvc_mode_5km", + "fvh_mode_5km", + "cbd_mean_5km", + "cbh_mean_5km", + "cc_mean_5km", + "ch_mean_5km", + "cbd_max_5km", + "cbh_max_5km", + "cc_max_5km", + "ch_max_5km" + ], + "human": [ + "population_source_year", + "pop_density_point", + "pop_density_mean_1km", + "pop_density_mean_3km", + "pop_density_mean_5km", + "pop_density_max_5km" + ], + "metadata": [ + "lat", + "lon", + "state", + "county", + "discovery_month", + "discovery_doy", + "discovery_hour", + "cause_classification", + "general_cause" + ], + "patch_tables": { + "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" + }, + "topography": [ + "elev_point", + "slope_point", + "aspect_sin_point", + "aspect_cos_point", + "elev_mean_1km", + "slope_mean_1km", + "elev_mean_3km", + "slope_mean_3km", + "elev_mean_5km", + "slope_mean_5km", + "slope_max_5km" + ], + "vegetation": [ + "evt_point", + "evc_point", + "evh_point", + "evt_mode_1km", + "evc_mode_1km", + "evh_mode_1km", + "evt_mode_3km", + "evc_mode_3km", + "evh_mode_3km", + "evt_mode_5km", + "evc_mode_5km", + "evh_mode_5km" + ], + "weather_aggregate": [ + "tmmx_day0", + "tmmx_lag1", + "tmmn_day0", + "tmmn_lag1", + "pr_day0", + "rmax_day0", + "rmax_lag1", + "rmin_day0", + "rmin_lag1", + "sph_day0", + "sph_lag1", + "vpd_day0", + "vpd_lag1", + "vs_day0", + "vs_lag1", + "srad_day0", + "srad_lag1", + "tmmx_mean2", + "tmmx_mean3", + "tmmx_mean4", + "tmmx_mean5", + "tmmn_mean2", + "tmmn_mean3", + "tmmn_mean4", + "tmmn_mean5", + "pr_sum2", + "pr_sum3", + "pr_sum4", + "pr_sum5", + "rmax_mean2", + "rmax_mean3", + "rmax_mean4", + "rmax_mean5", + "rmin_mean2", + "rmin_mean3", + "rmin_mean4", + "rmin_mean5", + "sph_mean2", + "sph_mean3", + "sph_mean4", + "sph_mean5", + "vpd_mean2", + "vpd_mean3", + "vpd_mean4", + "vpd_mean5", + "vs_mean2", + "vs_mean3", + "vs_mean4", + "vs_mean5", + "srad_mean2", + "srad_mean3", + "srad_mean4", + "srad_mean5" + ] +} diff --git a/data/canonical/raw_feature_tables/fire_events_natural_2016_2020.parquet b/data/canonical/raw_feature_tables/fire_events_natural_2016_2020.parquet new file mode 100644 index 0000000000000000000000000000000000000000..3bfd9073f826e9b6d2eebbdde005f194e5d7c49f --- /dev/null +++ b/data/canonical/raw_feature_tables/fire_events_natural_2016_2020.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:869527f9f04c6bb665023e7aca2afe31c485d6e8ee189f60b71b4be10f12e2b8 +size 2088352 diff --git a/data/canonical/raw_feature_tables/gridmet_daily_event_features_natural_2016_2020.parquet b/data/canonical/raw_feature_tables/gridmet_daily_event_features_natural_2016_2020.parquet new file mode 100644 index 0000000000000000000000000000000000000000..ca169c31c07e9ad235d594929be36240b73aef5b --- /dev/null +++ b/data/canonical/raw_feature_tables/gridmet_daily_event_features_natural_2016_2020.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:717f1861c53fa0e0687d1c4c90738bf28c0151e58e9861fdda368a4697934e5b +size 4188091 diff --git a/data/canonical/raw_feature_tables/gridmet_features_natural_2016_2020.parquet b/data/canonical/raw_feature_tables/gridmet_features_natural_2016_2020.parquet new file mode 100644 index 0000000000000000000000000000000000000000..3bbb6dd87eee4154f81009faebe05167bc53d6a5 --- /dev/null +++ b/data/canonical/raw_feature_tables/gridmet_features_natural_2016_2020.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab2bff9a9b9fe477630d5cce4e22c6262169554ca849433069efc9babc2271eb +size 7569654 diff --git a/data/canonical/raw_feature_tables/label_manifest_natural.json b/data/canonical/raw_feature_tables/label_manifest_natural.json new file mode 100644 index 0000000000000000000000000000000000000000..94b7a77dfaee4f4fd51f4d269e439d66729a0ce3 --- /dev/null +++ b/data/canonical/raw_feature_tables/label_manifest_natural.json @@ -0,0 +1,41 @@ +{ + "forbidden_as_features": [ + "fire_size_acres", + "fire_size_ha", + "ia_failure_label", + "contain_dt", + "containment_hours", + "log_containment_hours", + "log_fire_size_ha", + "FIRE_SIZE", + "FIRE_SIZE_CLASS", + "CONT_DATE", + "CONT_TIME", + "MTBS_ID", + "MTBS_FIRE_NAME" + ], + "tasks": { + "burned_area_optional": { + "description": "Optional burned area target. Do not use this as an input feature for IA failure.", + "ignore_if_nan": true, + "raw_column": "fire_size_ha", + "target_column": "log_fire_size_ha", + "task_type": "regression" + }, + "containment_time": { + "description": "Remaining time to containment prediction using log1p containment hours.", + "ignore_if_nan": true, + "raw_column": "containment_hours", + "target_column": "log_containment_hours", + "task_type": "regression" + }, + "ia_failure": { + "description": "Initial attack failure prediction. 0 if fire_size_ha <= 10, 1 if fire_size_ha >= 50, NaN for 10-50 ha.", + "ignore_if_nan": true, + "negative_label": 0, + "positive_label": 1, + "target_column": "ia_failure_label", + "task_type": "binary_classification" + } + } +} diff --git a/data/canonical/raw_feature_tables/landfire_fuel_veg_features_natural_2016_2020.parquet b/data/canonical/raw_feature_tables/landfire_fuel_veg_features_natural_2016_2020.parquet new file mode 100644 index 0000000000000000000000000000000000000000..d6bfdb1f4152dde5da9f0667ead95489847b3218 --- /dev/null +++ b/data/canonical/raw_feature_tables/landfire_fuel_veg_features_natural_2016_2020.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e21b78ea29a7bb3e235aa96f47897a998dd283e8c7acb4655f11f92dadcff2e0 +size 2460578 diff --git a/data/canonical/raw_feature_tables/master_features_natural_2016_2020.parquet b/data/canonical/raw_feature_tables/master_features_natural_2016_2020.parquet new file mode 100644 index 0000000000000000000000000000000000000000..19b302f7ed2b3b82cfb93eda85b25aae5c0f98d7 --- /dev/null +++ b/data/canonical/raw_feature_tables/master_features_natural_2016_2020.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6bb504898590a0f4c1f5b87ddb73e9200466507ff7e96a2df9be050dff1e12a8 +size 15340791 diff --git a/data/canonical/raw_feature_tables/osm_access_features_natural_2016_2020.parquet b/data/canonical/raw_feature_tables/osm_access_features_natural_2016_2020.parquet new file mode 100644 index 0000000000000000000000000000000000000000..725365208f49b3e8656431865b951f8d36ba7e2d --- /dev/null +++ b/data/canonical/raw_feature_tables/osm_access_features_natural_2016_2020.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b87cd320983a70f8754175187fa53b7e092661bfcb6b668507ee87ab47b849e8 +size 1261348 diff --git a/data/canonical/raw_feature_tables/population_features_natural_2016_2020.parquet b/data/canonical/raw_feature_tables/population_features_natural_2016_2020.parquet new file mode 100644 index 0000000000000000000000000000000000000000..0d2ccd532bcd891c072ce864dee8f4fa42bbe1e8 --- /dev/null +++ b/data/canonical/raw_feature_tables/population_features_natural_2016_2020.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:437c04cbc2471a538ad2597b894092d171f1a3b1edd52ce3512b56e8f472e5b2 +size 1597827 diff --git a/data/canonical/raw_feature_tables/temporal_protocol_manifest_natural.json b/data/canonical/raw_feature_tables/temporal_protocol_manifest_natural.json new file mode 100644 index 0000000000000000000000000000000000000000..d4635bf0930464de52177078aebab0c979cbcc85 --- /dev/null +++ b/data/canonical/raw_feature_tables/temporal_protocol_manifest_natural.json @@ -0,0 +1,51 @@ +{ + "default_later_training_protocol": { + "fire_input_days": 1, + "fire_relative_days": [ + 0 + ], + "fire_signal": "VIIRS discovery day D only", + "weather_input_days": 5, + "weather_relative_days": [ + -4, + -3, + -2, + -1, + 0 + ] + }, + "important_note": "pipeline.py only saves canonical daily data. dataloader.py later selects input_days and reshapes data into model-specific caches.", + "prediction_time": "discovery day D", + "supported_later_ablation_protocols": { + "weather_1d": [ + 0 + ], + "weather_2d": [ + -1, + 0 + ], + "weather_3d": [ + -2, + -1, + 0 + ], + "weather_4d": [ + -3, + -2, + -1, + 0 + ], + "weather_5d": [ + -4, + -3, + -2, + -1, + 0 + ] + }, + "weather_daily_range": { + "description": "Daily weather is stored from D-4 to D. D is discovery day.", + "max_relative_day": 0, + "min_relative_day": -4 + } +} diff --git a/data/canonical/raw_feature_tables/topography_features_natural_2016_2020.parquet b/data/canonical/raw_feature_tables/topography_features_natural_2016_2020.parquet new file mode 100644 index 0000000000000000000000000000000000000000..572897cf10cedb9b0515481e95c530e1d8a23b84 --- /dev/null +++ b/data/canonical/raw_feature_tables/topography_features_natural_2016_2020.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b036b3dae6f80e667a70422c75fbe3170435ac0116520d4a5a2e27508f9f7309 +size 1485867 diff --git a/data/canonical/raw_feature_tables/viirs_features_natural_2016_2020.parquet b/data/canonical/raw_feature_tables/viirs_features_natural_2016_2020.parquet new file mode 100644 index 0000000000000000000000000000000000000000..f6916dbc7220985ed6a2445ad6479df9e117268c --- /dev/null +++ b/data/canonical/raw_feature_tables/viirs_features_natural_2016_2020.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d8baaaa749399fa00857b62e321b61003a00f100c2d6b572c31a220dcca56e72 +size 489315 diff --git a/metadata/cache_generation_commands.md b/metadata/cache_generation_commands.md new file mode 100644 index 0000000000000000000000000000000000000000..13fde6c383478f94c353e7880c4d34035f73d611 --- /dev/null +++ b/metadata/cache_generation_commands.md @@ -0,0 +1,39 @@ +# Cache Generation Commands + +All commands assume the current working directory is the dataset repository. + +## Task 1 Full Input + +```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 +``` + +## Task 2 Full Input + +```bash +python code/dataloader.py --base_dir . --canonical_dir data/canonical/raw_feature_tables --output_dir data/model_ready --task containment_time --representation all --weather_days 5 --input_protocol all --overwrite +``` + +## Task 1 Weather-History Ablation + +```bash +for d in 1 2 3 4 5; do + 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 ${d} --input_protocol weather --overwrite +done +``` + +## Task 1 FPA-FOD Metadata Plus One Source + +```bash +for p in metadata_vegetation metadata_fuel metadata_topography metadata_access metadata_human; do + 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 ${p} --overwrite +done +``` + +## Task 1 Leave-One-Source-Out + +```bash +for p in all_without_fire all_without_weather all_without_vegetation all_without_fuel all_without_topography all_without_access all_without_human; do + 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 ${p} --overwrite +done +``` diff --git a/metadata/file_inventory.json b/metadata/file_inventory.json new file mode 100644 index 0000000000000000000000000000000000000000..74b2dcb9598bf61d4e030bd2a91479915cfc1865 --- /dev/null +++ b/metadata/file_inventory.json @@ -0,0 +1,317 @@ +[ + { + "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" + } +] diff --git a/metadata/identity_check_summary.md b/metadata/identity_check_summary.md new file mode 100644 index 0000000000000000000000000000000000000000..a27c8a3b26639639caa309275efb8f2ad5ca9328 --- /dev/null +++ b/metadata/identity_check_summary.md @@ -0,0 +1,3 @@ +# Identity Check Summary + +No author names, affiliations, emails, or local absolute paths are intended in this release. Run the repository-level scan before uploading. diff --git a/metadata/release_manifest.json b/metadata/release_manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..647017c189960c4bfb6b8a498e6d40b5e056303b --- /dev/null +++ b/metadata/release_manifest.json @@ -0,0 +1,728 @@ +{ + "canonical_root": "data/canonical/raw_feature_tables", + "canonical_total_bytes": 2421663395, + "created_date": "2026-05-07", + "dataset": "WildfireIA anonymous release", + "file_count": 63, + "parquet_tables": { + "event_grid_375m_index_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "year", + "split", + "row", + "col", + "cell_id", + "x_5070", + "y_5070", + "lat", + "lon", + "dx_m", + "dy_m", + "distance_to_ignition_m" + ], + "path": "data/canonical/raw_feature_tables/event_grid_375m_index_natural_2016_2020.parquet", + "rows": 32065648 + }, + "event_osm_patch_375m_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "year", + "split", + "row", + "col", + "cell_id", + "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" + ], + "path": "data/canonical/raw_feature_tables/event_osm_patch_375m_natural_2016_2020.parquet", + "rows": 32065648 + }, + "event_static_patch_375m_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "year", + "split", + "row", + "col", + "cell_id", + "distance_to_ignition_m", + "fbfm40", + "cbd", + "cbh", + "cc", + "ch", + "fd", + "fvt", + "fvc", + "fvh", + "evt", + "evc", + "evh", + "elev", + "slope", + "aspect_sin", + "aspect_cos", + "population_source_year", + "pop_density" + ], + "path": "data/canonical/raw_feature_tables/event_static_patch_375m_natural_2016_2020.parquet", + "rows": 32065648 + }, + "event_viirs_patch_375m_D_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "row", + "col", + "cell_id", + "year", + "split", + "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" + ], + "path": "data/canonical/raw_feature_tables/event_viirs_patch_375m_D_natural_2016_2020.parquet", + "rows": 32065648 + }, + "event_weather_aggregate_patch_375m_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "year", + "split", + "row", + "col", + "cell_id", + "tmmx_day0", + "tmmx_lag1", + "tmmn_day0", + "tmmn_lag1", + "pr_day0", + "rmax_day0", + "rmax_lag1", + "rmin_day0", + "rmin_lag1", + "sph_day0", + "sph_lag1", + "vpd_day0", + "vpd_lag1", + "vs_day0", + "vs_lag1", + "srad_day0", + "srad_lag1", + "erc_day0", + "erc_lag1", + "bi_day0", + "bi_lag1", + "fm100_day0", + "fm100_lag1", + "fm1000_day0", + "fm1000_lag1", + "wind_dir_sin_day0", + "wind_dir_sin_lag1", + "wind_dir_cos_day0", + "wind_dir_cos_lag1", + "tmmx_mean2", + "tmmx_mean3", + "tmmx_mean4", + "tmmx_mean5", + "tmmn_mean2", + "tmmn_mean3", + "tmmn_mean4", + "tmmn_mean5", + "pr_sum2", + "pr_sum3", + "pr_sum4", + "pr_sum5", + "rmax_mean2", + "rmax_mean3", + "rmax_mean4", + "rmax_mean5", + "rmin_mean2", + "rmin_mean3", + "rmin_mean4", + "rmin_mean5", + "sph_mean2", + "sph_mean3", + "sph_mean4", + "sph_mean5", + "vpd_mean2", + "vpd_mean3", + "vpd_mean4", + "vpd_mean5", + "vs_mean2", + "vs_mean3", + "vs_mean4", + "vs_mean5", + "srad_mean2", + "srad_mean3", + "srad_mean4", + "srad_mean5", + "erc_mean2", + "erc_mean3", + "erc_mean4", + "erc_mean5", + "bi_mean2", + "bi_mean3", + "bi_mean4", + "bi_mean5", + "fm100_mean2", + "fm100_mean3", + "fm100_mean4", + "fm100_mean5", + "fm1000_mean2", + "fm1000_mean3", + "fm1000_mean4", + "fm1000_mean5", + "wind_dir_sin_mean2", + "wind_dir_sin_mean3", + "wind_dir_sin_mean4", + "wind_dir_sin_mean5", + "wind_dir_cos_mean2", + "wind_dir_cos_mean3", + "wind_dir_cos_mean4", + "wind_dir_cos_mean5" + ], + "path": "data/canonical/raw_feature_tables/event_weather_aggregate_patch_375m_natural_2016_2020.parquet", + "rows": 32065648 + }, + "event_weather_daily_patch_375m_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "year", + "split", + "row", + "col", + "cell_id", + "date", + "tmmx", + "tmmn", + "pr", + "rmax", + "rmin", + "sph", + "vpd", + "vs", + "srad", + "erc", + "bi", + "fm100", + "fm1000", + "wind_dir_sin", + "wind_dir_cos", + "relative_day" + ], + "path": "data/canonical/raw_feature_tables/event_weather_daily_patch_375m_natural_2016_2020.parquet", + "rows": 160328240 + }, + "fire_events_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "year", + "lat", + "lon", + "state", + "county", + "discovery_dt", + "discovery_date", + "discovery_month", + "discovery_doy", + "discovery_hour", + "cause_classification", + "general_cause", + "fire_size_acres", + "fire_size_ha", + "ia_failure_label", + "contain_dt", + "containment_hours", + "log_containment_hours", + "log_fire_size_ha", + "split" + ], + "path": "data/canonical/raw_feature_tables/fire_events_natural_2016_2020.parquet", + "rows": 38128 + }, + "gridmet_daily_event_features_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "date", + "relative_day", + "tmmx", + "tmmn", + "pr", + "rmax", + "rmin", + "sph", + "vpd", + "vs", + "srad", + "erc", + "bi", + "fm100", + "fm1000", + "wind_dir_sin", + "wind_dir_cos" + ], + "path": "data/canonical/raw_feature_tables/gridmet_daily_event_features_natural_2016_2020.parquet", + "rows": 190640 + }, + "gridmet_features_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "tmmx_day0", + "tmmx_lag1", + "tmmn_day0", + "tmmn_lag1", + "pr_day0", + "rmax_day0", + "rmax_lag1", + "rmin_day0", + "rmin_lag1", + "sph_day0", + "sph_lag1", + "vpd_day0", + "vpd_lag1", + "vs_day0", + "vs_lag1", + "srad_day0", + "srad_lag1", + "erc_day0", + "erc_lag1", + "bi_day0", + "bi_lag1", + "fm100_day0", + "fm100_lag1", + "fm1000_day0", + "fm1000_lag1", + "wind_dir_sin_day0", + "wind_dir_sin_lag1", + "wind_dir_cos_day0", + "wind_dir_cos_lag1", + "tmmx_mean2", + "tmmx_mean3", + "tmmx_mean4", + "tmmx_mean5", + "tmmn_mean2", + "tmmn_mean3", + "tmmn_mean4", + "tmmn_mean5", + "pr_sum2", + "pr_sum3", + "pr_sum4", + "pr_sum5", + "rmax_mean2", + "rmax_mean3", + "rmax_mean4", + "rmax_mean5", + "rmin_mean2", + "rmin_mean3", + "rmin_mean4", + "rmin_mean5", + "sph_mean2", + "sph_mean3", + "sph_mean4", + "sph_mean5", + "vpd_mean2", + "vpd_mean3", + "vpd_mean4", + "vpd_mean5", + "vs_mean2", + "vs_mean3", + "vs_mean4", + "vs_mean5", + "srad_mean2", + "srad_mean3", + "srad_mean4", + "srad_mean5", + "erc_mean2", + "erc_mean3", + "erc_mean4", + "erc_mean5", + "bi_mean2", + "bi_mean3", + "bi_mean4", + "bi_mean5", + "fm100_mean2", + "fm100_mean3", + "fm100_mean4", + "fm100_mean5", + "fm1000_mean2", + "fm1000_mean3", + "fm1000_mean4", + "fm1000_mean5", + "wind_dir_sin_mean2", + "wind_dir_sin_mean3", + "wind_dir_sin_mean4", + "wind_dir_sin_mean5", + "wind_dir_cos_mean2", + "wind_dir_cos_mean3", + "wind_dir_cos_mean4", + "wind_dir_cos_mean5" + ], + "path": "data/canonical/raw_feature_tables/gridmet_features_natural_2016_2020.parquet", + "rows": 38128 + }, + "landfire_fuel_veg_features_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "fbfm40_point", + "cbd_point", + "cbh_point", + "cc_point", + "ch_point", + "fd_point", + "fvt_point", + "fvc_point", + "fvh_point", + "evt_point", + "evc_point", + "evh_point", + "fbfm40_mode_1km", + "fd_mode_1km", + "fvt_mode_1km", + "fvc_mode_1km", + "fvh_mode_1km", + "evt_mode_1km", + "evc_mode_1km", + "evh_mode_1km", + "cbd_mean_1km", + "cbh_mean_1km", + "cc_mean_1km", + "ch_mean_1km", + "fbfm40_mode_3km", + "fd_mode_3km", + "fvt_mode_3km", + "fvc_mode_3km", + "fvh_mode_3km", + "evt_mode_3km", + "evc_mode_3km", + "evh_mode_3km", + "cbd_mean_3km", + "cbh_mean_3km", + "cc_mean_3km", + "ch_mean_3km", + "fbfm40_mode_5km", + "fd_mode_5km", + "fvt_mode_5km", + "fvc_mode_5km", + "fvh_mode_5km", + "evt_mode_5km", + "evc_mode_5km", + "evh_mode_5km", + "cbd_mean_5km", + "cbh_mean_5km", + "cc_mean_5km", + "ch_mean_5km", + "cbd_max_5km", + "cbh_max_5km", + "cc_max_5km", + "ch_max_5km" + ], + "path": "data/canonical/raw_feature_tables/landfire_fuel_veg_features_natural_2016_2020.parquet", + "rows": 38128 + }, + "master_features_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "year_x", + "lat", + "lon", + "state", + "county", + "discovery_dt", + "discovery_date", + "discovery_month", + "discovery_doy", + "discovery_hour", + "cause_classification", + "general_cause", + "fire_size_acres", + "fire_size_ha", + "ia_failure_label", + "contain_dt", + "containment_hours", + "log_containment_hours", + "log_fire_size_ha", + "split", + "has_viirs_detection_1km_D", + "viirs_count_500m_D", + "viirs_count_1km_D", + "viirs_sum_frp_1km_D", + "viirs_max_frp_1km_D", + "viirs_mean_frp_1km_D", + "viirs_max_bright_ti4_1km_D", + "viirs_mean_bright_ti4_1km_D", + "viirs_day_count_1km_D", + "viirs_night_count_1km_D", + "viirs_count_3km_D", + "viirs_sum_frp_3km_D", + "viirs_max_frp_3km_D", + "viirs_mean_frp_3km_D", + "viirs_max_bright_ti4_3km_D", + "viirs_mean_bright_ti4_3km_D", + "viirs_nearest_detection_distance_m_D", + "viirs_min_assigned_distance_m_D", + "viirs_num_assigned_detections_D", + "viirs_ambiguous_match_count_D", + "tmmx_day0", + "tmmx_lag1", + "tmmn_day0", + "tmmn_lag1", + "pr_day0", + "rmax_day0", + "rmax_lag1", + "rmin_day0", + "rmin_lag1", + "sph_day0", + "sph_lag1", + "vpd_day0", + "vpd_lag1", + "vs_day0", + "vs_lag1", + "srad_day0", + "srad_lag1", + "erc_day0", + "erc_lag1", + "bi_day0", + "bi_lag1", + "fm100_day0", + "fm100_lag1", + "fm1000_day0", + "fm1000_lag1", + "wind_dir_sin_day0", + "wind_dir_sin_lag1", + "wind_dir_cos_day0", + "wind_dir_cos_lag1", + "tmmx_mean2", + "tmmx_mean3", + "tmmx_mean4", + "tmmx_mean5", + "tmmn_mean2", + "tmmn_mean3", + "tmmn_mean4", + "tmmn_mean5", + "pr_sum2", + "pr_sum3", + "pr_sum4", + "pr_sum5", + "rmax_mean2", + "rmax_mean3", + "rmax_mean4", + "rmax_mean5", + "rmin_mean2", + "rmin_mean3", + "rmin_mean4", + "rmin_mean5", + "sph_mean2", + "sph_mean3", + "sph_mean4", + "sph_mean5", + "vpd_mean2", + "vpd_mean3", + "vpd_mean4", + "vpd_mean5", + "vs_mean2", + "vs_mean3", + "vs_mean4", + "vs_mean5", + "srad_mean2", + "srad_mean3", + "srad_mean4", + "srad_mean5", + "erc_mean2", + "erc_mean3", + "erc_mean4", + "erc_mean5", + "bi_mean2", + "bi_mean3", + "bi_mean4", + "bi_mean5", + "fm100_mean2", + "fm100_mean3", + "fm100_mean4", + "fm100_mean5", + "fm1000_mean2", + "fm1000_mean3", + "fm1000_mean4", + "fm1000_mean5", + "wind_dir_sin_mean2", + "wind_dir_sin_mean3", + "wind_dir_sin_mean4", + "wind_dir_sin_mean5", + "wind_dir_cos_mean2", + "wind_dir_cos_mean3", + "wind_dir_cos_mean4", + "wind_dir_cos_mean5", + "fbfm40_point", + "cbd_point", + "cbh_point", + "cc_point", + "ch_point", + "fd_point", + "fvt_point", + "fvc_point", + "fvh_point", + "evt_point", + "evc_point", + "evh_point", + "fbfm40_mode_1km", + "fd_mode_1km", + "fvt_mode_1km", + "fvc_mode_1km", + "fvh_mode_1km", + "evt_mode_1km", + "evc_mode_1km", + "evh_mode_1km", + "cbd_mean_1km", + "cbh_mean_1km", + "cc_mean_1km", + "ch_mean_1km", + "fbfm40_mode_3km", + "fd_mode_3km", + "fvt_mode_3km", + "fvc_mode_3km", + "fvh_mode_3km", + "evt_mode_3km", + "evc_mode_3km", + "evh_mode_3km", + "cbd_mean_3km", + "cbh_mean_3km", + "cc_mean_3km", + "ch_mean_3km", + "fbfm40_mode_5km", + "fd_mode_5km", + "fvt_mode_5km", + "fvc_mode_5km", + "fvh_mode_5km", + "evt_mode_5km", + "evc_mode_5km", + "evh_mode_5km", + "cbd_mean_5km", + "cbh_mean_5km", + "cc_mean_5km", + "ch_mean_5km", + "cbd_max_5km", + "cbh_max_5km", + "cc_max_5km", + "ch_max_5km", + "elev_point", + "slope_point", + "aspect_sin_point", + "aspect_cos_point", + "elev_mean_1km", + "slope_mean_1km", + "elev_mean_3km", + "slope_mean_3km", + "elev_mean_5km", + "slope_mean_5km", + "slope_max_5km", + "year_y", + "distance_to_nearest_drivable_road_m", + "road_density_1km_km_per_km2", + "road_density_3km_km_per_km2", + "road_density_5km_km_per_km2", + "nearest_fire_station_distance_km", + "fire_station_count_10km", + "fire_station_count_20km", + "fire_station_count_50km", + "population_source", + "population_source_year", + "pop_density_point", + "pop_density_mean_1km", + "pop_density_mean_3km", + "pop_density_mean_5km", + "pop_density_max_5km" + ], + "path": "data/canonical/raw_feature_tables/master_features_natural_2016_2020.parquet", + "rows": 38128 + }, + "osm_access_features_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "year", + "distance_to_nearest_drivable_road_m", + "road_density_1km_km_per_km2", + "road_density_3km_km_per_km2", + "road_density_5km_km_per_km2", + "nearest_fire_station_distance_km", + "fire_station_count_10km", + "fire_station_count_20km", + "fire_station_count_50km" + ], + "path": "data/canonical/raw_feature_tables/osm_access_features_natural_2016_2020.parquet", + "rows": 38128 + }, + "population_features_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "population_source", + "population_source_year", + "pop_density_point", + "pop_density_mean_1km", + "pop_density_mean_3km", + "pop_density_mean_5km", + "pop_density_max_5km" + ], + "path": "data/canonical/raw_feature_tables/population_features_natural_2016_2020.parquet", + "rows": 38128 + }, + "topography_features_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "elev_point", + "slope_point", + "aspect_sin_point", + "aspect_cos_point", + "elev_mean_1km", + "slope_mean_1km", + "elev_mean_3km", + "slope_mean_3km", + "elev_mean_5km", + "slope_mean_5km", + "slope_max_5km" + ], + "path": "data/canonical/raw_feature_tables/topography_features_natural_2016_2020.parquet", + "rows": 38128 + }, + "viirs_features_natural_2016_2020.parquet": { + "columns": [ + "fire_id", + "has_viirs_detection_1km_D", + "viirs_count_500m_D", + "viirs_count_1km_D", + "viirs_sum_frp_1km_D", + "viirs_max_frp_1km_D", + "viirs_mean_frp_1km_D", + "viirs_max_bright_ti4_1km_D", + "viirs_mean_bright_ti4_1km_D", + "viirs_day_count_1km_D", + "viirs_night_count_1km_D", + "viirs_count_3km_D", + "viirs_sum_frp_3km_D", + "viirs_max_frp_3km_D", + "viirs_mean_frp_3km_D", + "viirs_max_bright_ti4_3km_D", + "viirs_mean_bright_ti4_3km_D", + "viirs_nearest_detection_distance_m_D", + "viirs_min_assigned_distance_m_D", + "viirs_num_assigned_detections_D", + "viirs_ambiguous_match_count_D" + ], + "path": "data/canonical/raw_feature_tables/viirs_features_natural_2016_2020.parquet", + "rows": 38128 + } + }, + "release_dir": ".", + "task1_full_cache_root": null, + "task1_full_cache_total_bytes": 0, + "task1_full_caches": [] +}