Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,2 @@
-*.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
+*.npz filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,149 @@
+---
+license: cc-by-4.0
+language:
+- en
+tags:
+- OneScience
+- Earth Science
+- Climate Prediction
+- Regression
+frameworks: PyTorch
+---
+
+<p align="center">
+  <strong><span style="font-size: 30px;">ClimEmu-S2L</span></strong>
+</p>
+
+# Model Introduction
+
+ClimEmu-S2L predicts long-term climate-change patterns from the first 10 years of global near-surface temperature responses to reduce the cost of multi-scenario long-term climate simulations and support regional temperature-response analysis.
+
+Paper: Predicting global patterns of long-term climate change from short-term simulations using machine learning  
+https://doi.org/10.1038/s41612-020-00148-5
+
+# Model Description
+
+The method reproduced by ClimEmu-S2L was proposed by research teams from Imperial College London, the University of Reading, the University of East Anglia, the University of Warwick, the Technical University of Crete, and collaborating institutions. The paper uses 21 HadGEM3 climate-forcing scenarios from projects including PDRMIP, ECLIPSE, and Kasoar. The model performs the task of predicting long-term spatial patterns from short-term global near-surface temperature responses and evaluates global and regional climate responses.
+
+# Use Cases
+
+| Use Case | Description |
+| :---: | :--- |
+| Long-term climate response prediction | Predict global long-term patterns after year 70 from the first 10 years of temperature response. |
+| Ridge regression validation | Select regularization with inner cross-validation and execute 21-fold LOSO prediction. |
+| GPR regression validation | Execute 21-fold LOSO prediction with shared-kernel Gaussian process regression. |
+| ModelScope/OneCode execution | Execute full-grid training, inference, regional evaluation, and visualization in ModelScope or OneCode environments. |
+| Multi-GPU training | Distribute the 21 LOSO folds across processes 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/ClimEmu-S2L --local-dir ./ClimEmu-S2L
+cd ClimEmu-S2L
+```
+
+### 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
+
+This repository uses a small set of structured synthetic climate-response samples to validate the engineering workflow, comprising 21 forcing scenarios of single-channel near-surface temperature anomalies on the complete `145×192` grid in `degC`. Inputs are the mean responses during the first 10 years of each scenario, and targets are the same-scenario long-term mean responses after year 70. The synthetic data preserve the scenario count, spatial grid, and time windows while reducing GPR to a shared non-ARD kernel structure and fewer kernel-optimization iterations to control engineering-validation cost; they do not represent the official HadGEM3 data distribution or training scale.
+
+```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 fits Ridge and GPR models over all 21 leave-one-scenario-out (LOSO) folds; Ridge selects regularization through inner three-fold cross-validation, while GPR optimizes a shared non-ARD kernel. Standard training artifacts are saved to:
+
+```text
+result/checkpoints/climemu_s2l.pt
+result/training/metrics.json
+```
+
+### Trained Weights
+
+This repository does not include weights under `weight/`. The paper does not provide a confirmed official checkpoint, and the current engineering checkpoint is not claimed to contain the paper's formal model parameters.
+
+### Inference
+
+```bash
+python scripts/inference.py
+```
+
+Inference loads the training checkpoint and generates Ridge and GPR long-term response fields for all 21 scenarios. Complete numerical results are saved to:
+
+```text
+result/output/predictions.npz
+```
+
+### Evaluation and Visualization
+
+```bash
+python scripts/result.py
+```
+
+Evaluation reports area-weighted full-grid RMSE, global mean absolute error, and regional mean absolute error by method, per scenario, and per region; this is neither a multi-step nor classification task, so no per-step or per-class results are provided. Visualizations include target and prediction spatial maps and cross-scenario error boxplots, with structured results and figures saved to the paths below. Synthetic-data results validate the engineering workflow only and do not represent formal paper performance.
+
+```text
+result/evaluation/metrics.json
+result/evaluation/spatial_fields.png
+result/evaluation/error_boxplots.png
+```
+
+# 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 ClimEmu-S2L specifications.
+
+Use of this repository's code, official model weights, and data remains subject to the licenses and terms of their respective projects.

conf/config.yaml

@@ -0,0 +1,30 @@
+seed: 2020
+data:
+  path: data/hadgem3_fake.npz
+  scenario_count: 21
+  grid: [145, 192]
+  channels: 1
+model:
+  methods: [ridge, gpr]
+  ridge:
+    alphas: [0.001, 0.01, 0.1, 1.0, 10.0, 100.0]
+    inner_folds: 3
+  gpr:
+    kernel_mode: paper_rbf
+    supported_kernel_modes: [paper_rbf, official_rbf_linear]
+    optimizer_steps: 8
+    learning_rate: 0.08
+    jitter: 0.00001
+    ard: false
+    ard_gap: "The paper/official GPy workflow can use per-input ARD; this implementation deliberately uses one shared non-ARD lengthscale because p=27840 and N=20."
+runtime:
+  device: cpu
+  dtype: float64
+  ddp_backend: gloo
+paths:
+  checkpoint: result/checkpoints/climemu_s2l.pt
+  training_metrics: result/training/metrics.json
+  inference: result/output/predictions.npz
+  evaluation_dir: result/evaluation
+evaluation:
+  plot_scenario_id: PDRMIP_2xCO2

config.json

@@ -0,0 +1,34 @@
+{
+  "model_name": "ClimEmu-S2L",
+  "model_type": "climemu_s2l",
+  "architectures": ["DualRidge", "SharedKernelGPR"],
+  "framework": "PyTorch",
+  "domain": "earth-science",
+  "task": "short-to-long-term-climate-response",
+  "implementation": {
+    "entry_point": "model/climemu_s2l.py",
+    "train_script": "scripts/train.py",
+    "inference_script": "scripts/inference.py",
+    "evaluation_script": "scripts/result.py",
+    "synthetic_data_script": "scripts/fake_data.py"
+  },
+  "data": {
+    "scenarios": 21,
+    "grid": [145, 192],
+    "features_per_scenario": 27840,
+    "input_channels": 1,
+    "outer_validation": "21-fold leave-one-scenario-out"
+  },
+  "methods": {
+    "ridge": "multi-output sample-space dual closed form with internal 3-fold alpha selection",
+    "gpr": "multi-output posterior mean with one shared non-ARD kernel and optimized marginal likelihood",
+    "kernel_modes": ["paper_rbf", "official_rbf_linear"]
+  },
+  "paper": {
+    "title": "Predicting global patterns of long-term climate change from short-term simulations using machine learning",
+    "doi": "10.1038/s41612-020-00148-5",
+    "data_doi": "10.5281/zenodo.3971024",
+    "license": "CC BY 4.0"
+  },
+  "configuration_sources": ["conf/config.yaml", "model/climemu_s2l.py", "scripts/fake_data.py", "scripts/train.py", "scripts/inference.py", "scripts/result.py"]
+}

configuration.json

@@ -0,0 +1,12 @@
+{
+  "framework": "PyTorch",
+  "task": "short-to-long-term-climate-response",
+  "model": "ClimEmu-S2L",
+  "input_format": "NPZ with short_response and long_response shaped [21,145,192]",
+  "protocol": "full-grid 21-fold LOSO dual Ridge and shared-kernel GPR",
+  "default_config": "conf/config.yaml",
+  "training": "scripts/train.py",
+  "inference": "scripts/inference.py",
+  "evaluation": "scripts/result.py",
+  "visualization": "scripts/result.py"
+}

model/climemu_s2l.py

@@ -0,0 +1,168 @@
+"""Full-grid sample-space regressors for HadGEM3 short-to-long responses."""
+
+from dataclasses import dataclass
+
+import numpy as np
+import torch
+
+
+MODEL_NAME = "ClimEmu-S2L"
+FORMAT_VERSION = "climemu_s2l_v1"
+GRID_SHAPE = (145, 192)
+SCENARIO_COUNT = 21
+FEATURE_COUNT = 27840
+
+
+def area_weights(latitude_deg, nx=192):
+    weights = np.cos(np.deg2rad(np.asarray(latitude_deg, dtype=np.float64)))[:, None]
+    weights = np.broadcast_to(np.maximum(weights, 0.0), (len(latitude_deg), nx)).copy()
+    return weights / weights.sum()
+
+
+def weighted_rmse(target, prediction, weights):
+    residual = np.asarray(target) - np.asarray(prediction)
+    return float(np.sqrt(np.sum(weights * residual.reshape(weights.shape) ** 2)))
+
+
+def _normalise_inputs(x):
+    mean = x.mean(dim=0, keepdim=True)
+    scale = torch.sqrt(torch.mean((x - mean) ** 2)).clamp_min(1e-8)
+    return (x - mean) / scale, mean, scale
+
+
+@dataclass
+class DualRidge:
+    alpha: float
+    x_train: torch.Tensor = None
+    dual_coef: torch.Tensor = None
+    x_mean: torch.Tensor = None
+    x_scale: torch.Tensor = None
+    y_mean: torch.Tensor = None
+
+    def fit(self, x, y):
+        x = torch.as_tensor(x)
+        y = torch.as_tensor(y, dtype=x.dtype, device=x.device)
+        x_scaled, self.x_mean, self.x_scale = _normalise_inputs(x)
+        self.y_mean = y.mean(dim=0, keepdim=True)
+        yc = y - self.y_mean
+        gram = x_scaled @ x_scaled.T
+        system = gram + self.alpha * torch.eye(len(x), dtype=x.dtype, device=x.device)
+        self.x_train = x_scaled
+        self.dual_coef = torch.linalg.solve(system, yc)
+        return self
+
+    def predict(self, x):
+        x = torch.as_tensor(x, dtype=self.x_train.dtype, device=self.x_train.device)
+        return ((x - self.x_mean) / self.x_scale) @ self.x_train.T @ self.dual_coef + self.y_mean
+
+
+def select_ridge_alpha(x, y, alphas, folds, weights):
+    """Paper-style internal CV using area-weighted grid RMSE."""
+    x = torch.as_tensor(x)
+    y = torch.as_tensor(y, dtype=x.dtype)
+    split = np.array_split(np.arange(len(x)), folds)
+    scores = {}
+    flat_weights = torch.as_tensor(weights.reshape(-1), dtype=x.dtype)
+    for alpha in alphas:
+        fold_scores = []
+        for validation in split:
+            training = np.setdiff1d(np.arange(len(x)), validation)
+            prediction = DualRidge(float(alpha)).fit(x[training], y[training]).predict(x[validation])
+            mse = torch.sum((prediction - y[validation]) ** 2 * flat_weights, dim=1)
+            fold_scores.append(float(torch.sqrt(mse).mean()))
+        scores[float(alpha)] = float(np.mean(fold_scores))
+    selected = min(scores, key=scores.get)
+    return selected, scores
+
+
+class SharedKernelGPR(torch.nn.Module):
+    """One scenario-space covariance shared by all 27,840 output cells."""
+
+    def __init__(self, kernel_mode="paper_rbf", jitter=1e-5, dtype=torch.float64):
+        super().__init__()
+        if kernel_mode not in {"paper_rbf", "official_rbf_linear"}:
+            raise ValueError(f"unknown GPR kernel mode: {kernel_mode}")
+        self.kernel_mode = kernel_mode
+        self.jitter = float(jitter)
+        self.log_lengthscale = torch.nn.Parameter(torch.tensor(0.0, dtype=dtype))
+        self.log_outputscale = torch.nn.Parameter(torch.tensor(0.0, dtype=dtype))
+        self.log_noise = torch.nn.Parameter(torch.tensor(-2.5, dtype=dtype))
+        self.log_linear_scale = torch.nn.Parameter(torch.tensor(-1.0, dtype=dtype))
+
+    @staticmethod
+    def geometry(x1, x2):
+        feature_count = x1.shape[1]
+        distance = ((x1[:, None, :] - x2[None, :, :]) ** 2).mean(dim=2)
+        linear = (x1 @ x2.T) / feature_count
+        return distance, linear
+
+    def kernel_from_geometry(self, distance, linear):
+        length2 = torch.exp(2.0 * self.log_lengthscale).clamp_min(1e-10)
+        kernel = torch.exp(2.0 * self.log_outputscale) * torch.exp(-0.5 * distance / length2)
+        if self.kernel_mode == "official_rbf_linear":
+            kernel = kernel + torch.exp(2.0 * self.log_linear_scale) * linear
+        return kernel
+
+    def fit(self, x, y, steps=8, learning_rate=0.08):
+        x = torch.as_tensor(x, dtype=self.log_lengthscale.dtype)
+        y = torch.as_tensor(y, dtype=x.dtype)
+        self.x_train, self.x_mean, self.x_scale = _normalise_inputs(x)
+        self.y_mean = y.mean(dim=0, keepdim=True)
+        self.y_scale = torch.sqrt(torch.mean((y - self.y_mean) ** 2)).clamp_min(1e-8)
+        self.y_train = (y - self.y_mean) / self.y_scale
+        distance, linear = self.geometry(self.x_train, self.x_train)
+        identity = torch.eye(len(x), dtype=x.dtype)
+        optimizer = torch.optim.Adam(self.parameters(), lr=float(learning_rate))
+        initial = {name: value.detach().clone() for name, value in self.named_parameters()}
+        losses, gradient_seen = [], False
+        for _ in range(int(steps)):
+            optimizer.zero_grad()
+            kernel = self.kernel_from_geometry(distance, linear)
+            noise = torch.exp(2.0 * self.log_noise) + self.jitter
+            chol = torch.linalg.cholesky(kernel + noise * identity)
+            solved = torch.cholesky_solve(self.y_train, chol)
+            data_fit = 0.5 * torch.mean(torch.sum(self.y_train * solved, dim=0))
+            loss = data_fit + torch.log(torch.diagonal(chol)).sum()
+            loss.backward()
+            gradient_seen = gradient_seen or any(p.grad is not None and torch.isfinite(p.grad).all() for p in self.parameters())
+            torch.nn.utils.clip_grad_norm_(self.parameters(), 20.0)
+            optimizer.step()
+            losses.append(float(loss.detach()))
+        parameter_updated = any(not torch.equal(initial[name], value.detach()) for name, value in self.named_parameters())
+        if not gradient_seen or not parameter_updated:
+            raise RuntimeError("GPR marginal-likelihood backward/update check failed")
+        with torch.no_grad():
+            kernel = self.kernel_from_geometry(distance, linear)
+            noise = torch.exp(2.0 * self.log_noise) + self.jitter
+            self.posterior_coef = torch.linalg.solve(kernel + noise * identity, self.y_train)
+        return {"loss": losses, "gradient_seen": gradient_seen, "parameter_updated": parameter_updated}
+
+    def predict(self, x):
+        x = torch.as_tensor(x, dtype=self.x_train.dtype)
+        scaled = (x - self.x_mean) / self.x_scale
+        distance, linear = self.geometry(scaled, self.x_train)
+        kernel = self.kernel_from_geometry(distance, linear)
+        return self.y_mean + self.y_scale * (kernel @ self.posterior_coef)
+
+    def hyperparameters(self):
+        return {name: float(value.detach()) for name, value in self.named_parameters()}
+
+    def load_hyperparameters(self, values):
+        with torch.no_grad():
+            for name, value in values.items():
+                getattr(self, name).copy_(torch.tensor(value, dtype=getattr(self, name).dtype))
+        return self
+
+    def restore_posterior(self, x, y):
+        x = torch.as_tensor(x, dtype=self.log_lengthscale.dtype)
+        y = torch.as_tensor(y, dtype=x.dtype)
+        self.x_train, self.x_mean, self.x_scale = _normalise_inputs(x)
+        self.y_mean = y.mean(dim=0, keepdim=True)
+        self.y_scale = torch.sqrt(torch.mean((y - self.y_mean) ** 2)).clamp_min(1e-8)
+        self.y_train = (y - self.y_mean) / self.y_scale
+        distance, linear = self.geometry(self.x_train, self.x_train)
+        kernel = self.kernel_from_geometry(distance, linear)
+        identity = torch.eye(len(x), dtype=x.dtype)
+        noise = torch.exp(2.0 * self.log_noise) + self.jitter
+        self.posterior_coef = torch.linalg.solve(kernel + noise * identity, self.y_train)
+        return self

scripts/fake_data.py

@@ -0,0 +1,88 @@
+"""Generate 21 structured, physically interpretable full-grid response pairs."""
+
+import sys
+from pathlib import Path
+
+import numpy as np
+import yaml
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+from model.climemu_s2l import FORMAT_VERSION, GRID_SHAPE
+
+
+SCENARIOS = [
+    ("PDRMIP_2xCO2", 2.5, "global", 0, 0),
+    ("PDRMIP_3xCH4", 1.5, "global", 0, 0),
+    ("PDRMIP_10xCFC12", 1.1, "global", 0, 0),
+    ("PDRMIP_solar", 1.0, "global", 0, 0),
+    ("PDRMIP_5xSO4", -1.6, "global", 0, 0),
+    ("PDRMIP_10xBC", 1.2, "global", 0, 0),
+    ("PDRMIP_10xSO4_Europe", -1.0, "regional", 52, 15),
+    ("PDRMIP_10xSO4_Asia", -1.1, "regional", 35, 105),
+    ("PDRMIP_preindustrial_SO4", 0.8, "global", 0, 0),
+    ("ECLIPSE_CH4_minus20", -0.7, "global", 0, 0),
+    ("ECLIPSE_2xCO2", 2.3, "global", 0, 0),
+    ("ECLIPSE_BC_minus100", -0.6, "global", 0, 0),
+    ("ECLIPSE_SO2_minus100", 1.0, "global", 0, 0),
+    ("ECLIPSE_CO_minus100", -0.45, "global", 0, 0),
+    ("KASOAR_SO2_NHML_minus100", 0.75, "regional", 42, 30),
+    ("KASOAR_BC_NHML_minus100", -0.55, "regional", 42, 30),
+    ("KASOAR_SO2_China_minus100", 0.70, "regional", 34, 105),
+    ("KASOAR_SO2_EastAsia_minus100", 0.65, "regional", 40, 125),
+    ("KASOAR_SO2_Europe_minus100", 0.62, "regional", 52, 15),
+    ("KASOAR_SO2_US_minus100", 0.58, "regional", 40, 260),
+    ("PDRMIP_SO4_Asia_alt", -0.72, "regional", 25, 80),
+]
+
+
+def wrapped_distance(longitude, centre):
+    return (longitude - centre + 180.0) % 360.0 - 180.0
+
+
+def main():
+    config = yaml.safe_load((ROOT / "conf/config.yaml").read_text())
+    ny, nx = map(int, config["data"]["grid"])
+    if (ny, nx) != GRID_SHAPE or len(SCENARIOS) != 21:
+        raise ValueError("protocol requires exactly 21 scenarios on a 145x192 grid")
+    latitude = np.linspace(-90.0, 90.0, ny, dtype=np.float64)
+    longitude = np.linspace(0.0, 360.0, nx, endpoint=False, dtype=np.float64)
+    lat, lon = np.meshgrid(latitude, longitude, indexing="ij")
+    polar = np.sin(np.deg2rad(lat)) ** 4
+    land_wave = np.cos(np.deg2rad(2.0 * lon - 0.6 * lat)) * np.cos(np.deg2rad(lat)) ** 2
+    short_fields, long_fields = [], []
+    for index, (scenario_id, amplitude, forcing_type, centre_lat, centre_lon) in enumerate(SCENARIOS):
+        local = np.exp(-0.5 * ((lat - centre_lat) / 16.0) ** 2
+                       -0.5 * (wrapped_distance(lon, centre_lon) / 28.0) ** 2)
+        if forcing_type == "global":
+            local = 0.25 * np.cos(np.deg2rad(lat)) ** 2
+        phase = 2.0 * np.pi * index / len(SCENARIOS)
+        forcing_region = amplitude * local
+        global_warming = amplitude * (0.52 + 0.34 * polar)
+        circulation = 0.13 * amplitude * np.cos(np.deg2rad(lat * 2.0) + phase) * np.sin(np.deg2rad(lon) - phase)
+        short = global_warming + 0.72 * forcing_region + 0.10 * amplitude * land_wave + circulation
+        zonal = short.mean(axis=1, keepdims=True)
+        remote_east = np.roll(short, nx // 5, axis=1)
+        cross_equatorial = np.flip(zonal, axis=0)
+        planetary_wave = np.cos(np.deg2rad(lon * 2.0 + centre_lon)) * np.cos(np.deg2rad(lat))
+        long = (1.42 * short + 0.28 * remote_east + 0.23 * cross_equatorial
+                + short.mean() * (0.48 + 0.62 * polar) + 0.09 * amplitude * planetary_wave)
+        short_fields.append(short.astype(np.float32))
+        long_fields.append(long.astype(np.float32))
+    short_response = np.stack(short_fields)
+    long_response = np.stack(long_fields)
+    if short_response.shape != (21, 145, 192) or not np.isfinite(long_response).all():
+        raise ValueError("invalid synthetic response fields")
+    output = ROOT / config["data"]["path"]
+    output.parent.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(output, format_version=np.array(FORMAT_VERSION),
+                        scenario_ids=np.asarray([item[0] for item in SCENARIOS]),
+                        forcing_amplitude=np.asarray([item[1] for item in SCENARIOS], dtype=np.float32),
+                        latitude_deg=latitude.astype(np.float32), longitude_deg=longitude.astype(np.float32),
+                        short_response=short_response, long_response=long_response)
+    print(f"data={output.relative_to(ROOT)} shape={short_response.shape} features={ny * nx}")
+
+
+if __name__ == "__main__":
+    main()

scripts/inference.py

@@ -0,0 +1,60 @@
+"""Restore every LOSO fold and emit both methods' 21 complete response maps."""
+
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+import yaml
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+from model.climemu_s2l import FEATURE_COUNT, FORMAT_VERSION, GRID_SHAPE, DualRidge, SharedKernelGPR
+
+
+def load_checkpoint(path):
+    try:
+        return torch.load(path, map_location="cpu", weights_only=False)
+    except TypeError:
+        return torch.load(path, map_location="cpu")
+
+
+def main():
+    config = yaml.safe_load((ROOT / "conf/config.yaml").read_text())
+    checkpoint = load_checkpoint(ROOT / config["paths"]["checkpoint"])
+    if checkpoint["format_version"] != FORMAT_VERSION or tuple(checkpoint["grid_shape"]) != GRID_SHAPE:
+        raise ValueError("checkpoint protocol mismatch")
+    x = checkpoint["short_response"].double()
+    y = checkpoint["long_response"].double()
+    required = {"model", "model_config", "format_version"}
+    if not required.issubset(checkpoint):
+        raise ValueError(f"checkpoint is missing standard fields: {sorted(required - checkpoint.keys())}")
+    predictions = {"ridge": [], "gpr": []}
+    for expected_fold, state in enumerate(checkpoint["model"]["folds"]):
+        if state["fold"] != expected_fold or state["held_out_scenario_id"] != checkpoint["scenario_ids"][expected_fold]:
+            raise ValueError("fold/scenario identity mismatch")
+        training = state["train_indices"]
+        ridge = DualRidge(float(state["ridge_alpha"])).fit(x[training], y[training])
+        gpr = SharedKernelGPR(state["gpr_kernel_mode"], config["model"]["gpr"]["jitter"])
+        gpr.load_hyperparameters(state["gpr_hyperparameters"]).restore_posterior(x[training], y[training])
+        predictions["ridge"].append(ridge.predict(x[expected_fold:expected_fold + 1]).detach().numpy()[0])
+        predictions["gpr"].append(gpr.predict(x[expected_fold:expected_fold + 1]).detach().numpy()[0])
+    ridge = np.asarray(predictions["ridge"], dtype=np.float32).reshape(21, *GRID_SHAPE)
+    gpr = np.asarray(predictions["gpr"], dtype=np.float32).reshape(21, *GRID_SHAPE)
+    if ridge.shape != (21, 145, 192) or not np.isfinite(gpr).all():
+        raise ValueError("inference did not produce 21 finite full-grid fields")
+    source = np.load(ROOT / config["data"]["path"])
+    output = ROOT / config["paths"]["inference"]
+    output.parent.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(output, format_version=np.array(FORMAT_VERSION),
+                        scenario_ids=np.asarray(checkpoint["scenario_ids"]),
+                        latitude_deg=source["latitude_deg"], longitude_deg=source["longitude_deg"],
+                        short_response=x.numpy().reshape(21, *GRID_SHAPE).astype(np.float32),
+                        long_response=y.numpy().reshape(21, *GRID_SHAPE).astype(np.float32),
+                        ridge_prediction=ridge, gpr_prediction=gpr)
+    print(f"predictions={output.relative_to(ROOT)} methods=2 shape={ridge.shape}")
+
+
+if __name__ == "__main__":
+    main()

scripts/result.py

@@ -0,0 +1,103 @@
+"""Compute paper metrics for every scenario and draw maps and error boxes."""
+
+import json
+import sys
+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]
+sys.path.insert(0, str(ROOT))
+from model.climemu_s2l import GRID_SHAPE, area_weights, weighted_rmse
+
+
+REGIONS = {
+    "North America": (15, 75, 190, 310), "Europe": (35, 70, 350, 45),
+    "South Asia": (5, 35, 60, 100), "East Asia": (20, 55, 100, 150),
+    "Arctic": (66, 90, 0, 360), "Northwest Asia": (50, 75, 45, 120),
+    "Northern Africa": (15, 35, 340, 55), "Southern Africa": (-35, 0, 10, 55),
+    "South America": (-60, 15, 275, 330), "Australia": (-45, -10, 110, 155),
+}
+
+
+def region_mask(latitude, longitude, bounds):
+    south, north, west, east = bounds
+    latitude_mask = (latitude[:, None] >= south) & (latitude[:, None] <= north)
+    longitude_mask = ((longitude[None, :] >= west) & (longitude[None, :] <= east)
+                      if west <= east else (longitude[None, :] >= west) | (longitude[None, :] <= east))
+    return latitude_mask & longitude_mask
+
+
+def weighted_mean(field, weights, mask=None):
+    selected = np.ones(field.shape, dtype=bool) if mask is None else mask
+    local_weights = weights[selected]
+    return float(np.sum(field[selected] * local_weights) / np.sum(local_weights))
+
+
+def main():
+    config = yaml.safe_load((ROOT / "conf/config.yaml").read_text())
+    data = np.load(ROOT / config["paths"]["inference"])
+    latitude, longitude = data["latitude_deg"], data["longitude_deg"]
+    weights = area_weights(latitude, GRID_SHAPE[1])
+    targets = data["long_response"]
+    scenario_ids = [str(item) for item in data["scenario_ids"]]
+    masks = {name: region_mask(latitude, longitude, bounds) for name, bounds in REGIONS.items()}
+    report = {"grid": list(GRID_SHAPE), "scenario_count": 21, "regions": list(REGIONS), "methods": {}}
+    box_values = {}
+    for method in ("ridge", "gpr"):
+        predictions = data[f"{method}_prediction"]
+        scenarios = []
+        for index, scenario_id in enumerate(scenario_ids):
+            target, prediction = targets[index], predictions[index]
+            regional = {name: abs(weighted_mean(prediction, weights, mask) - weighted_mean(target, weights, mask))
+                        for name, mask in masks.items()}
+            scenarios.append({"scenario_id": scenario_id,
+                              "area_weighted_grid_rmse": weighted_rmse(target, prediction, weights),
+                              "global_mean_absolute_error": abs(weighted_mean(prediction, weights) - weighted_mean(target, weights)),
+                              "regional_mean_absolute_error": regional})
+        grid_errors = [item["area_weighted_grid_rmse"] for item in scenarios]
+        global_errors = [item["global_mean_absolute_error"] for item in scenarios]
+        report["methods"][method] = {"scenarios": scenarios,
+            "summary": {"mean_grid_rmse": float(np.mean(grid_errors)), "median_grid_rmse": float(np.median(grid_errors)),
+                        "mean_global_absolute_error": float(np.mean(global_errors)),
+                        "mean_regional_absolute_error": {name: float(np.mean([item["regional_mean_absolute_error"][name]
+                                                                             for item in scenarios])) for name in REGIONS}}}
+        box_values[method] = [grid_errors, global_errors] + [[item["regional_mean_absolute_error"][name] for item in scenarios]
+                                                             for name in REGIONS]
+    numeric = [value for method in report["methods"].values() for value in
+               (method["summary"]["mean_grid_rmse"], method["summary"]["mean_global_absolute_error"])]
+    if not np.isfinite(numeric).all():
+        raise FloatingPointError("evaluation metrics are not finite")
+    output = ROOT / config["paths"]["evaluation_dir"]
+    output.mkdir(parents=True, exist_ok=True)
+    (output / "metrics.json").write_text(json.dumps(report, indent=2) + "\n")
+    plot_index = scenario_ids.index(config["evaluation"]["plot_scenario_id"])
+    fields = [targets[plot_index], data["ridge_prediction"][plot_index], data["gpr_prediction"][plot_index],
+              data["ridge_prediction"][plot_index] - targets[plot_index], data["gpr_prediction"][plot_index] - targets[plot_index]]
+    titles = ["HadGEM3 target", "Dual Ridge", "Shared-kernel GPR", "Ridge error", "GPR error"]
+    figure, axes = plt.subplots(2, 3, figsize=(14, 7), constrained_layout=True)
+    for axis, field, title in zip(axes.flat, fields, titles):
+        limit = max(abs(np.percentile(field, 1)), abs(np.percentile(field, 99)))
+        image = axis.imshow(field, origin="lower", extent=(0, 360, -90, 90), cmap="RdBu_r", vmin=-limit, vmax=limit, aspect="auto")
+        axis.set(title=title, xlabel="Longitude", ylabel="Latitude"); figure.colorbar(image, ax=axis, shrink=0.75)
+    axes.flat[-1].axis("off")
+    figure.suptitle(config["evaluation"]["plot_scenario_id"] + " full 145x192 fields")
+    figure.savefig(output / "spatial_fields.png", dpi=150); plt.close(figure)
+    labels = ["Grid RMSE", "Global"] + list(REGIONS)
+    figure, axes = plt.subplots(1, 2, figsize=(15, 5), sharey=False, constrained_layout=True)
+    for axis, method, color in zip(axes, ("ridge", "gpr"), ("#2a6f97", "#c45d35")):
+        boxes = axis.boxplot(box_values[method], patch_artist=True, showmeans=True)
+        for patch in boxes["boxes"]: patch.set_facecolor(color); patch.set_alpha(0.65)
+        axis.set_xticks(range(1, len(labels) + 1), labels, rotation=55, ha="right")
+        axis.set(title=method.upper(), ylabel="Absolute error / RMSE (deg C)"); axis.grid(axis="y", alpha=0.25)
+    figure.savefig(output / "error_boxplots.png", dpi=150); plt.close(figure)
+    print(f"evaluation={output.relative_to(ROOT)} scenarios=21 regions=10 methods=2")
+
+
+if __name__ == "__main__":
+    main()

scripts/train.py

@@ -0,0 +1,130 @@
+"""Train all 21 LOSO folds; DDP ranks independently shard outer folds."""
+
+import json
+import argparse
+import os
+import random
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+import yaml
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+from model.climemu_s2l import (FEATURE_COUNT, FORMAT_VERSION, GRID_SHAPE,
+                                      MODEL_NAME, DualRidge, SharedKernelGPR,
+                                      area_weights, select_ridge_alpha, weighted_rmse)
+
+
+def load_data(path):
+    data = np.load(path)
+    short, long = data["short_response"], data["long_response"]
+    if str(data["format_version"]) != FORMAT_VERSION:
+        raise ValueError("data format version mismatch")
+    if short.shape != (21, *GRID_SHAPE) or long.shape != short.shape:
+        raise ValueError("responses must both have shape [21,145,192]")
+    ids = [str(value) for value in data["scenario_ids"]]
+    if len(set(ids)) != 21 or not np.isfinite(short).all() or not np.isfinite(long).all():
+        raise ValueError("scenario IDs must be unique and fields finite")
+    return data, short.reshape(21, FEATURE_COUNT), long.reshape(21, FEATURE_COUNT), ids
+
+
+def train_fold(fold, x, y, scenario_ids, config, weights):
+    training = np.asarray([index for index in range(21) if index != fold])
+    alpha, cv_scores = select_ridge_alpha(
+        x[training], y[training], config["model"]["ridge"]["alphas"],
+        int(config["model"]["ridge"]["inner_folds"]), weights)
+    ridge = DualRidge(alpha).fit(x[training], y[training])
+    ridge_prediction = ridge.predict(x[fold:fold + 1]).detach().cpu().numpy()[0]
+    gpr_config = config["model"]["gpr"]
+    gpr = SharedKernelGPR(gpr_config["kernel_mode"], gpr_config["jitter"])
+    optimizer_trace = gpr.fit(x[training], y[training], gpr_config["optimizer_steps"], gpr_config["learning_rate"])
+    gpr_prediction = gpr.predict(x[fold:fold + 1]).detach().cpu().numpy()[0]
+    state = {"fold": fold, "held_out_scenario_id": scenario_ids[fold], "train_indices": training.tolist(),
+              "ridge_alpha": alpha, "ridge_cv_scores": cv_scores,
+              "gpr_kernel_mode": gpr.kernel_mode, "gpr_hyperparameters": gpr.hyperparameters(),
+              "gpr_optimizer": optimizer_trace}
+    metrics = {"scenario_id": scenario_ids[fold],
+               "ridge_weighted_rmse": weighted_rmse(y[fold], ridge_prediction, weights),
+               "gpr_weighted_rmse": weighted_rmse(y[fold], gpr_prediction, weights),
+               "selected_alpha": alpha, "gpr_final_loss": optimizer_trace["loss"][-1],
+               "gpr_backward": optimizer_trace["gradient_seen"],
+               "gpr_parameter_update": optimizer_trace["parameter_updated"]}
+    return state, metrics
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--resume", action="store_true", help="resume completed LOSO folds from the checkpoint")
+    args = parser.parse_args()
+    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)
+    torch.set_default_dtype(torch.float64)
+    distributed = int(os.environ.get("WORLD_SIZE", "1")) > 1
+    if distributed:
+        torch.distributed.init_process_group(config["runtime"]["ddp_backend"])
+    rank = torch.distributed.get_rank() if distributed else 0
+    world = torch.distributed.get_world_size() if distributed else 1
+    data, x_numpy, y_numpy, scenario_ids = load_data(ROOT / config["data"]["path"])
+    x, y = torch.from_numpy(x_numpy).double(), torch.from_numpy(y_numpy).double()
+    weights = area_weights(data["latitude_deg"], GRID_SHAPE[1])
+    checkpoint_path = ROOT / config["paths"]["checkpoint"]
+    resumed_states, resumed_metrics = {}, {}
+    if args.resume and checkpoint_path.exists():
+        try:
+            previous = torch.load(checkpoint_path, map_location="cpu", weights_only=False)
+        except TypeError:
+            previous = torch.load(checkpoint_path, map_location="cpu")
+        if previous.get("format_version") != FORMAT_VERSION or tuple(previous.get("grid_shape", ())) != GRID_SHAPE:
+            raise ValueError("checkpoint protocol mismatch")
+        restored_folds = previous.get("model", {}).get("folds", previous.get("folds", []))
+        resumed_states = {state["fold"]: state for state in restored_folds}
+        resumed_metrics = {index: value for index, value in enumerate(previous.get("training_metrics", []))}
+    local_states, local_metrics = {}, {}
+    for fold in range(rank, 21, world):
+        if fold in resumed_states and fold in resumed_metrics:
+            continue
+        state, metrics = train_fold(fold, x, y, scenario_ids, config, weights)
+        local_states[fold], local_metrics[fold] = state, metrics
+        print(f"rank={rank} fold={fold:02d} scenario={scenario_ids[fold]} alpha={state['ridge_alpha']}")
+    if distributed:
+        gathered_states, gathered_metrics = [None] * world, [None] * world
+        torch.distributed.all_gather_object(gathered_states, local_states)
+        torch.distributed.all_gather_object(gathered_metrics, local_metrics)
+        states = {**resumed_states, **{key: value for item in gathered_states for key, value in item.items()}}
+        metrics = {**resumed_metrics, **{key: value for item in gathered_metrics for key, value in item.items()}}
+    else:
+        states, metrics = {**resumed_states, **local_states}, {**resumed_metrics, **local_metrics}
+    if rank == 0:
+        if sorted(states) != list(range(21)):
+            raise RuntimeError("all 21 LOSO folds must be trained")
+        fold_states = [states[index] for index in range(21)]
+        fold_metrics = [metrics[index] for index in range(21)]
+        checkpoint = {"epoch": 1,
+                      "model": {"folds": fold_states},
+                      "model_config": config["model"],
+                      "optimizer_state_dict": {"folds": [state["gpr_optimizer"] for state in fold_states]},
+                      "loss": float(np.mean([item["gpr_final_loss"] for item in fold_metrics])),
+                      "config": config,
+                      "model_name": MODEL_NAME, "format_version": FORMAT_VERSION,
+                      "grid_shape": GRID_SHAPE, "scenario_ids": scenario_ids,
+                      "short_response": torch.from_numpy(x_numpy), "long_response": torch.from_numpy(y_numpy),
+                      "training_metrics": fold_metrics,
+                      "gpr_ard": False, "gpr_ard_gap": config["model"]["gpr"]["ard_gap"]}
+        checkpoint_path.parent.mkdir(parents=True, exist_ok=True)
+        torch.save(checkpoint, checkpoint_path)
+        metrics_path = ROOT / config["paths"]["training_metrics"]
+        metrics_path.parent.mkdir(parents=True, exist_ok=True)
+        metrics_path.write_text(json.dumps({"fold_count": 21, "world_size": world,
+                                            "folds": fold_metrics}, indent=2) + "\n")
+        print(f"checkpoint={checkpoint_path.relative_to(ROOT)} folds=21 world_size={world} resumed={len(resumed_states)}")
+    if distributed:
+        torch.distributed.barrier(); torch.distributed.destroy_process_group()
+
+
+if __name__ == "__main__":
+    main()