Publish ClimateBench 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,139 @@
+---
+license: apache-2.0
+language:
+- en
+tags:
+- OneScience
+- Earth Science
+- Climate Emulation
+- CNN-LSTM
+frameworks: PyTorch
+---
+
+<p align="center">
+  <strong><span style="font-size: 30px;">ClimateBench CNN-LSTM</span></strong>
+</p>
+
+# Model Introduction
+
+The ClimateBench CNN-LSTM addresses the high computational cost of Earth system models and the difficulty of rapidly comparing many emission scenarios by estimating global temperature, diurnal-temperature-range, and precipitation responses from greenhouse-gas and aerosol emissions. It is primarily intended for data-driven climate projection, rapid emission-scenario assessment, and standardized comparison of climate-emulation methods, providing an efficient baseline for climate-response research.
+
+Paper: ClimateBench v1.0: A Benchmark for Data-Driven Climate Projections  
+https://doi.org/10.1029/2021MS002954
+
+# Model Description
+
+ClimateBench was proposed by a University of Oxford-led research team with institutions including North Carolina State University, the Norwegian Meteorological Institute, the University of East Anglia, and Universitat de València. The paper trained and validated baseline models with anthropogenic forcing and climate-response data from NorESM2-LM experiments in CMIP6, ScenarioMIP, AerChemMIP, and DAMIP. The model supports globally resolved climate-response emulation, data-driven climate projection, and SSP scenario evaluation.
+
+# Use Cases
+
+| Use Case | Description |
+| :---: | :--- |
+| Climate response emulation | Predict four global response fields from a ten-year forcing sequence. |
+| Architecture reproduction | Verify the exact CNN, pooling, ReLU-LSTM, and dense parameterization. |
+| SSP245 evaluation | Evaluate ClimateBench NRMSE with 2080-2100 target semantics. |
+| ModelScope/OneCode execution | Validate training, inference, evaluation, visualization, and checkpoint workflows in ModelScope or OneCode. |
+| Multi-device training | Train all independent branches with `torchrun` and DDP. |
+
+# 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/ClimateBench --local-dir ./ClimateBench
+cd ClimateBench
+```
+
+### 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
+
+This repository uses a small number of structured synthetic samples to validate the engineering workflow. Inputs contain annual sequences of cumulative CO2, CH4, SO2, and black-carbon emissions, while the targets are the corresponding global temperature, diurnal-temperature-range, and precipitation responses. The data preserves the paper's temporal, channel, and global-grid dimensions with plausible temporal and spatial climate structure; it does not represent the official data distribution or paper performance.
+
+```bash
+python scripts/fake_data.py --force
+```
+
+### 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/climatebench.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 writes `result/output/predictions.npz` with all four predictions, targets, coordinates, scenario, and 2080-2100 evaluation semantics.
+
+### Evaluation and Visualization
+
+```bash
+python scripts/result.py
+```
+
+Evaluation computes spatial error, global-mean error, and combined NRMSE for all four climate variables and saves them to `result/evaluation/metrics.json`. It also generates the target, prediction, and error comparison figure `result/evaluation/four_targets.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 ClimateBench 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,142 @@
+---
+license: Apache-2.0
+language:
+- en
+- zh
+tags:
+- OneScience
+- 地球科学
+- 气候模拟
+- CNN-LSTM
+frameworks: PyTorch
+datasets:
+- ClimateBench
+---
+
+<p align="center">
+  <strong><span style="font-size: 30px;">ClimateBench CNN-LSTM</span></strong>
+</p>
+
+# 模型介绍
+
+ClimateBench CNN-LSTM 用于解决地球系统模式计算成本高、难以快速比较大量排放情景的问题，根据温室气体和气溶胶排放估计全球气温、昼夜温差和降水响应。模型主要用于数据驱动气候投影、不同排放情景的快速评估以及气候模拟方法的标准化比较，为研究气候变化响应提供高效基线。
+
+论文：ClimateBench v1.0: A Benchmark for Data-Driven Climate Projections  
+https://doi.org/10.1029/2021MS002954
+
+# 模型描述
+
+ClimateBench 由 University of Oxford 牵头，联合 North Carolina State University、Norwegian Meteorological Institute、University of East Anglia、Universitat de València 等机构的研究团队提出。论文使用 CMIP6、ScenarioMIP、AerChemMIP 和 DAMIP 中 NorESM2-LM 的人为强迫与气候响应数据训练和验证基线模型。模型适用于全球空间气候响应模拟、数据驱动气候投影和 SSP 情景评估。
+
+# 适用场景
+
+| 场景 | 说明 |
+| :---: | :--- |
+| 气候响应模拟 | 从 10 年人为强迫序列预测四类全球空间响应。 |
+| 架构复现 | 验证论文 CNN、池化、ReLU LSTM 和稠密输出的精确参数化。 |
+| SSP245 评估 | 按 2080-2100 目标语义计算 ClimateBench NRMSE。 |
+| ModelScope/OneCode 运行 | 在 ModelScope 或 OneCode 环境中验证训练、推理、评估、可视化和 checkpoint 流程。 |
+| 多卡训练 | 使用 `torchrun` 和 DDP 训练四个独立分支。 |
+
+# 使用说明
+
+## 1.OneCode
+
+可通过 OneCode 在线环境体验智能化一键式 AI4S 编程：
+
+[点击体验智能化一键式 AI4S 编程](https://web-2069360198568017922-iaaj.ksai.scnet.cn:58043/home)
+
+## 2.下载安装
+
+```bash
+modelscope download --model OneScience/ClimateBench --local_dir ./ClimateBench
+cd ClimateBench
+```
+
+### 环境依赖
+
+**硬件要求**
+
+- 推荐使用 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
+```
+
+### 训练数据介绍
+
+本仓库使用少量结构化虚拟样本验证工程流程，输入包含连续年度的累积 CO2、CH4、SO2 和黑碳排放，目标为相应的全球气温、昼夜温差及降水响应。虚拟数据保留论文的时间、通道和全球网格维度，并包含合理的时间变化与空间气候结构，仅用于验证模型训练、推理和评估流程，不代表官方数据分布与论文性能。
+
+```bash
+python scripts/fake_data.py --force
+```
+
+### 训练
+
+单卡训练可使用：
+
+```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/climatebench.pt
+result/training/metrics.json
+```
+
+### 训练权重
+
+本仓库不在 `weight/` 中内置权重。论文未提供可确认的官方 checkpoint，当前工程 checkpoint 不声明兼容外部权重。
+
+### 推理
+
+```bash
+python scripts/inference.py
+```
+
+推理输出 `result/output/predictions.npz`，保留四目标预测、真实目标、坐标、场景和 2080-2100 评估语义。
+
+### 评估和可视化
+
+```bash
+python scripts/result.py
+```
+
+评估计算四个气候变量的空间误差、全球平均误差和综合 NRMSE，并保存到 `result/evaluation/metrics.json`。脚本同时生成目标、预测和误差对比图 `result/evaluation/four_targets.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 |
+
+# 引用与许可证
+
+本仓库为 ClimateBench 论文公开规格的独立工程复现版本。
+
+本仓库代码、官方模型权重和数据的使用仍应以各自项目中��许可证及使用条款为准。

conf/config.yaml

@@ -0,0 +1,46 @@
+seed: 42
+data:
+  root: data
+  format_version: climatebench_annual_npz_v1
+  train_samples: 2
+  test_samples: 1
+  time_steps: 10
+  channels: [co2_cumulative, ch4, so2, bc]
+  targets: [tas, dtr, pr, pr90]
+  height: 96
+  width: 144
+  storage_layout: NTCHW
+  paper_layout: NTHWC
+model:
+  convolution_filters: 20
+  convolution_kernel: 3
+  pooling_kernel: 2
+  lstm_input: 20
+  lstm_hidden: 25
+  output_features: 13824
+  parameters_per_target: 364764
+paper_training:
+  epochs: 30
+  batch_size: 16
+  optimizer: RMSprop
+  loss: mean_squared_error
+train:
+  epochs: 1
+  batch_size: 1
+  learning_rate: 0.001
+  optimizer: RMSprop
+  loss: mean_squared_error
+  gradient_clip_norm: 10.0
+  num_workers: 0
+runtime:
+  device: auto
+paths:
+  checkpoint: result/checkpoints/climatebench.pt
+  training_metrics: result/training/metrics.json
+  inference: result/output/predictions.npz
+  evaluation_dir: result/evaluation
+evaluation:
+  start_year: 2080
+  end_year: 2100
+  global_weight: 5.0
+  scenario: ssp245

config.json

@@ -0,0 +1,40 @@
+{
+  "model_name": "ClimateBench",
+  "model_type": "climatebench",
+  "architectures": ["ClimateBench", "ClimateBenchBranch"],
+  "framework": "PyTorch",
+  "domain": "climate-emulation",
+  "task": "annual-spatial-climate-response-emulation",
+  "license": "Apache-2.0",
+  "implementation": {
+    "entry_point": "model/climatebench.py",
+    "train_script": "scripts/train.py",
+    "inference_script": "scripts/inference.py",
+    "evaluation_script": "scripts/result.py",
+    "synthetic_data_script": "scripts/fake_data.py"
+  },
+  "architecture": {
+    "per_target": "TimeDistributed Conv2d(4,20,3,same)+ReLU+AvgPool2d(2)+global spatial average+ReLU-LSTM(20,25)+Dense(25,13824)",
+    "parameters_per_target": 364764,
+    "targets": ["tas", "dtr", "pr", "pr90"],
+    "independent_branches": 4
+  },
+  "data": {
+    "format": "NPZ",
+    "stored_input_layout": "NTCHW",
+    "paper_input_layout": "NTHWC",
+    "recommended_input_shape": ["B", 10, 4, 96, 144],
+    "output_shape": ["B", 4, 96, 144],
+    "channels": ["co2_cumulative", "ch4", "so2", "bc"],
+    "temporal_resolution": "annual",
+    "protocol": "climatebench_annual_npz_v1"
+  },
+  "configuration_sources": [
+    "conf/config.yaml",
+    "model/climatebench.py",
+    "scripts/fake_data.py",
+    "scripts/train.py",
+    "scripts/inference.py",
+    "scripts/result.py"
+  ]
+}

configuration.json

@@ -0,0 +1,12 @@
+{
+  "framework": "PyTorch",
+  "task": "annual-spatial-climate-response-emulation",
+  "model": "ClimateBench",
+  "input_format": "NTCHW",
+  "protocol": "four independent paper-faithful CNN-LSTM target emulators",
+  "default_config": "conf/config.yaml",
+  "training": "scripts/train.py",
+  "inference": "scripts/inference.py",
+  "evaluation": "scripts/result.py",
+  "visualization": "scripts/result.py"
+}

model/climatebench.py

@@ -0,0 +1,90 @@
+"""Paper-faithful PyTorch CNN-LSTM baseline for ClimateBench."""
+
+from __future__ import annotations
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+
+TARGETS = ("tas", "dtr", "pr", "pr90")
+
+
+class ReLULSTM(nn.Module):
+    """Keras-compatible LSTM using sigmoid gates and ReLU activation."""
+
+    def __init__(self, input_size: int = 20, hidden_size: int = 25):
+        super().__init__()
+        self.input_size = int(input_size)
+        self.hidden_size = int(hidden_size)
+        self.kernel = nn.Parameter(torch.empty(input_size, 4 * hidden_size))
+        self.recurrent_kernel = nn.Parameter(torch.empty(hidden_size, 4 * hidden_size))
+        self.bias = nn.Parameter(torch.zeros(4 * hidden_size))
+        self.reset_parameters()
+
+    def reset_parameters(self) -> None:
+        nn.init.xavier_uniform_(self.kernel)
+        nn.init.orthogonal_(self.recurrent_kernel)
+        nn.init.zeros_(self.bias)
+        with torch.no_grad():
+            self.bias[self.hidden_size:2 * self.hidden_size].fill_(1.0)
+
+    def forward(self, sequence: torch.Tensor) -> torch.Tensor:
+        if sequence.ndim != 3 or sequence.shape[-1] != self.input_size:
+            raise ValueError(f"expected [B,T,{self.input_size}], got {tuple(sequence.shape)}")
+        batch = sequence.shape[0]
+        hidden = sequence.new_zeros(batch, self.hidden_size)
+        cell = sequence.new_zeros(batch, self.hidden_size)
+        for step in range(sequence.shape[1]):
+            gates = sequence[:, step] @ self.kernel + hidden @ self.recurrent_kernel + self.bias
+            input_gate, forget_gate, candidate, output_gate = gates.chunk(4, dim=-1)
+            input_gate = torch.sigmoid(input_gate)
+            forget_gate = torch.sigmoid(forget_gate)
+            candidate = F.relu(candidate)
+            output_gate = torch.sigmoid(output_gate)
+            cell = forget_gate * cell + input_gate * candidate
+            hidden = output_gate * F.relu(cell)
+        return hidden
+
+
+class ClimateBenchBranch(nn.Module):
+    """One 364,764-parameter paper CNN-LSTM target emulator."""
+
+    PAPER_PARAMETER_COUNT = 364_764
+
+    def __init__(self, height: int = 96, width: int = 144):
+        super().__init__()
+        self.height = int(height)
+        self.width = int(width)
+        self.conv = nn.Conv2d(4, 20, kernel_size=3, padding="same")
+        self.pool = nn.AvgPool2d(kernel_size=2)
+        self.lstm = ReLULSTM(20, 25)
+        self.dense = nn.Linear(25, height * width)
+        count = sum(parameter.numel() for parameter in self.parameters())
+        if count != self.PAPER_PARAMETER_COUNT:
+            raise RuntimeError(f"paper branch must have 364764 parameters, got {count}")
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        if inputs.ndim != 5 or inputs.shape[2:] != (4, self.height, self.width):
+            raise ValueError(f"expected [B,T,4,{self.height},{self.width}], got {tuple(inputs.shape)}")
+        batch, time = inputs.shape[:2]
+        features = F.relu(self.conv(inputs.reshape(batch * time, 4, self.height, self.width)))
+        features = self.pool(features).mean(dim=(-2, -1)).reshape(batch, time, 20)
+        return self.dense(self.lstm(features)).reshape(batch, 1, self.height, self.width)
+
+
+class ClimateBench(nn.Module):
+    """Four independent paper branches ordered as tas, dtr, pr and pr90."""
+
+    def __init__(self, height: int = 96, width: int = 144):
+        super().__init__()
+        self.height = int(height)
+        self.width = int(width)
+        self.branches = nn.ModuleDict({name: ClimateBenchBranch(height, width) for name in TARGETS})
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        return torch.cat([self.branches[name](inputs) for name in TARGETS], dim=1)
+
+    def parameter_counts(self) -> dict[str, int]:
+        return {name: sum(parameter.numel() for parameter in branch.parameters())
+                for name, branch in self.branches.items()}

scripts/fake_data.py

@@ -0,0 +1,81 @@
+"""Generate structured annual forcing windows and climate responses."""
+
+import argparse
+from pathlib import Path
+
+import numpy as np
+import yaml
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def make_split(path: Path, count: int, config: dict, seed: int, test: bool) -> None:
+    rng = np.random.default_rng(seed)
+    data = config["data"]
+    time, height, width = int(data["time_steps"]), int(data["height"]), int(data["width"])
+    lat = np.linspace(-90, 90, height, dtype=np.float32)
+    lon = np.linspace(0, 360, width, endpoint=False, dtype=np.float32)
+    lat2d, lon2d = np.meshgrid(lat, lon, indexing="ij")
+    windows, responses, years = [], [], []
+    for sample in range(count):
+        end_year = 2100 if test else 2060 + 10 * sample
+        annual_years = np.arange(end_year - time + 1, end_year + 1, dtype=np.int32)
+        progress = (annual_years - 1850).astype(np.float32)
+        co2 = 0.90 * progress + 0.0018 * progress ** 2
+        ch4 = 0.42 * progress + 12.0 * np.sin(progress / 38.0)
+        industrial = np.exp(-((lat2d - 35) / 22) ** 2) * (0.65 + 0.35 * np.cos(np.deg2rad(lon2d - 90)))
+        tropical = np.exp(-(lat2d / 20) ** 2) * (0.65 + 0.35 * np.sin(np.deg2rad(2 * lon2d)))
+        forcing = np.empty((time, 4, height, width), dtype=np.float32)
+        for index, year_progress in enumerate(progress):
+            forcing[index, 0] = co2[index]
+            forcing[index, 1] = ch4[index]
+            forcing[index, 2] = industrial * (32.0 * np.exp(-((year_progress - 125) / 75) ** 2))
+            forcing[index, 3] = tropical * (5.0 + 2.0 * np.sin(year_progress / 27.0))
+        forcing += rng.normal(0, 0.01, forcing.shape).astype(np.float32)
+        co2_level = forcing[-1, 0].mean() / 300.0
+        methane = forcing[-3:, 1].mean() / 120.0
+        aerosol = forcing[-3:, 2:].mean(axis=(0, 1)) / 25.0
+        arctic = 1.0 + 1.3 * (np.abs(lat2d) / 90.0) ** 2
+        land_pattern = np.cos(np.deg2rad(2 * lon2d)) * np.cos(np.deg2rad(lat2d))
+        itcz = np.sin(np.deg2rad(lon2d)) * np.exp(-(lat2d / 17) ** 2)
+        tas = 1.35 * co2_level * arctic + 0.22 * methane - 0.30 * aerosol + 0.05 * land_pattern
+        dtr = 0.10 * co2_level + 0.23 * aerosol * land_pattern - 0.04 * methane
+        pr = 0.16 * co2_level * np.cos(np.deg2rad(lat2d)) + 0.20 * itcz - 0.07 * aerosol
+        pr90 = 1.35 * pr + 0.08 * co2_level * np.exp(-(lat2d / 28) ** 2)
+        response = np.stack([tas, dtr, pr, pr90]).astype(np.float32)
+        response += rng.normal(0, 0.003, response.shape).astype(np.float32)
+        windows.append(forcing)
+        responses.append(response)
+        years.append(annual_years)
+    evaluation = config["evaluation"]
+    np.savez_compressed(
+        path, inputs=np.stack(windows).astype(np.float32), targets=np.stack(responses).astype(np.float32),
+        years=np.stack(years), latitude=lat, longitude=lon,
+        channel_names=np.asarray(data["channels"]), target_names=np.asarray(data["targets"]),
+        format_version=np.asarray(data["format_version"]), storage_layout=np.asarray("NTCHW"),
+        temporal_resolution=np.asarray("annual"), data_source=np.asarray("structured_synthetic"),
+        scenario=np.asarray(evaluation["scenario"] if test else "synthetic_training_scenarios"),
+        target_aggregation=np.asarray("2080-2100 climatological mean" if test else "annual response"),
+        evaluation_start_year=np.asarray(evaluation["start_year"], dtype=np.int32),
+        evaluation_end_year=np.asarray(evaluation["end_year"], dtype=np.int32),
+    )
+
+
+def main() -> None:
+    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, test) in enumerate((("train.npz", config["data"]["train_samples"], False),
+                                                  ("test.npz", config["data"]["test_samples"], True))):
+        path = output / name
+        if args.force or not path.exists():
+            make_split(path, int(count), config, int(config["seed"]) + offset, test)
+        print(f"generated={path.relative_to(ROOT)} samples={count} layout=NTCHW annual=true")
+
+
+if __name__ == "__main__":
+    main()

scripts/inference.py

@@ -0,0 +1,50 @@
+"""Run the four ClimateBench emulators on the held-out scenario."""
+
+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.climatebench import ClimateBench
+from train import ClimateDataset, device_from_config
+
+
+def main() -> None:
+    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 = ClimateBench(**checkpoint["model_config"]).to(device)
+    model.load_state_dict(checkpoint["model"])
+    model.eval()
+    dataset = ClimateDataset(ROOT / config["data"]["root"] / "test.npz", config)
+    loader = DataLoader(dataset, batch_size=1, shuffle=False)
+    predictions = []
+    with torch.no_grad():
+        for inputs, _ in loader:
+            predictions.append(model(inputs.to(device)).cpu().numpy())
+    prediction = np.concatenate(predictions).astype(np.float32)
+    if not np.isfinite(prediction).all():
+        raise FloatingPointError("inference produced NaN or Inf")
+    source = dataset.data
+    output = ROOT / config["paths"]["inference"]
+    output.parent.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(output, predictions=prediction, targets=source["targets"], years=source["years"],
+                        latitude=source["latitude"], longitude=source["longitude"],
+                        target_names=source["target_names"], scenario=source["scenario"],
+                        target_aggregation=source["target_aggregation"], storage_layout=np.asarray("NCHW"),
+                        format_version=source["format_version"],
+                        evaluation_start_year=source["evaluation_start_year"],
+                        evaluation_end_year=source["evaluation_end_year"])
+    print(f"predictions={output.relative_to(ROOT)} shape={prediction.shape} test_batches={len(predictions)}")
+
+
+if __name__ == "__main__":
+    main()

scripts/result.py

@@ -0,0 +1,75 @@
+"""Compute ClimateBench spatial/global NRMSE and plot all four targets."""
+
+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 area_mean(field: np.ndarray, latitude: np.ndarray) -> np.ndarray:
+    weights = np.cos(np.deg2rad(latitude)).clip(0)[:, None]
+    return np.sum(field * weights, axis=(-2, -1)) / (weights.sum() * field.shape[-1])
+
+
+def climatebench_metrics(prediction: np.ndarray, target: np.ndarray, latitude: np.ndarray, alpha: float) -> dict:
+    normalization = float(area_mean(target, latitude).mean())
+    if abs(normalization) <= 1e-12:
+        raise ValueError("area-weighted target mean must be nonzero for NRMSE normalization")
+    temporal_rmse = np.sqrt(np.mean((prediction - target) ** 2, axis=0))
+    spatial = float(area_mean(temporal_rmse, latitude) / normalization)
+    predicted_global = area_mean(prediction, latitude)
+    target_global = area_mean(target, latitude)
+    global_nrmse = float(np.sqrt(np.mean((predicted_global - target_global) ** 2)) / normalization)
+    return {"spatial_nrmse": spatial, "global_nrmse": global_nrmse,
+            "total_nrmse": spatial + alpha * global_nrmse}
+
+
+def main() -> None:
+    config = yaml.safe_load((ROOT / "conf/config.yaml").read_text())
+    data = np.load(ROOT / config["paths"]["inference"])
+    if str(data["format_version"]) != config["data"]["format_version"]:
+        raise ValueError("incompatible prediction format")
+    start, end = int(data["evaluation_start_year"]), int(data["evaluation_end_year"])
+    if (start, end) != (int(config["evaluation"]["start_year"]), int(config["evaluation"]["end_year"])):
+        raise ValueError("evaluation period metadata must be 2080-2100")
+    names = data["target_names"].tolist()
+    alpha = float(config["evaluation"]["global_weight"])
+    metrics = {name: climatebench_metrics(data["predictions"][:, index], data["targets"][:, index],
+                                           data["latitude"], alpha) for index, name in enumerate(names)}
+    report = {"variables": metrics, "mean_total_nrmse": float(np.mean([value["total_nrmse"] for value in metrics.values()])),
+              "evaluation_protocol": {"scenario": str(data["scenario"]), "period": f"{start}-{end}",
+                                      "target_aggregation": str(data["target_aggregation"]),
+                                      "spatial_metric": "cosine-area mean of grid-cell temporal RMSE",
+                                      "global_weighting": "cosine latitude cell area",
+                                      "total": "spatial_nrmse + 5 * global_nrmse",
+                                      "normalization": "cosine-area and sample mean of target field"}}
+    numeric = [number for values in metrics.values() for number in values.values()]
+    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(report, indent=2) + "\n")
+    figure, axes = plt.subplots(4, 3, figsize=(12, 12), constrained_layout=True)
+    longitude, latitude = data["longitude"], data["latitude"]
+    for index, name in enumerate(names):
+        fields = (data["targets"][:, index].mean(0), data["predictions"][:, index].mean(0),
+                  (data["predictions"][:, index] - data["targets"][:, index]).mean(0))
+        for column, (field, title) in enumerate(zip(fields, ("Target", "Prediction", "Error"))):
+            image = axes[index, column].pcolormesh(longitude, latitude, field, shading="auto", cmap="coolwarm")
+            axes[index, column].set(title=f"{name}: {title}", xlabel="Longitude", ylabel="Latitude")
+            figure.colorbar(image, ax=axes[index, column], shrink=0.75)
+    figure.suptitle(f"ClimateBench {str(data['scenario'])} {start}-{end}")
+    figure.savefig(output / "four_targets.png", dpi=150)
+    plt.close(figure)
+    print(f"evaluation={output.relative_to(ROOT)} variables={','.join(names)}")
+
+
+if __name__ == "__main__":
+    main()

scripts/train.py

@@ -0,0 +1,103 @@
+"""Train four independent paper CNN-LSTM branches with RMSprop and MSE."""
+
+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
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+from model.climatebench import ClimateBench, ClimateBenchBranch, TARGETS
+
+
+class ClimateDataset(Dataset):
+    def __init__(self, path: Path, config: dict):
+        self.data = np.load(path)
+        expected = config["data"]
+        shape = (int(expected["time_steps"]), 4, int(expected["height"]), int(expected["width"]))
+        target_shape = (4, int(expected["height"]), int(expected["width"]))
+        if str(self.data["format_version"]) != expected["format_version"] or str(self.data["storage_layout"]) != "NTCHW":
+            raise ValueError("incompatible ClimateBench NPZ format or storage layout")
+        if self.data["inputs"].shape[1:] != shape or self.data["targets"].shape[1:] != target_shape:
+            raise ValueError(f"expected inputs [N,{shape}] and targets [N,{target_shape}]")
+        if self.data["inputs"].dtype != np.float32 or self.data["targets"].dtype != np.float32:
+            raise TypeError("inputs and targets must be float32")
+        if tuple(self.data["channel_names"].tolist()) != tuple(expected["channels"]):
+            raise ValueError("forcing channels must be [co2_cumulative,ch4,so2,bc]")
+
+    def __len__(self) -> int:
+        return len(self.data["inputs"])
+
+    def __getitem__(self, index: int):
+        return torch.from_numpy(self.data["inputs"][index]), torch.from_numpy(self.data["targets"][index])
+
+
+def device_from_config(config: dict, rank: int = 0) -> torch.device:
+    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() -> None:
+    config = yaml.safe_load((ROOT / "conf/config.yaml").read_text())
+    np.random.seed(int(config["seed"]))
+    torch.manual_seed(int(config["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 = ClimateDataset(ROOT / config["data"]["root"] / "train.npz", config)
+    sampler = DistributedSampler(dataset, shuffle=True) if distributed else None
+    loader = DataLoader(dataset, batch_size=int(config["train"]["batch_size"]), sampler=sampler,
+                        shuffle=sampler is None, num_workers=int(config["train"]["num_workers"]))
+    model = ClimateBench(int(config["data"]["height"]), int(config["data"]["width"])).to(device)
+    counts = model.parameter_counts()
+    expected_count = int(config["model"]["parameters_per_target"])
+    if any(count != expected_count for count in counts.values()):
+        raise RuntimeError(f"parameter count mismatch: {counts}")
+    wrapped = DistributedDataParallel(model, device_ids=[local_rank] if device.type == "cuda" else None) if distributed else model
+    optimizer = torch.optim.RMSprop(wrapped.parameters(), lr=float(config["train"]["learning_rate"]))
+    history = []
+    for epoch in range(int(config["train"]["epochs"])):
+        if sampler is not None:
+            sampler.set_epoch(epoch)
+        total, batches = 0.0, 0
+        for inputs, targets in loader:
+            prediction = wrapped(inputs.to(device))
+            loss = torch.nn.functional.mse_loss(prediction, targets.to(device))
+            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())
+            batches += 1
+        history.append({"epoch": epoch + 1, "mse": total / max(batches, 1), "batches": batches})
+    model = wrapped.module if distributed else wrapped
+    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)
+        torch.save({"model": model.state_dict(), "parameter_counts": counts, "targets": TARGETS,
+                    "format_version": config["data"]["format_version"], "storage_layout": "NTCHW",
+                    "model_config": {"height": model.height, "width": model.width}}, checkpoint_path)
+        metrics_path.write_text(json.dumps({"history": history, "parameter_counts": counts}, indent=2) + "\n")
+        print(f"checkpoint={checkpoint_path.relative_to(ROOT)} batches={history[-1]['batches']} parameters={counts}")
+    if distributed:
+        torch.distributed.destroy_process_group()
+
+
+if __name__ == "__main__":
+    main()