Publish FireCubeNet engineering reproduction

.gitattributes

@@ -1,35 +1,12 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow 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
-*.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
+weight/* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,138 @@
+---
+license: mit
+language:
+- en
+tags:
+- OneScience
+- Earth Science
+- Wildfire Danger Prediction
+- ConvLSTM
+frameworks: PyTorch
+---
+
+<p align="center">
+  <strong><span style="font-size: 30px;">FireCubeNet</span></strong>
+</p>
+
+# Model Introduction
+
+FireCubeNet addresses next-day danger prediction for large wildfires by combining meteorological, vegetation, soil-moisture, human-activity, terrain, and land-cover conditions to identify areas at risk of severe fire. It is primarily intended to generate wildfire-danger probabilities, identify important drivers of fire ignition and spread, and support wildfire warning, risk assessment, and emergency-resource planning.
+
+Paper: Wildfire Danger Prediction and Understanding With Deep Learning  
+https://doi.org/10.1029/2022GL099368
+
+# Model Description
+
+FireCubeNet was proposed by research teams from the National Observatory of Athens, Universitat de València, Max Planck Institute for Biogeochemistry, and Universidade Nova de Lisboa. The paper trained and validated the models with ERA5-Land, MODIS, European Drought Observatory, WorldPop, Copernicus EU-DEM, CORINE Land Cover, EFFIS, and MODIS active-fire data. The model supports next-day wildfire-danger prediction, spatiotemporal fire-driver modeling, and large-wildfire risk assessment.
+
+# Use Cases
+
+| Use Case | Description |
+| :---: | :--- |
+| Next-day wildfire danger | Estimate next-day large-fire danger from ten days and a 25 km neighborhood around a center pixel. |
+| Spatiotemporal drivers | Combine weather, vegetation, wetness, socioeconomic, terrain, and land-cover variables. |
+| ModelScope/OneCode execution | Validate training, inference, evaluation, visualization, and checkpoint workflows in ModelScope or OneCode. |
+| Multi-GPU training | Run distributed data-parallel training with `torchrun`. |
+
+# Usage Instructions
+
+## 1.OneCode
+
+Experience intelligent, one-click AI4S programming through the OneCode online environment:
+
+[Try intelligent, one-click AI4S programming](https://web-2069360198568017922-iaaj.ksai.scnet.cn:58043/home)
+
+## 2. Download and Installation
+
+```bash
+hf download OneScience-Group/FireCubeNet --local-dir ./FireCubeNet
+cd FireCubeNet
+```
+
+### Environment Dependencies
+
+**Hardware Requirements**
+
+- A GPU or DCU is recommended.
+- A CPU can be used for connectivity validation with the default small-sample configuration.
+- DCU users must install DTK first. DTK 25.04.2 or later, or the OneScience-recommended version matching the cluster, is recommended.
+
+**DCU Environment**
+
+```bash
+# Activate DTK and Conda first
+conda create -n onescience311 python=3.11 -y
+conda activate onescience311
+pip install onescience[earth-dcu] -i http://mirrors.onescience.ai:3141/pypi/simple/ --trusted-host mirrors.onescience.ai
+```
+
+**GPU Environment**
+
+```bash
+# Activate Conda first
+conda create -n onescience311 python=3.11 -y libstdcxx-ng=12 libgcc-ng=12 gcc_linux-64=12 gxx_linux-64=12
+conda activate onescience311
+pip install onescience[earth-gpu] -i http://mirrors.onescience.ai:3141/pypi/simple/ --trusted-host mirrors.onescience.ai
+```
+
+### Training Data
+
+The default synthetic dataset has few samples but preserves the real `10×25×25×25` input dimensions. It includes persistent weather, progressive drying, spatial hotspots, and physically correlated variables; static fields repeat through time, and the ten land-cover fractions sum to exactly one at every pixel. Synthetic labels validate engineering connectivity only and do not represent the official data distribution or paper performance.
+
+```bash
+python scripts/fake_data.py
+```
+
+### Training
+
+For single-device training, use:
+
+```bash
+python scripts/train.py
+```
+
+For multi-GPU training, use:
+
+```bash
+torchrun --nproc_per_node=8 --nnodes=1 --rdzv_id=1000 --rdzv_backend=c10d --max_restarts=0 --master_addr="localhost" --master_port=29500 scripts/train.py
+```
+
+Training results include model parameters for inference and loss metrics for each training epoch. The results are saved to:
+
+```text
+result/checkpoints/firecubenet.pt
+result/training/metrics.json
+```
+
+### Trained Weights
+
+No trained weights are bundled under `weight/`. The paper provides no confirmed official checkpoint, and the engineering checkpoint is not claimed to be compatible with external weights.
+
+### Inference
+
+```bash
+python scripts/inference.py
+```
+
+Inference results contain next-day wildfire-danger probabilities, reference labels, and the corresponding temporal and spatial location information, and are saved to `result/output/predictions.npz`.
+
+### Evaluation and Visualization
+
+```bash
+python scripts/result.py
+```
+
+Evaluation reports Precision, Recall, F1, AUROC, and the confusion matrix in `result/evaluation/metrics.json`. It also generates the wildfire-danger probability and ROC comparison figure `result/evaluation/wildfire_danger.png`. Synthetic-data results are only for engineering-workflow validation and do not represent paper performance on the real test set.
+
+# Official OneScience Information
+
+| Platform | OneScience Main Repository | Skills Repository |
+| --- | --- | --- |
+| Gitee | https://gitee.com/onescience-ai/onescience | https://gitee.com/onescience-ai/oneskills |
+| GitHub | https://github.com/onescience-ai/OneScience | https://github.com/onescience-ai/oneskills |
+
+# Citation and License
+
+This repository is an independent engineering reproduction of the public FireCubeNet paper specifications.
+
+Use of this repository's code, official model weights, and data remains subject to the licenses and terms of their respective projects.

README_zh.md

@@ -0,0 +1,141 @@
+---
+license: mit
+language:
+- en
+- zh
+tags:
+- OneScience
+- 地球科学
+- 野火危险预测
+- ConvLSTM
+frameworks: PyTorch
+datasets:
+- Wildfire Danger Dataset
+---
+
+<p align="center">
+  <strong><span style="font-size: 30px;">FireCubeNet</span></strong>
+</p>
+
+# 模型介绍
+
+FireCubeNet 用于解决大面积野火的次日危险预测问题，综合气象、植被、土壤湿度、人类活动、地形和土地覆盖条件判断可能发生严重野火的区域。模型主要用于生成野火危险概率、识别影响火灾发生与传播的重要因素，并为野火预警、风险评估和应急资源部署提供数据驱动支持。
+
+论文：Wildfire Danger Prediction and Understanding With Deep Learning  
+https://doi.org/10.1029/2022GL099368
+
+# 模型描述
+
+FireCubeNet 由 National Observatory of Athens、Universitat de València、Max Planck Institute for Biogeochemistry 和 Universidade Nova de Lisboa 的研究团队提出。论文使用 ERA5-Land、MODIS、European Drought Observatory、WorldPop、Copernicus EU-DEM、CORINE Land Cover、EFFIS 和 MODIS active fire 数据训练与验证。模型适用于次日野火危险预测、时空火灾驱动建模和大面积野火风险评估。
+
+# 适用场景
+
+| 场景 | 说明 |
+| :---: | :--- |
+| 次日野火危险 | 从中心像素过去 10 天及其 25 km 邻域估计次日大火危险概率。 |
+| 时空驱动建模 | 联合使用天气、植被、湿度、社会经济、地形与土地覆盖变量。 |
+| ModelScope/OneCode 运行 | 在 ModelScope 或 OneCode 环境中验证训练、推理、评估、可视化和 checkpoint 流程。 |
+| 多卡训练 | 通过 `torchrun` 运行分布式数据并行训练。 |
+
+# 使用说明
+
+## 1.OneCode
+
+可通过 OneCode 在线环境体验智能化一键式 AI4S 编程：
+
+[点击体验智能化一键式 AI4S 编程](https://web-2069360198568017922-iaaj.ksai.scnet.cn:58043/home)
+
+## 2.下载安装
+
+```bash
+modelscope download --model OneScience/FireCubeNet --local_dir ./FireCubeNet
+cd FireCubeNet
+```
+
+### 环境依赖
+
+**硬件要求**
+
+- 推荐使用 GPU 或 DCU 运行。
+- CPU 可用于默认小样本配置的连通性验证。
+- DCU 用户需预先安装 DTK，建议使用 DTK 25.04.2 以上版本或与当前集群匹配的 OneScience 推荐版本。
+
+**DCU环境**
+
+```bash
+# 请首先激活DTK及CONDA
+conda create -n onescience311 python=3.11 -y
+conda activate onescience311
+pip install onescience[earth-dcu] -i http://mirrors.onescience.ai:3141/pypi/simple/ --trusted-host mirrors.onescience.ai
+```
+
+**GPU环境**
+
+```bash
+# 请首先激活CONDA
+conda create -n onescience311 python=3.11 -y libstdcxx-ng=12 libgcc-ng=12 gcc_linux-64=12 gxx_linux-64=12
+conda activate onescience311
+pip install onescience[earth-gpu] -i http://mirrors.onescience.ai:3141/pypi/simple/ --trusted-host mirrors.onescience.ai
+```
+
+### 训练数据介绍
+
+默认虚拟数据仅含少量样本，但保持 `10×25×25×25` 的真实维度。生成器包含持续天气、逐日干燥、空间热点及变量间物理相关；静态空间变量在时间上重复，10 个土地覆盖 fraction 在每个像素严格归一化为 1。虚拟标签只用于工程连通性验证，不代表官方数据分布和论文性能。
+
+```bash
+python scripts/fake_data.py
+```
+
+### 训练
+
+单卡训练可使用：
+
+```bash
+python scripts/train.py
+```
+
+多卡训练可使用：
+
+```bash
+torchrun --nproc_per_node=8 --nnodes=1 --rdzv_id=1000 --rdzv_backend=c10d --max_restarts=0 --master_addr="localhost" --master_port=29500 scripts/train.py
+```
+
+训练结果包含用于推理的模型参数，以及各训练轮次的损失指标。训练结果保存到：
+
+```text
+result/checkpoints/firecubenet.pt
+result/training/metrics.json
+```
+
+### 训练权重
+
+本仓库不在 `weight/` 内置权重。论文未提供可确认的官方 checkpoint，当前工程 checkpoint 不声明兼容外部权重。
+
+### 推理
+
+```bash
+python scripts/inference.py
+```
+
+推理结果包含次日野火危险概率、真实标签以及对应的时间和空间位置信息，并保存到 `result/output/predictions.npz`。
+
+### 评估和可视化
+
+```bash
+python scripts/result.py
+```
+
+评估结果包含 Precision、Recall、F1、AUROC 和混淆矩阵，并保存到 `result/evaluation/metrics.json`。脚本同时生成野火危险概率与 ROC 对比图 `result/evaluation/wildfire_danger.png`。虚拟数据结果仅用于验证工程流程，不代表论文真实测试集性能。
+
+# OneScience官方信息
+
+| 平台 | OneScience 主仓库 | Skills 仓库 |
+| --- | --- | --- |
+| Gitee | https://gitee.com/onescience-ai/onescience | https://gitee.com/onescience-ai/oneskills |
+| GitHub | https://github.com/onescience-ai/OneScience | https://github.com/onescience-ai/oneskills |
+
+# 引用与许可证
+
+本仓库为 FireCubeNet 论文公开规格的独立工程复现版本。
+
+本仓库代码、官方模型权重和数据的使用仍应以各自项目中的许可证及使用条��为准。

conf/config.yaml

@@ -0,0 +1,36 @@
+seed: 42
+data:
+  root: data
+  format_version: wildfire_danger_spatiotemporal_v1
+  train_samples: 12
+  test_samples: 8
+  sequence_days: 10
+  channels: 25
+  patch_height: 25
+  patch_width: 25
+  resolution_km: 1
+  input_layout: BTCHW
+  target_layout: B1
+model:
+  input_channels: 25
+  hidden_channels: 4
+  kernel_size: 3
+  dropout: 0.1
+train:
+  epochs: 2
+  batch_size: 4
+  learning_rate: 0.003
+  optimizer: Adam
+  loss: BCEWithLogitsLoss
+  weight_decay: 0.0001
+  gradient_clip_norm: 5.0
+  num_workers: 0
+runtime:
+  device: auto
+paths:
+  checkpoint: result/checkpoints/firecubenet.pt
+  training_metrics: result/training/metrics.json
+  inference_dir: result/output
+  evaluation_dir: result/evaluation
+evaluation:
+  threshold: 0.5

config.json

@@ -0,0 +1,49 @@
+{
+  "model_name": "FireCubeNet",
+  "model_type": "firecubenet",
+  "architectures": ["FireCubeNet"],
+  "framework": "PyTorch",
+  "domain": "earth-science",
+  "task": "next-day-wildfire-danger-classification",
+  "implementation": {
+    "entry_point": "model/firecubenet.py",
+    "scope": "paper-task and real-input-dimension scaled engineering reproduction",
+    "train_script": "scripts/train.py",
+    "inference_script": "scripts/inference.py",
+    "evaluation_script": "scripts/result.py",
+    "synthetic_data_script": "scripts/fake_data.py"
+  },
+  "architecture": {
+    "family": "ConvLSTM center-pixel binary classifier",
+    "input_layout": "BTCHW",
+    "input_channels": 25,
+    "sequence_days": 10,
+    "patch_height": 25,
+    "patch_width": 25,
+    "engineering_hidden_channels": 4,
+    "loss": "BCEWithLogitsLoss"
+  },
+  "data": {
+    "protocol": "wildfire_danger_spatiotemporal_v1",
+    "format": "NPZ",
+    "resolution_km": 1,
+    "sample_interval_days": 1,
+    "input_shape": ["B", 10, 25, 25, 25],
+    "target_shape": ["B", 1],
+    "channels": [
+      "maximum_2m_temperature", "maximum_wind_speed", "minimum_relative_humidity",
+      "total_precipitation", "maximum_2m_dewpoint_temperature", "maximum_surface_pressure",
+      "ndvi", "day_lst", "night_lst", "soil_moisture_index", "road_distance",
+      "waterway_distance", "population_density", "elevation", "slope",
+      "land_cover_fraction_1", "land_cover_fraction_2", "land_cover_fraction_3",
+      "land_cover_fraction_4", "land_cover_fraction_5", "land_cover_fraction_6",
+      "land_cover_fraction_7", "land_cover_fraction_8", "land_cover_fraction_9",
+      "land_cover_fraction_10"
+    ],
+    "target": "center pixel belongs to a greater-than-30-ha fire starting next day"
+  },
+  "configuration_sources": [
+    "conf/config.yaml", "model/firecubenet.py", "scripts/fake_data.py",
+    "scripts/train.py", "scripts/inference.py", "scripts/result.py"
+  ]
+}

configuration.json

@@ -0,0 +1,12 @@
+{
+  "framework": "PyTorch",
+  "task": "next-day-wildfire-danger-classification",
+  "model": "FireCubeNet",
+  "input_format": "BTCHW",
+  "protocol": "10-day 25-channel 25-km ConvLSTM center-pixel binary classification",
+  "default_config": "conf/config.yaml",
+  "training": "scripts/train.py",
+  "inference": "scripts/inference.py",
+  "evaluation": "scripts/result.py",
+  "visualization": "scripts/result.py"
+}

model/firecubenet.py

@@ -0,0 +1,57 @@
+"""ConvLSTM model for center-pixel next-day wildfire danger."""
+
+from __future__ import annotations
+
+import torch
+from torch import nn
+
+
+class ConvLSTMCell(nn.Module):
+    """Standard ConvLSTM cell with input, forget, output, and candidate gates."""
+
+    def __init__(self, input_channels: int, hidden_channels: int, kernel_size: int = 3):
+        super().__init__()
+        self.hidden_channels = int(hidden_channels)
+        padding = kernel_size // 2
+        self.gates = nn.Conv2d(
+            input_channels + hidden_channels, 4 * hidden_channels,
+            kernel_size=kernel_size, padding=padding,
+        )
+
+    def forward(self, inputs: torch.Tensor, state: tuple[torch.Tensor, torch.Tensor]):
+        hidden, cell = state
+        input_gate, forget_gate, output_gate, candidate = self.gates(
+            torch.cat((inputs, hidden), dim=1)
+        ).chunk(4, dim=1)
+        input_gate = torch.sigmoid(input_gate)
+        forget_gate = torch.sigmoid(forget_gate)
+        output_gate = torch.sigmoid(output_gate)
+        candidate = torch.tanh(candidate)
+        next_cell = forget_gate * cell + input_gate * candidate
+        next_hidden = output_gate * torch.tanh(next_cell)
+        return next_hidden, next_cell
+
+
+class FireCubeNet(nn.Module):
+    """Propagate ConvLSTM state over ten days and classify the center pixel."""
+
+    def __init__(self, input_channels: int = 25, hidden_channels: int = 4,
+                 kernel_size: int = 3, dropout: float = 0.1):
+        super().__init__()
+        self.input_channels = int(input_channels)
+        self.hidden_channels = int(hidden_channels)
+        self.cell = ConvLSTMCell(input_channels, hidden_channels, kernel_size)
+        self.head = nn.Sequential(nn.Dropout(dropout), nn.Linear(hidden_channels, 1))
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        if inputs.ndim != 5 or inputs.shape[2] != self.input_channels:
+            raise ValueError(
+                f"expected BTCHW with C={self.input_channels}, got {tuple(inputs.shape)}"
+            )
+        batch, _, _, height, width = inputs.shape
+        hidden = inputs.new_zeros(batch, self.hidden_channels, height, width)
+        cell = inputs.new_zeros(batch, self.hidden_channels, height, width)
+        for time_index in range(inputs.shape[1]):
+            hidden, cell = self.cell(inputs[:, time_index], (hidden, cell))
+        center_features = hidden[:, :, height // 2, width // 2]
+        return self.head(center_features)

scripts/fake_data.py

@@ -0,0 +1,89 @@
+"""Generate small structured wildfire sequences with physical correlations."""
+
+import argparse
+from pathlib import Path
+
+import numpy as np
+import yaml
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def make_split(path, count, config, seed, day_offset):
+    rng = np.random.default_rng(seed)
+    data_config = config["data"]
+    time = int(data_config["sequence_days"])
+    height = int(data_config["patch_height"])
+    width = int(data_config["patch_width"])
+    yy, xx = np.mgrid[:height, :width].astype(np.float32)
+    inputs = np.empty((count, time, 25, height, width), dtype=np.float32)
+    danger_scores = np.empty(count, dtype=np.float32)
+    for sample in range(count):
+        center_y = height / 2 + rng.uniform(-3, 3)
+        center_x = width / 2 + rng.uniform(-3, 3)
+        hotspot = np.exp(-((yy - center_y) ** 2 + (xx - center_x) ** 2) / (2 * rng.uniform(4, 7) ** 2))
+        elevation = np.clip(0.25 + 0.018 * yy + 0.012 * xx + rng.normal(0, 0.02, (height, width)), 0, 1)
+        slope = np.clip(np.hypot(*np.gradient(elevation)) * 15, 0, 1)
+        road = np.clip(np.abs(xx - rng.uniform(5, 20)) / 20, 0, 1)
+        water = np.clip(np.abs(yy - (height / 2 + 2 * np.sin(xx / 4))) / 18, 0, 1)
+        population = np.exp(-((xx - rng.uniform(5, 20)) ** 2 + (yy - rng.uniform(5, 20)) ** 2) / 60)
+        cover_logits = rng.normal(0, 0.8, (10, height, width))
+        cover_logits += np.stack([np.sin((xx + index) / (3 + index / 3)) for index in range(10)])
+        cover = np.exp(cover_logits - cover_logits.max(axis=0, keepdims=True))
+        cover /= cover.sum(axis=0, keepdims=True)
+        weather = rng.normal(0, 0.45)
+        for day in range(time):
+            weather = 0.82 * weather + rng.normal(0, 0.25)
+            drying = day / max(time - 1, 1)
+            spatial_noise = rng.normal(0, 0.025, (height, width))
+            temperature = 0.50 + 0.16 * weather + 0.20 * drying + 0.16 * hotspot + spatial_noise
+            wind = 0.32 + 0.12 * weather + 0.10 * hotspot + rng.normal(0, 0.035, (height, width))
+            humidity = 0.62 - 0.19 * weather - 0.20 * drying - 0.14 * hotspot + spatial_noise
+            precipitation = np.clip(0.30 - 0.13 * weather - 0.18 * drying - 0.10 * hotspot + spatial_noise, 0, 1)
+            dewpoint = 0.55 * temperature + 0.40 * humidity
+            pressure = 0.55 - 0.06 * weather + 0.02 * hotspot + spatial_noise
+            ndvi = np.clip(0.62 - 0.14 * drying - 0.08 * hotspot + 0.08 * cover[2], 0, 1)
+            day_lst = np.clip(temperature + 0.10 * hotspot, 0, 1)
+            night_lst = np.clip(temperature - 0.16 + 0.04 * hotspot, 0, 1)
+            soil_moisture = np.clip(0.58 * humidity + 0.42 * precipitation - 0.10 * drying, 0, 1)
+            dynamic = [temperature, wind, humidity, precipitation, dewpoint, pressure,
+                       ndvi, day_lst, night_lst, soil_moisture]
+            static = [road, water, population, elevation, slope, *cover]
+            inputs[sample, day] = np.stack(dynamic + static).astype(np.float32)
+        cy, cx = height // 2, width // 2
+        latest = inputs[sample, -1, :, cy, cx]
+        danger_scores[sample] = (1.7 * latest[0] + 1.1 * latest[1] - 1.5 * latest[2]
+                                 - 1.2 * latest[9] - 0.35 * latest[10]
+                                 + 0.25 * latest[12] + rng.normal(0, 0.12))
+    labels = (danger_scores >= np.median(danger_scores)).astype(np.float32)[:, None]
+    timestamps = (np.datetime64("2018-06-01") + (np.arange(count) + day_offset).astype("timedelta64[D]"))
+    timestamps = timestamps.astype("datetime64[s]").astype(np.int64)
+    latitude = rng.uniform(34.0, 43.0, count).astype(np.float32)
+    longitude = rng.uniform(19.0, 30.0, count).astype(np.float32)
+    np.savez_compressed(
+        path, inputs=inputs, labels=labels, timestamps_unix_s=timestamps,
+        coords=np.column_stack((latitude, longitude)).astype(np.float32),
+        format_version=np.asarray(data_config["format_version"]),
+        data_source=np.asarray("structured_synthetic"), input_layout=np.asarray("BTCHW"),
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--force", action="store_true")
+    args = parser.parse_args()
+    config = yaml.safe_load((ROOT / "conf/config.yaml").read_text())
+    output = ROOT / config["data"]["root"]
+    output.mkdir(parents=True, exist_ok=True)
+    splits = (("train.npz", int(config["data"]["train_samples"]), 0),
+              ("test.npz", int(config["data"]["test_samples"]), 1000))
+    for offset, (name, count, day_offset) in enumerate(splits):
+        path = output / name
+        if args.force or not path.exists():
+            make_split(path, count, config, int(config["seed"]) + offset, day_offset)
+        print(f"generated={path.relative_to(ROOT)} samples={count} shape={count},10,25,25,25")
+
+
+if __name__ == "__main__":
+    main()

scripts/inference.py

@@ -0,0 +1,49 @@
+"""Infer next-day center-pixel wildfire probabilities."""
+
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+import yaml
+from torch.utils.data import DataLoader
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+from model.firecubenet import FireCubeNet
+from train import WildfireDataset, device_from_config
+
+
+def main():
+    config = yaml.safe_load((ROOT / "conf/config.yaml").read_text())
+    device = device_from_config(config)
+    checkpoint = torch.load(ROOT / config["paths"]["checkpoint"], map_location=device, weights_only=False)
+    if checkpoint["format_version"] != config["data"]["format_version"]:
+        raise ValueError("checkpoint and data format versions differ")
+    dataset = WildfireDataset(ROOT / config["data"]["root"] / "test.npz", config)
+    loader = DataLoader(dataset, batch_size=int(config["train"]["batch_size"]), shuffle=False)
+    model = FireCubeNet(**checkpoint["model_config"]).to(device)
+    model.load_state_dict(checkpoint["model_state_dict"])
+    model.eval()
+    mean = torch.from_numpy(checkpoint["channel_mean"]).to(device).view(1, 1, -1, 1, 1)
+    std = torch.from_numpy(checkpoint["channel_std"]).to(device).view(1, 1, -1, 1, 1)
+    probabilities = []
+    with torch.no_grad():
+        for inputs, _ in loader:
+            probabilities.append(torch.sigmoid(model((inputs.to(device) - mean) / std)).cpu().numpy())
+    probabilities = np.concatenate(probabilities).astype(np.float32)
+    if probabilities.shape != dataset.data["labels"].shape or not np.isfinite(probabilities).all():
+        raise FloatingPointError("invalid inference probabilities")
+    output = ROOT / config["paths"]["inference_dir"] / "predictions.npz"
+    output.parent.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(
+        output, probabilities=probabilities, labels=dataset.data["labels"],
+        timestamps=dataset.data["timestamps_unix_s"], coords=dataset.data["coords"],
+        format_version=np.asarray(config["data"]["format_version"]),
+    )
+    print(f"predictions={output.relative_to(ROOT)} shape={probabilities.shape}")
+
+
+if __name__ == "__main__":
+    main()

scripts/result.py

@@ -0,0 +1,76 @@
+"""Evaluate binary wildfire danger predictions and create task-specific plots."""
+
+import json
+from pathlib import Path
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import yaml
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def roc_curve_and_auc(labels, probabilities):
+    order = np.argsort(-probabilities, kind="stable")
+    sorted_labels = labels[order]
+    positives = max(int(labels.sum()), 1)
+    negatives = max(int((1 - labels).sum()), 1)
+    true_positive_rate = np.r_[0.0, np.cumsum(sorted_labels) / positives, 1.0]
+    false_positive_rate = np.r_[0.0, np.cumsum(1 - sorted_labels) / negatives, 1.0]
+    return false_positive_rate, true_positive_rate, float(np.trapz(true_positive_rate, false_positive_rate))
+
+
+def main():
+    config = yaml.safe_load((ROOT / "conf/config.yaml").read_text())
+    data = np.load(ROOT / config["paths"]["inference_dir"] / "predictions.npz")
+    if str(data["format_version"]) != config["data"]["format_version"]:
+        raise ValueError("incompatible prediction format")
+    probabilities = data["probabilities"].reshape(-1)
+    labels = data["labels"].reshape(-1).astype(np.int64)
+    if probabilities.shape != labels.shape or not np.isfinite(probabilities).all() or not np.isin(labels, (0, 1)).all():
+        raise ValueError("probabilities/labels are invalid")
+    threshold = float(config["evaluation"]["threshold"])
+    predictions = (probabilities >= threshold).astype(np.int64)
+    tp = int(((predictions == 1) & (labels == 1)).sum())
+    fp = int(((predictions == 1) & (labels == 0)).sum())
+    tn = int(((predictions == 0) & (labels == 0)).sum())
+    fn = int(((predictions == 0) & (labels == 1)).sum())
+    precision = tp / (tp + fp) if tp + fp else 0.0
+    recall = tp / (tp + fn) if tp + fn else 0.0
+    f1 = 2 * precision * recall / (precision + recall) if precision + recall else 0.0
+    fpr, tpr, auroc = roc_curve_and_auc(labels, probabilities)
+    report = {
+        "samples": int(len(labels)), "threshold": threshold,
+        "precision": precision, "recall": recall, "f1": f1, "auroc": auroc,
+        "confusion_matrix": {"true_negative": tn, "false_positive": fp,
+                             "false_negative": fn, "true_positive": tp},
+        "note": "Synthetic engineering validation; not paper test-set performance."
+    }
+    if not np.isfinite([precision, recall, f1, auroc]).all():
+        raise FloatingPointError("evaluation contains non-finite metrics")
+    output = ROOT / config["paths"]["evaluation_dir"]
+    output.mkdir(parents=True, exist_ok=True)
+    (output / "metrics.json").write_text(json.dumps(report, indent=2) + "\n")
+    order = np.argsort(data["timestamps"])
+    figure, axes = plt.subplots(1, 2, figsize=(11, 4.2))
+    axes[0].plot(fpr, tpr, color="firebrick", linewidth=2, label=f"ConvLSTM (AUROC={auroc:.3f})")
+    axes[0].plot([0, 1], [0, 1], "k--", linewidth=1)
+    axes[0].set(xlabel="False positive rate", ylabel="True positive rate", title="Next-day wildfire ROC")
+    axes[0].legend()
+    colors = np.where(labels[order] == 1, "firebrick", "steelblue")
+    axes[1].scatter(np.arange(len(labels)), probabilities[order], c=colors, s=45)
+    axes[1].axhline(threshold, color="black", linestyle="--", linewidth=1, label="threshold=0.5")
+    axes[1].set(xlabel="Chronological sample", ylabel="Wildfire danger probability",
+                title="Center-pixel next-day danger", ylim=(0, 1))
+    axes[1].legend()
+    figure.tight_layout()
+    figure.savefig(output / "wildfire_danger.png", dpi=150)
+    plt.close(figure)
+    print(f"evaluation={output.relative_to(ROOT)} f1={f1:.3f} auroc={auroc:.3f}")
+
+
+if __name__ == "__main__":
+    main()

scripts/train.py

@@ -0,0 +1,130 @@
+"""Train the ConvLSTM classifier with optional distributed data parallelism."""
+
+import json
+import os
+import random
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+import yaml
+from torch.nn.parallel import DistributedDataParallel
+from torch.utils.data import DataLoader, Dataset, DistributedSampler
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+from model.firecubenet import FireCubeNet
+
+
+class WildfireDataset(Dataset):
+    def __init__(self, path, config):
+        self.data = np.load(path)
+        expected = config["data"]
+        if str(self.data["format_version"]) != expected["format_version"]:
+            raise ValueError("incompatible wildfire data format")
+        expected_shape = (int(expected["sequence_days"]), int(expected["channels"]),
+                          int(expected["patch_height"]), int(expected["patch_width"]))
+        if self.data["inputs"].ndim != 5 or self.data["inputs"].shape[1:] != expected_shape:
+            raise ValueError(f"inputs must have shape [B,{','.join(map(str, expected_shape))}]")
+        count = len(self.data["inputs"])
+        if self.data["labels"].shape != (count, 1):
+            raise ValueError("labels must have shape [B,1]")
+        if self.data["coords"].shape != (count, 2) or self.data["timestamps_unix_s"].shape != (count,):
+            raise ValueError("coords/timestamps shape mismatch")
+        if not np.isfinite(self.data["inputs"]).all() or not np.isfinite(self.data["labels"]).all():
+            raise ValueError("inputs and labels must be finite")
+        if not np.isin(self.data["labels"], (0, 1)).all():
+            raise ValueError("labels must be binary")
+        cover_sum = self.data["inputs"][:, :, 15:25].sum(axis=2)
+        if not np.allclose(cover_sum, 1.0, atol=1e-5):
+            raise ValueError("land-cover fractions must sum to one")
+
+    def __len__(self):
+        return len(self.data["labels"])
+
+    def __getitem__(self, index):
+        return (torch.from_numpy(self.data["inputs"][index]).float(),
+                torch.from_numpy(self.data["labels"][index]).float())
+
+
+def device_from_config(config, local_rank=0):
+    requested = config["runtime"]["device"]
+    if requested == "auto":
+        return torch.device("cuda", local_rank) if torch.cuda.is_available() else torch.device("cpu")
+    return torch.device(requested)
+
+
+def main():
+    config = yaml.safe_load((ROOT / "conf/config.yaml").read_text())
+    seed = int(config["seed"])
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+    distributed = int(os.environ.get("WORLD_SIZE", "1")) > 1
+    local_rank = int(os.environ.get("LOCAL_RANK", "0"))
+    if distributed:
+        torch.distributed.init_process_group("nccl" if torch.cuda.is_available() else "gloo")
+    rank = torch.distributed.get_rank() if distributed else 0
+    device = device_from_config(config, local_rank)
+    if device.type == "cuda":
+        torch.cuda.set_device(device)
+    dataset = WildfireDataset(ROOT / config["data"]["root"] / "train.npz", config)
+    sampler = DistributedSampler(dataset, shuffle=True, seed=seed) if distributed else None
+    loader = DataLoader(dataset, batch_size=int(config["train"]["batch_size"]),
+                        shuffle=sampler is None, sampler=sampler,
+                        num_workers=int(config["train"]["num_workers"]))
+    channel_mean = dataset.data["inputs"].mean(axis=(0, 1, 3, 4)).astype(np.float32)
+    channel_std = dataset.data["inputs"].std(axis=(0, 1, 3, 4)).clip(1e-6).astype(np.float32)
+    model = FireCubeNet(**config["model"]).to(device)
+    wrapped = DistributedDataParallel(model, device_ids=[local_rank] if device.type == "cuda" else None) if distributed else model
+    optimizer = torch.optim.Adam(wrapped.parameters(), lr=float(config["train"]["learning_rate"]),
+                                 weight_decay=float(config["train"]["weight_decay"]))
+    criterion = torch.nn.BCEWithLogitsLoss()
+    mean = torch.from_numpy(channel_mean).to(device).view(1, 1, -1, 1, 1)
+    std = torch.from_numpy(channel_std).to(device).view(1, 1, -1, 1, 1)
+    history = []
+    for epoch in range(int(config["train"]["epochs"])):
+        if sampler is not None:
+            sampler.set_epoch(epoch)
+        total, samples = 0.0, 0
+        wrapped.train()
+        for inputs, labels in loader:
+            inputs, labels = inputs.to(device), labels.to(device)
+            logits = wrapped((inputs - mean) / std)
+            loss = criterion(logits, labels)
+            optimizer.zero_grad(set_to_none=True)
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(wrapped.parameters(), float(config["train"]["gradient_clip_norm"]))
+            optimizer.step()
+            total += float(loss.detach()) * len(inputs)
+            samples += len(inputs)
+        loss_sum = torch.tensor([total, samples], dtype=torch.float64, device=device)
+        if distributed:
+            torch.distributed.all_reduce(loss_sum)
+        if rank == 0:
+            history.append({"epoch": epoch + 1, "bce_with_logits": float(loss_sum[0] / loss_sum[1])})
+    if rank == 0:
+        checkpoint_path = ROOT / config["paths"]["checkpoint"]
+        metrics_path = ROOT / config["paths"]["training_metrics"]
+        checkpoint_path.parent.mkdir(parents=True, exist_ok=True)
+        metrics_path.parent.mkdir(parents=True, exist_ok=True)
+        bare_model = wrapped.module if distributed else wrapped
+        torch.save({
+            "model_state_dict": bare_model.state_dict(),
+            "optimizer_state_dict": optimizer.state_dict(),
+            "model_config": config["model"], "epoch": int(config["train"]["epochs"]),
+            "channel_mean": channel_mean, "channel_std": channel_std,
+            "format_version": config["data"]["format_version"], "seed": seed,
+        }, checkpoint_path)
+        metrics_path.write_text(json.dumps({"history": history}, indent=2) + "\n")
+        print(f"checkpoint={checkpoint_path.relative_to(ROOT)} final_loss={history[-1]['bce_with_logits']:.6f}")
+    if distributed:
+        torch.distributed.destroy_process_group()
+
+
+if __name__ == "__main__":
+    main()