Publish WoFS-StormCal 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,137 @@
+---
+license: apache-2.0
+language:
+- en
+tags:
+- OneScience
+- Earth Science
+- Severe Weather
+- Probability Calibration
+frameworks: PyTorch
+---
+
+<p align="center"><strong><span style="font-size: 30px;">WoFS-StormCal</span></strong></p>
+
+# Model Introduction
+
+WoFS-StormCal addresses calibration of short-term, storm-scale severe-weather probabilities by combining storm state, surrounding environment, and object morphology from ensemble storm tracks to estimate the likelihood of tornadoes, severe hail, and severe wind. It is primarily intended to improve the reliability of ensemble guidance and support nowcasting, severe-weather risk assessment, and forecaster decision-making.
+
+Paper: Using Machine Learning to Calibrate Storm-Scale Probabilistic Guidance of Severe Weather Hazards in the Warn-on-Forecast System  
+https://arxiv.org/abs/2012.00679
+
+# Model Description
+
+WoFS-StormCal was proposed by research teams from the University of Oklahoma, the Cooperative Institute for Mesoscale Meteorological Studies, and the NOAA National Severe Storms Laboratory. The paper trained and validated the models with WoFS ensemble forecasts and local storm reports from the 2017-2019 NOAA Hazardous Weather Testbed Spring Forecasting Experiments. The model supports short-term storm-scale probabilistic forecasting and calibration for tornadoes, severe hail, and severe wind.
+
+# Use Cases
+
+| Use Case | Description |
+| :---: | :--- |
+| Storm-scale probabilistic guidance | Predict tornado, severe-hail, and severe-wind probabilities for ensemble storm-track objects. |
+| Probability calibration | Fit monotone isotonic mappings from cross-validated probabilities. |
+| Lead-group modeling | Process first-hour and second-hour 30-minute storm-track windows separately. |
+| ModelScope/OneCode execution | Validate training, inference, probabilistic evaluation, visualization, and checkpoint workflows. |
+| Multi-GPU training | Launch 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/WoFS-StormCal --local-dir ./WoFS-StormCal
+cd WoFS-StormCal
+```
+
+### 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 in advance. DTK 25.04.2 or later, or the OneScience-recommended version matching the current 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
+
+Synthetic features use storm organization, rotation, instability, shear, cold-pool, and ensemble-spread latent drivers to create within-group and cross-group correlation while preserving all 113 dimensions. The data validates feature loading, probabilistic training, calibration, inference, and evaluation only; it does not represent the real severe-weather sample 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 outputs are saved to:
+
+```text
+result/checkpoints/wofsstormcal.pt
+result/training/metrics.json
+```
+
+### Trained Weights
+
+No 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 loads the training checkpoint, produces calibrated probabilities for three hazards from 113-dimensional object features, and saves them to `result/output/predictions.npz`.
+
+### Evaluation and Visualization
+
+```bash
+python scripts/result.py
+```
+
+Evaluation reports probabilistic skill, classification skill, and reliability metrics for each hazard and lead group in `result/evaluation/metrics.json`. It also generates performance and reliability diagrams. 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 WoFS-StormCal 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,138 @@
+---
+license: Apache-2.0
+language:
+- en
+- zh
+tags:
+- OneScience
+- 地球科学
+- 强天气预报
+- 概率校准
+frameworks: PyTorch
+---
+
+<p align="center"><strong><span style="font-size: 30px;">WoFS-StormCal</span></strong></p>
+
+# 模型介绍
+
+WoFS-StormCal 用于解决短时风暴尺度强天气概率预报的校准问题，综合集合风暴轨迹中的风暴状态、周边环境和对象形态信息，判断风暴产生龙卷风、严重冰雹或严重大风的可能性。模型主要用于提高集合预报概率的可靠性，为临近预报、强天气风险研判和预报员决策提供概率指导。
+
+论文：Using Machine Learning to Calibrate Storm-Scale Probabilistic Guidance of Severe Weather Hazards in the Warn-on-Forecast System  
+https://arxiv.org/abs/2012.00679
+
+# 模型描述
+
+WoFS-StormCal 由 University of Oklahoma、Cooperative Institute for Mesoscale Meteorological Studies 和 NOAA National Severe Storms Laboratory 的研究团队提出。论文使用 2017 至 2019 年 NOAA Hazardous Weather Testbed Spring Forecasting Experiments 的 WoFS 集合预报和本地风暴报告训练与验证。模型适用于龙卷风、严重冰雹和严重大风的短时风暴尺度概率预报与校准。
+
+# 适用场景
+
+| 场景 | 说明 |
+| :---: | :--- |
+| 风暴尺度概率预报 | 根据集合风暴轨迹对象预测龙卷风、严重冰雹和严重大风概率。 |
+| 概率校准 | 使用交叉验证概率拟合单调 isotonic 映射。 |
+| 分时效建模 | 分别处理 first hour 和 second hour 的 30 分钟风暴轨迹窗口。 |
+| ModelScope/OneCode 运行 | 验证训练、推理、概率评估、可视化和 checkpoint 流程。 |
+| 多卡训练 | 通过 `torchrun` 启动分布式数据并行训练。 |
+
+# 使用说明
+
+## 1.OneCode
+
+可通过 OneCode 在线环境体验智能化一键式 AI4S 编程：
+
+[点击体验智能化一键式 AI4S 编程](https://web-2069360198568017922-iaaj.ksai.scnet.cn:58043/home)
+
+## 2.下载安装
+
+```bash
+modelscope download --model OneScience/WoFS-StormCal --local_dir ./WoFS-StormCal
+cd WoFS-StormCal
+```
+
+### 环境依赖
+
+**硬件要求**
+
+- 推荐使用 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
+```
+
+### 训练数据介绍
+
+虚拟数据使用组织度、旋转、热力不稳定度、风切变、冷池和集合离散度等潜变量构造组内及跨组相关结构，并保持真实 113 维不缩减。该数据仅用于验证特征加载、概率训练、校准、推理和评估流程，不代表真实强天气样本分布与论文性能。
+
+```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/wofsstormcal.pt
+result/training/metrics.json
+```
+
+### 训练权重
+
+本仓库不在 `weight/` 中内置权重。论文未提供可确认的官方 checkpoint，当前工程 checkpoint 不声明兼容外部权重。
+
+### 推理
+
+```bash
+python scripts/inference.py
+```
+
+推理加载训练 checkpoint，根据 113 维对象特征输出三个灾种的校准概率，并保存到 `result/output/predictions.npz`。
+
+### 评估和可视化
+
+```bash
+python scripts/result.py
+```
+
+评估结果包含各灾种和时效组的概率技巧、分类技巧与可靠性指标，并保存到 `result/evaluation/metrics.json`。脚本同时生成性能图和可靠性图。虚拟数据结果仅用于验证工程流程，不代表论文真实测试集性能。
+
+# 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 |
+
+# 引用与许可证
+
+本仓库为 WoFS-StormCal 论文公开规格的独立工程复现版本。
+
+本仓库代码、官方模型权重和数据的使用仍应以各自项目中的许可证及使用条款为准。

conf/config.yaml

@@ -0,0 +1,37 @@
+seed: 42
+data:
+  root: data
+  format_version: wofs_storm_object_113_v1
+  train_samples: 1200
+  test_samples: 500
+  input_features: 113
+  amplitude_features: 30
+  spatial_features: 76
+  object_properties: 7
+  hazards: [tornado, hail, wind]
+  lead_groups: [first_hour, second_hour]
+  ensemble_members: 18
+  grid_spacing_km: 3
+  forecast_window_minutes: 30
+  forecast_interval_minutes: 5
+model:
+  calibration_points: 256
+train:
+  epochs: 30
+  batch_size: 128
+  learning_rate: 0.03
+  l1_strength: 0.002
+  l2_strength: 0.01
+  calibration_fraction: 0.2
+  gradient_clip_norm: 5.0
+  num_workers: 0
+runtime:
+  device: auto
+paths:
+  checkpoint: result/checkpoints/wofsstormcal.pt
+  training_metrics: result/training/metrics.json
+  inference_dir: result/output
+  evaluation_dir: result/evaluation
+evaluation:
+  probability_bins: 10
+  threshold_count: 201

config.json

@@ -0,0 +1,46 @@
+{
+  "model_name": "WoFS-StormCal",
+  "model_type": "wofsstormcal",
+  "architectures": ["WoFSStormCal"],
+  "framework": "PyTorch",
+  "domain": "meteorology",
+  "task": "storm-object-multilabel-severe-hazard-probability",
+  "license": "Apache-2.0",
+  "implementation": {
+    "entry_point": "model/wofsstormcal.py",
+    "train_script": "scripts/train.py",
+    "inference_script": "scripts/inference.py",
+    "evaluation_script": "scripts/result.py",
+    "synthetic_data_script": "scripts/fake_data.py"
+  },
+  "architecture": {
+    "family": "elastic-net logistic regression with isotonic calibration",
+    "input_shape": ["N", 113],
+    "output_shape": ["N", 3],
+    "feature_groups": {"amplitude": 30, "spatial": 76, "object_property": 7},
+    "hazards": ["tornado", "hail", "wind"],
+    "lead_groups": ["first_hour", "second_hour"]
+  },
+  "paper_model": {
+    "families": ["random_forest", "xgboost", "elastic_net_logistic_regression"],
+    "probability_calibration": "isotonic regression",
+    "cross_validation_folds": 5
+  },
+  "forecast_metadata": {
+    "ensemble_members": 18,
+    "grid_spacing_km": 3,
+    "forecast_window_minutes": 30,
+    "forecast_interval_minutes": 5,
+    "first_hour_start_minutes": [0, 60],
+    "second_hour_start_minutes": [65, 120]
+  },
+  "data": {"protocol": "wofs_storm_object_113_v1", "format": "NPZ"},
+  "configuration_sources": [
+    "conf/config.yaml",
+    "model/wofsstormcal.py",
+    "scripts/fake_data.py",
+    "scripts/train.py",
+    "scripts/inference.py",
+    "scripts/result.py"
+  ]
+}

configuration.json

@@ -0,0 +1,13 @@
+{
+  "framework": "PyTorch",
+  "task": "storm-object-severe-hazard-probability-calibration",
+  "model": "WoFS-StormCal",
+  "input_format": "N113",
+  "output_format": "N3",
+  "protocol": "113-feature storm-object elastic-net probability calibration for three hazards and two lead groups",
+  "default_config": "conf/config.yaml",
+  "training": "scripts/train.py",
+  "inference": "scripts/inference.py",
+  "evaluation": "scripts/result.py",
+  "visualization": "scripts/result.py"
+}

model/wofsstormcal.py

@@ -0,0 +1,132 @@
+"""Elastic-net logistic calibration of WoFS ensemble storm-track hazards."""
+
+from __future__ import annotations
+
+import numpy as np
+import torch
+from torch import nn
+
+
+HAZARDS = ("tornado", "hail", "wind")
+LEAD_GROUPS = ("first_hour", "second_hour")
+
+
+def _pav(values: np.ndarray, targets: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """Fit an isotonic map with the pool-adjacent-violators algorithm."""
+    order = np.argsort(values, kind="stable")
+    x, y = values[order], targets[order].astype(np.float64)
+    starts, ends, sums, counts = [], [], [], []
+    for index, target in enumerate(y):
+        starts.append(index); ends.append(index); sums.append(float(target)); counts.append(1)
+        while len(sums) > 1 and sums[-2] / counts[-2] > sums[-1] / counts[-1]:
+            ends[-2] = ends[-1]
+            sums[-2] += sums[-1]
+            counts[-2] += counts[-1]
+            starts.pop(); ends.pop(); sums.pop(); counts.pop()
+    xp, yp = [], []
+    for start, end, total, count in zip(starts, ends, sums, counts):
+        level = total / count
+        xp.extend((float(x[start]), float(x[end])))
+        yp.extend((level, level))
+    xp = np.maximum.accumulate(np.asarray(xp, dtype=np.float32))
+    return xp, np.asarray(yp, dtype=np.float32)
+
+
+class WoFSStormCal(nn.Module):
+    """Two lead-group linear classifiers with portable isotonic calibration."""
+
+    input_dim = 113
+    output_dim = 3
+    hazards = HAZARDS
+    lead_groups = LEAD_GROUPS
+    ensemble_members = 18
+    grid_spacing_km = 3
+    forecast_window_minutes = 30
+    forecast_interval_minutes = 5
+
+    def __init__(self, calibration_points: int = 256):
+        super().__init__()
+        self.calibration_points = int(calibration_points)
+        self.weight = nn.Parameter(torch.empty(2, 3, self.input_dim))
+        self.bias = nn.Parameter(torch.zeros(2, 3))
+        nn.init.normal_(self.weight, std=0.01)
+        self.register_buffer("feature_mean", torch.zeros(2, self.input_dim))
+        self.register_buffer("feature_scale", torch.ones(2, self.input_dim))
+        grid = torch.linspace(0, 1, self.calibration_points)
+        self.register_buffer("calibration_x", grid.expand(2, 3, -1).clone())
+        self.register_buffer("calibration_y", grid.expand(2, 3, -1).clone())
+        self.register_buffer("calibration_length", torch.full((2, 3), self.calibration_points, dtype=torch.long))
+
+    @staticmethod
+    def validate_features(features: torch.Tensor) -> None:
+        if features.ndim != 2 or features.shape[1] != 113:
+            raise ValueError(f"features must have shape [N,113], got {tuple(features.shape)}")
+        if not torch.isfinite(features).all():
+            raise ValueError("features contain NaN or Inf")
+
+    @staticmethod
+    def validate_lead_group(lead_group: torch.Tensor, samples: int) -> None:
+        if lead_group.ndim != 1 or len(lead_group) != samples:
+            raise ValueError(f"lead_group must have shape [N], got {tuple(lead_group.shape)}")
+        if bool(((lead_group < 0) | (lead_group > 1)).any()):
+            raise ValueError("lead_group values must be 0 (first hour) or 1 (second hour)")
+
+    def set_normalization(self, mean: torch.Tensor, scale: torch.Tensor) -> None:
+        if mean.shape != (2, 113) or scale.shape != (2, 113):
+            raise ValueError("normalization statistics must both have shape [2,113]")
+        self.feature_mean.copy_(mean)
+        self.feature_scale.copy_(scale.clamp_min(1e-6))
+
+    def logits(self, features: torch.Tensor, lead_group: torch.Tensor) -> torch.Tensor:
+        self.validate_features(features)
+        lead_group = lead_group.to(device=features.device, dtype=torch.long)
+        self.validate_lead_group(lead_group, len(features))
+        normalized = (features - self.feature_mean[lead_group]) / self.feature_scale[lead_group]
+        return torch.einsum("ni,noi->no", normalized, self.weight[lead_group]) + self.bias[lead_group]
+
+    def _calibrate(self, probabilities: torch.Tensor, lead_group: torch.Tensor) -> torch.Tensor:
+        result = torch.empty_like(probabilities)
+        for group in range(2):
+            mask = lead_group == group
+            if not bool(mask.any()):
+                continue
+            for hazard in range(3):
+                length = int(self.calibration_length[group, hazard])
+                xp = self.calibration_x[group, hazard, :length]
+                yp = self.calibration_y[group, hazard, :length]
+                value = probabilities[mask, hazard].clamp(xp[0], xp[-1])
+                upper = torch.searchsorted(xp.contiguous(), value.contiguous()).clamp(1, length - 1)
+                lower = upper - 1
+                fraction = (value - xp[lower]) / (xp[upper] - xp[lower]).clamp_min(1e-7)
+                result[mask, hazard] = yp[lower] + fraction * (yp[upper] - yp[lower])
+        return result.clamp(0, 1)
+
+    def forward(self, features: torch.Tensor, lead_group: torch.Tensor, calibrated: bool = True) -> torch.Tensor:
+        probabilities = torch.sigmoid(self.logits(features, lead_group))
+        return self._calibrate(probabilities, lead_group.to(probabilities.device)) if calibrated else probabilities
+
+    @torch.no_grad()
+    def fit_calibration(self, features: torch.Tensor, targets: torch.Tensor, lead_group: torch.Tensor) -> None:
+        if targets.shape != (len(features), 3):
+            raise ValueError(f"targets must have shape [N,3], got {tuple(targets.shape)}")
+        probabilities = torch.sigmoid(self.logits(features, lead_group)).cpu().numpy()
+        target_array, groups = targets.cpu().numpy(), lead_group.cpu().numpy()
+        for group in range(2):
+            for hazard in range(3):
+                mask = groups == group
+                xp, yp = _pav(probabilities[mask, hazard], target_array[mask, hazard])
+                if len(xp) > self.calibration_points:
+                    selected = np.linspace(0, len(xp) - 1, self.calibration_points).round().astype(int)
+                    xp, yp = xp[selected], yp[selected]
+                if len(xp) == 1:
+                    xp, yp = np.repeat(xp, 2), np.repeat(yp, 2)
+                length = len(xp)
+                self.calibration_x[group, hazard, :length] = torch.from_numpy(xp).to(self.calibration_x)
+                self.calibration_y[group, hazard, :length] = torch.from_numpy(yp).to(self.calibration_y)
+                self.calibration_length[group, hazard] = length
+
+    def elastic_net_loss(self, logits: torch.Tensor, targets: torch.Tensor, l1: float, l2: float) -> torch.Tensor:
+        if logits.shape != targets.shape or logits.ndim != 2 or logits.shape[1] != 3:
+            raise ValueError("logits and targets must both have shape [N,3]")
+        bce = nn.functional.binary_cross_entropy_with_logits(logits, targets)
+        return bce + float(l1) * self.weight.abs().mean() + 0.5 * float(l2) * self.weight.square().mean()

scripts/fake_data.py

@@ -0,0 +1,86 @@
+"""Generate correlated 113-feature WoFS ensemble storm-track examples."""
+
+import argparse
+from pathlib import Path
+
+import numpy as np
+import yaml
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def correlated_block(rng, latent, count, noise, offset):
+    projection_rng = np.random.default_rng(1000 + int(offset * 100))
+    weights = projection_rng.normal(0, 0.35, (latent.shape[1], count))
+    for index in range(min(latent.shape[1], count)):
+        weights[index, index::latent.shape[1]] += 0.8
+    values = latent @ weights + rng.normal(0, noise, (len(latent), count))
+    values += 0.08 * np.sin(np.arange(count)[None, :] * 0.21 + offset)
+    return values.astype(np.float32)
+
+
+def make_split(path, samples, config, seed):
+    rng = np.random.default_rng(seed)
+    lead_start = rng.choice(np.arange(0, 125, 5), samples)
+    lead_group = (lead_start > 60).astype(np.int64)
+    organization = rng.normal(size=samples)
+    rotation = 0.65 * organization + rng.normal(0, 0.75, samples)
+    instability = rng.normal(size=samples)
+    shear = 0.35 * instability + rng.normal(0, 0.9, samples)
+    cold_pool = 0.45 * organization + rng.normal(0, 0.85, samples)
+    spread = np.maximum(0.15, rng.lognormal(-0.2 + 0.2 * lead_group, 0.35, samples))
+    latent = np.column_stack((organization, rotation, instability, shear, cold_pool, spread))
+    amplitude = correlated_block(rng, latent, 30, 0.32, 0.0)
+    spatial = correlated_block(rng, latent, 76, 0.48 + 0.08 * lead_group[:, None], 0.7)
+    area = np.exp(0.45 * organization + rng.normal(5.8, 0.35, samples))
+    eccentricity = 1 / (1 + np.exp(-(0.5 * shear + rng.normal(0, 0.6, samples))))
+    major = np.sqrt(area) * (1.2 + eccentricity)
+    minor = area / np.maximum(major, 1)
+    orientation = np.arctan2(spatial[:, 4], spatial[:, 3]) / np.pi
+    extent = np.clip(0.72 - 0.15 * spread + rng.normal(0, 0.08, samples), 0.15, 1)
+    initialization_time = rng.uniform(0, 1, samples)
+    object_properties = np.column_stack((np.log1p(area), eccentricity, orientation, major / 100,
+                                         minor / 100, extent, initialization_time)).astype(np.float32)
+    features = np.concatenate((amplitude, spatial, object_properties), axis=1).astype(np.float32)
+    risk = np.column_stack((1.25 * rotation + 0.70 * shear + 0.35 * organization,
+                            1.15 * instability + 0.55 * organization + 0.45 * amplitude[:, 5],
+                            1.00 * cold_pool + 0.65 * shear + 0.35 * spatial[:, 12]))
+    risk -= lead_group[:, None] * np.array((0.35, 0.22, 0.18))
+    # Elevated synthetic rates make the tiny engineering dataset trainable; paper rates were about 1.2/2.5/4%.
+    intercept = np.array((-2.35, -1.75, -1.45))
+    probabilities = 1 / (1 + np.exp(-(risk + intercept)))
+    targets = (rng.random((samples, 3)) < probabilities).astype(np.float32)
+    np.savez_compressed(path, features=features, targets=targets, lead_group=lead_group,
+                        lead_start_minutes=lead_start.astype(np.int16),
+                        lead_end_minutes=(lead_start + 30).astype(np.int16),
+                        format_version=np.asarray(config["data"]["format_version"]),
+                        feature_group_sizes=np.asarray((30, 76, 7), dtype=np.int16),
+                        hazards=np.asarray(config["data"]["hazards"]),
+                        lead_group_names=np.asarray(config["data"]["lead_groups"]),
+                        ensemble_members=np.asarray(18), grid_spacing_km=np.asarray(3),
+                        forecast_window_minutes=np.asarray(30), forecast_interval_minutes=np.asarray(5),
+                        data_source=np.asarray("structured_synthetic_elevated_event_rates"),
+                        paper_event_rates=np.asarray((0.012, 0.025, 0.040), dtype=np.float32))
+    return targets.mean(0)
+
+
+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)
+    for offset, (name, count) in enumerate((("train.npz", config["data"]["train_samples"]),
+                                             ("test.npz", config["data"]["test_samples"]))):
+        path = output / name
+        if args.force or not path.exists():
+            rates = make_split(path, int(count), config, int(config["seed"]) + offset)
+        else:
+            rates = np.load(path)["targets"].mean(0)
+        print(f"generated={path.relative_to(ROOT)} shape=({count},113) event_rates={rates.round(3).tolist()}")
+
+
+if __name__ == "__main__":
+    main()

scripts/inference.py

@@ -0,0 +1,49 @@
+"""Restore a checkpoint and infer calibrated tornado, hail, and wind 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.wofsstormcal import WoFSStormCal
+from train import HazardDataset, 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")
+    model = WoFSStormCal(int(config["model"]["calibration_points"])).to(device)
+    model.load_state_dict(checkpoint["model"]); model.eval()
+    dataset = HazardDataset(ROOT / config["data"]["root"] / "test.npz", config)
+    loader = DataLoader(dataset, batch_size=int(config["train"]["batch_size"]), shuffle=False)
+    predictions = []
+    with torch.no_grad():
+        for features, _, lead_group in loader:
+            prediction = model(features.to(device), lead_group.to(device))
+            if prediction.shape != (len(features), 3):
+                raise RuntimeError("model output must have shape [N,3]")
+            predictions.append(prediction.cpu().numpy())
+    predictions = np.concatenate(predictions)
+    if predictions.shape != (len(dataset), 3) or not np.isfinite(predictions).all():
+        raise FloatingPointError("inference output is invalid")
+    source = dataset.data
+    output = ROOT / config["paths"]["inference_dir"] / "predictions.npz"
+    output.parent.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(output, probabilities=predictions, targets=source["targets"],
+                        lead_group=source["lead_group"], lead_start_minutes=source["lead_start_minutes"],
+                        lead_end_minutes=source["lead_end_minutes"], hazards=source["hazards"],
+                        lead_group_names=source["lead_group_names"], format_version=source["format_version"])
+    print(f"predictions={output.relative_to(ROOT)} shape={predictions.shape} range=({predictions.min():.3f},{predictions.max():.3f})")
+
+
+if __name__ == "__main__":
+    main()

scripts/result.py

@@ -0,0 +1,116 @@
+"""Compute paper verification metrics and plot performance and reliability diagrams."""
+
+import json
+from pathlib import Path
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import yaml
+from sklearn.metrics import average_precision_score, roc_auc_score
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def curves(probability, target, threshold_count):
+    thresholds = np.linspace(0, 1, threshold_count)
+    pod, pofd, sr, far, csi, bias = [], [], [], [], [], []
+    for threshold in thresholds:
+        forecast = probability >= threshold
+        event = target == 1
+        hits = np.sum(forecast & event); false_alarms = np.sum(forecast & ~event)
+        misses = np.sum(~forecast & event); negatives = np.sum(~forecast & ~event)
+        pod.append(hits / max(hits + misses, 1)); pofd.append(false_alarms / max(false_alarms + negatives, 1))
+        sr.append(hits / max(hits + false_alarms, 1)); far.append(false_alarms / max(hits + false_alarms, 1))
+        csi.append(hits / max(hits + false_alarms + misses, 1)); bias.append((hits + false_alarms) / max(hits + misses, 1))
+    return {key: np.asarray(value) for key, value in (("threshold", thresholds), ("pod", pod), ("pofd", pofd),
+            ("sr", sr), ("far", far), ("csi", csi), ("bias", bias))}
+
+
+def reliability(probability, target, bins):
+    edges = np.linspace(0, 1, bins + 1)
+    index = np.minimum(np.digitize(probability, edges[1:-1]), bins - 1)
+    records, component = [], 0.0
+    for bin_index in range(bins):
+        mask = index == bin_index
+        if not mask.any():
+            continue
+        forecast_mean, observed_frequency = float(probability[mask].mean()), float(target[mask].mean())
+        component += mask.mean() * (forecast_mean - observed_frequency) ** 2
+        records.append({"count": int(mask.sum()), "forecast_probability": forecast_mean,
+                        "observed_frequency": observed_frequency})
+    return records, float(component)
+
+
+def metrics(probability, target, threshold_count, bins):
+    curve = curves(probability, target, threshold_count)
+    prevalence = float(target.mean())
+    auc = float(roc_auc_score(target, probability)) if 0 < target.sum() < len(target) else 0.5
+    aupdc = float(average_precision_score(target, probability)) if target.sum() else 0.0
+    positives, negatives = int(target.sum()), int(len(target) - target.sum())
+    minimum_aupdc = float(np.mean(np.arange(1, positives + 1) / (np.arange(1, positives + 1) + negatives))) if positives else 0.0
+    best = int(np.argmax(curve["csi"])); max_csi = float(curve["csi"][best])
+    brier = float(np.mean((probability - target) ** 2))
+    reference = prevalence * (1 - prevalence)
+    records, reliability_component = reliability(probability, target, bins)
+    return {"samples": len(target), "event_rate": prevalence, "auc": auc, "aupdc": aupdc,
+            "minimum_aupdc": minimum_aupdc, "naupdc": (aupdc - minimum_aupdc) / max(1 - minimum_aupdc, 1e-12),
+            "max_csi": max_csi, "ncsi": (max_csi - prevalence) / max(1 - prevalence, 1e-12),
+            "max_csi_threshold": float(curve["threshold"][best]), "pod": float(curve["pod"][best]),
+            "pofd": float(curve["pofd"][best]), "sr": float(curve["sr"][best]), "far": float(curve["far"][best]),
+            "csi": max_csi, "bias": float(curve["bias"][best]), "brier_score": brier,
+            "brier_skill_score": 1 - brier / reference if reference > 0 else 0.0,
+            "reliability_component": reliability_component, "reliability_bins": records}, curve
+
+
+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, targets, groups = data["probabilities"], data["targets"], data["lead_group"]
+    if probabilities.shape != targets.shape or probabilities.shape[1:] != (3,):
+        raise ValueError("probabilities and targets must have shape [N,3]")
+    hazards, group_names = data["hazards"].tolist(), data["lead_group_names"].tolist()
+    report, all_curves = {}, {}
+    for group_index, group_name in enumerate(group_names):
+        report[group_name] = {}
+        mask = groups == group_index
+        for hazard_index, hazard in enumerate(hazards):
+            result, curve = metrics(probabilities[mask, hazard_index], targets[mask, hazard_index],
+                                    int(config["evaluation"]["threshold_count"]), int(config["evaluation"]["probability_bins"]))
+            report[group_name][hazard] = result; all_curves[(group_name, hazard)] = curve
+    numeric = [value for group in report.values() for hazard in group.values() for value in hazard.values()
+               if isinstance(value, (int, float))]
+    if not np.isfinite(numeric).all():
+        raise FloatingPointError("evaluation contains NaN or Inf")
+    output = ROOT / config["paths"]["evaluation_dir"]
+    output.mkdir(parents=True, exist_ok=True)
+    (output / "metrics.json").write_text(json.dumps({"by_lead_group_and_hazard": report,
+        "metric_protocol": "Flora et al. AUC, weighted-average-precision AUPDC, minimum-AUPDC NAUPDC, climatology-normalized max CSI, and Brier verification"}, indent=2) + "\n")
+    colors = {"tornado": "#b3261e", "hail": "#2e7d32", "wind": "#1565c0"}
+    figure, axes = plt.subplots(1, 2, figsize=(10, 4.5), sharex=True, sharey=True)
+    for axis, group_name in zip(axes, group_names):
+        for hazard in hazards:
+            curve = all_curves[(group_name, hazard)]
+            axis.plot(curve["sr"], curve["pod"], color=colors[hazard], label=hazard)
+        axis.set(xlim=(0, 1), ylim=(0, 1), xlabel="Success ratio", ylabel="Probability of detection", title=group_name.replace("_", " ").title())
+        axis.grid(alpha=0.25); axis.legend()
+    figure.tight_layout(); figure.savefig(output / "performance.png", dpi=160); plt.close(figure)
+    figure, axes = plt.subplots(1, 2, figsize=(10, 4.5), sharex=True, sharey=True)
+    for axis, group_name in zip(axes, group_names):
+        axis.plot((0, 1), (0, 1), "k--", linewidth=1, label="perfect")
+        for hazard in hazards:
+            bins = report[group_name][hazard]["reliability_bins"]
+            axis.plot([item["forecast_probability"] for item in bins], [item["observed_frequency"] for item in bins],
+                      marker="o", color=colors[hazard], label=hazard)
+        axis.set(xlim=(0, 1), ylim=(0, 1), xlabel="Forecast probability", ylabel="Observed frequency", title=group_name.replace("_", " ").title())
+        axis.grid(alpha=0.25); axis.legend()
+    figure.tight_layout(); figure.savefig(output / "reliability.png", dpi=160); plt.close(figure)
+    print(f"evaluation={output.relative_to(ROOT)} groups={len(group_names)} hazards={len(hazards)}")
+
+
+if __name__ == "__main__":
+    main()

scripts/train.py

@@ -0,0 +1,129 @@
+"""Train, calibrate, and checkpoint WoFS elastic-net logistic models."""
+
+import argparse
+import json
+import os
+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, Subset
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+from model.wofsstormcal import WoFSStormCal
+
+
+class HazardDataset(Dataset):
+    def __init__(self, path, config):
+        self.data = np.load(path)
+        if str(self.data["format_version"]) != config["data"]["format_version"]:
+            raise ValueError("incompatible WoFS storm-object data format")
+        count = len(self.data["features"])
+        if self.data["features"].shape != (count, 113):
+            raise ValueError("features must have shape [N,113]")
+        if self.data["targets"].shape != (count, 3):
+            raise ValueError("targets must have shape [N,3]")
+        if self.data["lead_group"].shape != (count,):
+            raise ValueError("lead_group must have shape [N]")
+        if not np.isfinite(self.data["features"]).all() or not np.isfinite(self.data["targets"]).all():
+            raise ValueError("data contain NaN or Inf")
+
+    def __len__(self):
+        return len(self.data["features"])
+
+    def __getitem__(self, index):
+        return (torch.from_numpy(self.data["features"][index]).float(),
+                torch.from_numpy(self.data["targets"][index]).float(),
+                torch.as_tensor(self.data["lead_group"][index], dtype=torch.long))
+
+
+def device_from_config(config, rank=0):
+    requested = config["runtime"]["device"]
+    if requested == "auto":
+        return torch.device("cuda", rank) if torch.cuda.is_available() else torch.device("cpu")
+    return torch.device(requested)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--resume", action="store_true", help="restore model and optimizer state before training")
+    args = parser.parse_args()
+    config = yaml.safe_load((ROOT / "conf/config.yaml").read_text())
+    seed = int(config["seed"])
+    np.random.seed(seed); torch.manual_seed(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 = HazardDataset(ROOT / config["data"]["root"] / "train.npz", config)
+    split = int(len(dataset) * (1 - float(config["train"]["calibration_fraction"])))
+    fit_set = Subset(dataset, range(split))
+    sampler = DistributedSampler(fit_set, shuffle=True) if distributed else None
+    loader = DataLoader(fit_set, batch_size=int(config["train"]["batch_size"]), sampler=sampler,
+                        shuffle=sampler is None, num_workers=int(config["train"]["num_workers"]))
+    model = WoFSStormCal(int(config["model"]["calibration_points"])).to(device)
+    features = dataset.data["features"][:split]
+    groups = dataset.data["lead_group"][:split]
+    means, scales = [], []
+    for group in range(2):
+        group_features = features[groups == group]
+        means.append(group_features.mean(0)); scales.append(group_features.std(0).clip(1e-6))
+    model.set_normalization(torch.from_numpy(np.stack(means)).to(device), torch.from_numpy(np.stack(scales)).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"]))
+    checkpoint_path = ROOT / config["paths"]["checkpoint"]
+    start_epoch, history = 0, []
+    if args.resume:
+        checkpoint = torch.load(checkpoint_path, map_location=device, weights_only=False)
+        model.load_state_dict(checkpoint["model"])
+        optimizer.load_state_dict(checkpoint["optimizer"])
+        start_epoch = int(checkpoint["epoch"])
+        history = checkpoint.get("history", [])
+    for epoch in range(start_epoch, start_epoch + int(config["train"]["epochs"])):
+        if sampler is not None:
+            sampler.set_epoch(epoch)
+        total, steps = 0.0, 0
+        for batch_features, targets, lead_group in loader:
+            batch_features, targets, lead_group = batch_features.to(device), targets.to(device), lead_group.to(device)
+            active_model = wrapped.module if distributed else wrapped
+            logits = wrapped(batch_features, lead_group, False)
+            logits = torch.logit(logits.clamp(1e-6, 1 - 1e-6))
+            loss = active_model.elastic_net_loss(logits, targets, config["train"]["l1_strength"], config["train"]["l2_strength"])
+            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()); steps += 1
+        if rank == 0:
+            history.append({"epoch": epoch + 1, "elastic_net_loss": total / max(steps, 1)})
+    model = wrapped.module if distributed else wrapped
+    if rank == 0:
+        calibration_features = torch.from_numpy(dataset.data["features"][split:]).float().to(device)
+        calibration_targets = torch.from_numpy(dataset.data["targets"][split:]).float().to(device)
+        calibration_groups = torch.from_numpy(dataset.data["lead_group"][split:]).long().to(device)
+        model.fit_calibration(calibration_features, calibration_targets, calibration_groups)
+        checkpoint_path.parent.mkdir(parents=True, exist_ok=True)
+        payload = {"model": model.state_dict(), "optimizer": optimizer.state_dict(), "epoch": start_epoch + int(config["train"]["epochs"]),
+                   "history": history, "format_version": config["data"]["format_version"],
+                   "model_metadata": {"input_shape": ["N", 113], "output_shape": ["N", 3],
+                                      "hazards": model.hazards, "lead_groups": model.lead_groups,
+                                      "ensemble_members": 18, "grid_spacing_km": 3,
+                                      "forecast_window_minutes": 30, "forecast_interval_minutes": 5}}
+        torch.save(payload, checkpoint_path)
+        metrics = ROOT / config["paths"]["training_metrics"]
+        metrics.parent.mkdir(parents=True, exist_ok=True)
+        metrics.write_text(json.dumps({"history": history, "calibration_samples": len(dataset) - split}, indent=2) + "\n")
+        print(f"checkpoint={checkpoint_path.relative_to(ROOT)} output_shape=(N,3) epoch={payload['epoch']}")
+    if distributed:
+        torch.distributed.destroy_process_group()
+
+
+if __name__ == "__main__":
+    main()