Upload Experiments/V3_S4_A0/cidm_v3_scs_s4_a0_multiseason_training_qualification.py with huggingface_hub

Experiments/V3_S4_A0/cidm_v3_scs_s4_a0_multiseason_training_qualification.py

@@ -0,0 +1,2003 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+CIDM-v3 SCS V3-S4-A0
+多季节中等规模训练、近岸公平性与正式训练启动资格
+=====================================================
+
+本轮是V3正式训练前的最后资格阶段，不再进行架构探索。
+
+冻结架构：
+- MultiScalePhysicalEncoder
+- ExplicitScaleInformationState
+- SharedScaleConditionedCIDMCore
+- MultiStepRecurrence
+- BandClosure
+- MultiResolutionDecoder
+
+持续关闭：
+- Future/Boundary/Vertical BER
+- CrossScaleFlux
+- SlowMemory/VerticalOutput Closure
+- CausalVarianceAmplifier
+- EventRouter
+
+本轮只扩大数据覆盖并修复训练公平性：
+1. 冬季+春季原生1/12°训练；
+2. 夏季验证，秋季独立测试；
+3. 训练补丁按近岸/陆架/开阔海域平衡；
+4. 显式尺度与参数匹配Single-State使用同一数据、目标和课程；
+5. 所有保留模块允许训练，延期模块保持冻结；
+6. AdamW跨Epoch持续；
+7. 12→20→28→40→60步课程；
+8. 像素加权、等样本、海洋占比分层与时间块Bootstrap同时报告；
+9. 每Epoch保存远端续接资产，正式运行可恢复。
+
+本轮通过后：
+- CIDM-v3结构与训练合同正式冻结；
+- 下一步直接进入多年数据的正式训练，不再增加架构模块。
+"""
+from __future__ import annotations
+
+import argparse
+import copy
+import hashlib
+import json
+import math
+import os
+import random
+import shutil
+import time
+import traceback
+import zipfile
+from pathlib import Path
+from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, Dataset
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+import scs_c0_data_runtime as data_runtime
+import cidm_v3_scs_s2_a2_r1_native_grid_integration as native_runtime
+import cidm_v3_scs_s3_a0_long_rollout_freeze as s3a0
+import cidm_v3_scs_s3_a1_long_horizon_objective_repair as s3a1
+import cidm_v3_scs_s2_a1_r2_conditional_external_innovation_capacity as s2r2
+
+
+VARIABLE_NAMES = list(data_runtime.VARIABLE_NAMES)
+SEASONS = {
+    "winter": {
+        "role": "train",
+        "start": "2023-01-15T00:00:00",
+        "end": "2023-02-18T18:00:00",
+    },
+    "spring": {
+        "role": "train",
+        "start": "2023-04-10T00:00:00",
+        "end": "2023-05-14T18:00:00",
+    },
+    "summer": {
+        "role": "validation",
+        "start": "2023-07-10T00:00:00",
+        "end": "2023-08-13T18:00:00",
+    },
+    "autumn": {
+        "role": "test",
+        "start": "2023-10-05T00:00:00",
+        "end": "2023-11-08T18:00:00",
+    },
+}
+HORIZONS = [1, 4, 12, 28, 60]
+HORIZON_LABELS = {1: "6h", 4: "24h", 12: "72h", 28: "7d", 60: "15d"}
+S1_SEEDS = [20260902, 20260903, 20260904]
+GROUPS = dict(s2r2.GROUPS)
+METHODS = [
+    "persistence",
+    "parent_single",
+    "parent_explicit_band",
+    "medium_single",
+    "medium_explicit_no_band",
+    "medium_explicit_band",
+]
+OCEAN_BINS = {
+    "coastal": (0.10, 0.50),
+    "shelf": (0.50, 0.85),
+    "open_ocean": (0.85, 1.000001),
+}
+
+
+def json_default(value: Any) -> Any:
+    return data_runtime.json_default(value)
+
+
+def atomic_json(payload: Any, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(
+        json.dumps(payload, ensure_ascii=False, indent=2, default=json_default),
+        encoding="utf-8",
+    )
+    os.replace(tmp, path)
+
+
+def stage(index: int, total: int, title: str) -> None:
+    print(f"\n[V3-S4-A0] 阶段 {index}/{total}：{title}", flush=True)
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def seed_everything(seed: int) -> None:
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+
+def hf_download_file(
+    repo_id: str,
+    repo_path: str,
+    local_path: Path,
+    token: Optional[str],
+) -> bool:
+    try:
+        from huggingface_hub import hf_hub_download
+        downloaded = Path(
+            hf_hub_download(
+                repo_id=repo_id,
+                filename=repo_path,
+                repo_type="dataset",
+                token=token,
+            )
+        )
+    except Exception as exc:
+        print(f"[HF miss] {repo_path}: {exc}", flush=True)
+        return False
+    local_path.parent.mkdir(parents=True, exist_ok=True)
+    if local_path.exists() or local_path.is_symlink():
+        local_path.unlink()
+    try:
+        local_path.symlink_to(downloaded)
+    except Exception:
+        shutil.copy2(downloaded, local_path)
+    print(f"[HF restored] {repo_path}", flush=True)
+    return True
+
+
+def ensure_parent_assets(args: argparse.Namespace) -> Dict[str, Any]:
+    token = args.hf_token or os.environ.get("HF_TOKEN") or None
+    s3a1_zip = Path(args.s3a1_zip)
+    s3a0_zip = Path(args.s3a0_zip)
+    if not s3a1_zip.is_file():
+        candidates = [
+            "Experiments/V3_S3_A1/CIDM_v3_SCS_V3_S3_A1.zip",
+            "CIDM_v3_SCS_V3_S3_A1.zip",
+        ]
+        for candidate in candidates:
+            if hf_download_file(args.hf_repo_id, candidate, s3a1_zip, token):
+                break
+    if not s3a0_zip.is_file():
+        candidates = [
+            "Experiments/V3_S3_A0/CIDM_v3_SCS_V3_S3_A0.zip",
+            "CIDM_v3_SCS_V3_S3_A0.zip",
+        ]
+        for candidate in candidates:
+            if hf_download_file(args.hf_repo_id, candidate, s3a0_zip, token):
+                break
+    if not s3a1_zip.is_file() or not s3a0_zip.is_file():
+        raise FileNotFoundError(
+            f"Missing parents: S3-A1={s3a1_zip.is_file()}, "
+            f"S3-A0={s3a0_zip.is_file()}"
+        )
+    return {
+        "s3a1_sha256": sha256_file(s3a1_zip),
+        "s3a0_sha256": sha256_file(s3a0_zip),
+    }
+
+
+def native_file_map(root: Path) -> Dict[str, Path]:
+    return {
+        "data": root / "scs_c0_data.npy",
+        "mask": root / "scs_c0_mask.npy",
+        "variable_masks": root / "scs_c0_variable_masks.npy",
+        "metadata": root / "scs_c0_metadata.json",
+        "audit": root / "C0_data_audit.csv",
+    }
+
+
+def native_cache_valid(root: Path) -> bool:
+    files = native_file_map(root)
+    if not all(path.is_file() for path in files.values()):
+        return False
+    try:
+        metadata = json.loads(files["metadata"].read_text(encoding="utf-8"))
+        return (
+            len(metadata["shape"]) == 4
+            and int(metadata["shape"][1]) == len(VARIABLE_NAMES)
+            and abs(float(metadata["native_resolution_degrees"]) - 1 / 12) < 1e-6
+        )
+    except Exception:
+        return False
+
+
+def restore_native_from_hf(
+    args: argparse.Namespace,
+    season: str,
+    destination: Path,
+) -> bool:
+    token = args.hf_token or os.environ.get("HF_TOKEN") or None
+    destination.mkdir(parents=True, exist_ok=True)
+    downloaded: List[Path] = []
+    for filename in [
+        "scs_c0_data.npy",
+        "scs_c0_mask.npy",
+        "scs_c0_variable_masks.npy",
+        "scs_c0_metadata.json",
+        "C0_data_audit.csv",
+    ]:
+        local_path = destination / filename
+        if local_path.is_file():
+            continue
+        repo_path = f"Cache/native_1_12/{season}/{filename}"
+        if not hf_download_file(args.hf_repo_id, repo_path, local_path, token):
+            for path in downloaded:
+                path.unlink(missing_ok=True)
+            return False
+        downloaded.append(local_path)
+    return native_cache_valid(destination)
+
+
+def prepare_native_season(
+    args: argparse.Namespace,
+    season: str,
+) -> Tuple[Path, Dict[str, Any]]:
+    destination = Path(args.native_cache_dir) / season / "prepared"
+    if native_cache_valid(destination):
+        return destination, {"season": season, "source": "local"}
+    if restore_native_from_hf(args, season, destination):
+        return destination, {"season": season, "source": "hf"}
+    if args.no_live_download:
+        raise FileNotFoundError(
+            f"Native 1/12° cache missing for {season}; live download disabled."
+        )
+
+    print(
+        f"[CMEMS native download] {season}: "
+        f"{SEASONS[season]['start']} .. {SEASONS[season]['end']}",
+        flush=True,
+    )
+    root = Path(args.native_cache_dir) / season
+    build_args = argparse.Namespace(
+        start_datetime=SEASONS[season]["start"],
+        end_datetime=SEASONS[season]["end"],
+        minimum_time_steps=100,
+    )
+    prepared = data_runtime.prepare_cmems_cube(build_args, root)
+    if prepared != destination or not native_cache_valid(prepared):
+        raise RuntimeError(f"Native preparation failed: {season}")
+    if args.delete_native_raw:
+        shutil.rmtree(root / "raw", ignore_errors=True)
+    return prepared, {"season": season, "source": "cmems_live"}
+
+
+def extract_s3a0_assets(
+    zip_path: Path,
+    destination: Path,
+) -> Dict[str, Any]:
+    destination.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(zip_path) as archive:
+        archive.extractall(destination)
+    verdicts = list(destination.rglob("V3S1R3_verdict.json"))
+    if len(verdicts) != 1:
+        raise RuntimeError(f"Expected one nested S1-R3 verdict, found {len(verdicts)}")
+    s1_root = verdicts[0].parent
+    metadata_path = s1_root / "scs_c0_metadata.json"
+    if not metadata_path.is_file():
+        raise FileNotFoundError(metadata_path)
+
+    explicit = {}
+    for path in (s1_root / "checkpoints" / "slowfast_causal").glob("seed_*.pt"):
+        payload = torch.load(path, map_location="cpu", weights_only=False)
+        explicit[int(payload["seed"])] = path
+    single = {}
+    for path in s1_root.rglob("checkpoints/single/seed_*.pt"):
+        payload = torch.load(path, map_location="cpu", weights_only=False)
+        seed = int(payload["seed"])
+        if seed not in single:
+            single[seed] = path
+    return {
+        "metadata": json.loads(metadata_path.read_text(encoding="utf-8")),
+        "explicit_parent_checkpoints": explicit,
+        "single_parent_checkpoints": single,
+    }
+
+
+def extract_s3a1_assets(
+    zip_path: Path,
+    destination: Path,
+) -> Dict[str, Any]:
+    destination.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(zip_path) as archive:
+        archive.extractall(destination)
+    verdicts = list(destination.rglob("S3A1_verdict.json"))
+    if len(verdicts) != 1:
+        raise RuntimeError(f"Expected one S3-A1 verdict, found {len(verdicts)}")
+    root = verdicts[0].parent
+    explicit = {}
+    single = {}
+    for path in (root / "checkpoints" / "explicit").glob("seed_*.pt"):
+        payload = torch.load(path, map_location="cpu", weights_only=False)
+        explicit[int(payload["seed"])] = path
+    for path in (root / "checkpoints" / "single").glob("seed_*.pt"):
+        payload = torch.load(path, map_location="cpu", weights_only=False)
+        single[int(payload["seed"])] = path
+    missing = [
+        seed for seed in S1_SEEDS
+        if seed not in explicit or seed not in single
+    ]
+    if missing:
+        raise RuntimeError(f"S3-A1 repaired checkpoints missing: {missing}")
+    return {
+        "root": root,
+        "verdict": json.loads(verdicts[0].read_text(encoding="utf-8")),
+        "explicit_checkpoints": explicit,
+        "single_checkpoints": single,
+    }
+
+
+def ocean_bin(fraction: float) -> str:
+    for name, (low, high) in OCEAN_BINS.items():
+        if low <= fraction < high:
+            return name
+    return "excluded"
+
+
+class SeasonCube:
+    def __init__(
+        self,
+        season: str,
+        root: Path,
+        reference_mean: np.ndarray,
+        reference_std: np.ndarray,
+        history: int,
+        patch_size: int,
+        maximum_horizon: int,
+    ):
+        self.season = season
+        self.data = np.load(root / "scs_c0_data.npy", mmap_mode="r")
+        self.variable_masks = np.load(
+            root / "scs_c0_variable_masks.npy", mmap_mode="r"
+        )
+        self.metadata = json.loads(
+            (root / "scs_c0_metadata.json").read_text(encoding="utf-8")
+        )
+        self.window_mean = np.asarray(self.metadata["means"], dtype=np.float32)
+        self.window_std = np.asarray(self.metadata["stds"], dtype=np.float32)
+        self.reference_mean = np.asarray(reference_mean, dtype=np.float32)
+        self.reference_std = np.asarray(reference_std, dtype=np.float32)
+        self.history = history
+        self.patch_size = patch_size
+        self.maximum_horizon = maximum_horizon
+        self.valid_times = np.arange(
+            history - 1,
+            self.data.shape[0] - maximum_horizon,
+            dtype=np.int64,
+        )
+        self.height, self.width = self.data.shape[-2:]
+
+    def valid_fraction(self, y: int, x: int) -> float:
+        p = self.patch_size
+        mask = self.variable_masks[:, y:y+p, x:x+p]
+        return float(mask.mean())
+
+    def sample(
+        self,
+        time_index: int,
+        y: int,
+        x: int,
+    ) -> Dict[str, torch.Tensor]:
+        p = self.patch_size
+        history_window = np.asarray(
+            self.data[
+                time_index - self.history + 1:time_index + 1,
+                :,
+                y:y+p,
+                x:x+p,
+            ],
+            dtype=np.float32,
+        ).copy()
+        future_window = np.asarray(
+            self.data[
+                time_index + 1:time_index + self.maximum_horizon + 1,
+                :,
+                y:y+p,
+                x:x+p,
+            ],
+            dtype=np.float32,
+        ).copy()
+        mask = np.asarray(
+            self.variable_masks[:, y:y+p, x:x+p],
+            dtype=np.float32,
+        ).copy()
+
+        history_physical = (
+            history_window * self.window_std[None, :, None, None]
+            + self.window_mean[None, :, None, None]
+        )
+        future_physical = (
+            future_window * self.window_std[None, :, None, None]
+            + self.window_mean[None, :, None, None]
+        )
+        history = (
+            history_physical - self.reference_mean[None, :, None, None]
+        ) / self.reference_std[None, :, None, None]
+        future = (
+            future_physical - self.reference_mean[None, :, None, None]
+        ) / self.reference_std[None, :, None, None]
+        valid_fraction = float(mask.mean())
+        return {
+            "history": torch.from_numpy(history.astype(np.float32)),
+            "future": torch.from_numpy(future.astype(np.float32)),
+            "mask": torch.from_numpy(mask),
+            "time_index": torch.tensor(time_index, dtype=torch.long),
+            "origin_y": torch.tensor(y, dtype=torch.long),
+            "origin_x": torch.tensor(x, dtype=torch.long),
+            "valid_count": torch.tensor(float(mask.sum()), dtype=torch.float32),
+            "ocean_fraction": torch.tensor(valid_fraction, dtype=torch.float32),
+            "ocean_bin_id": torch.tensor(
+                list(OCEAN_BINS).index(ocean_bin(valid_fraction)),
+                dtype=torch.long,
+            ),
+        }
+
+
+class MultiSeasonPatchDataset(Dataset):
+    def __init__(
+        self,
+        cubes: Mapping[str, SeasonCube],
+        samples: int,
+        seed: int,
+        balanced: bool,
+        minimum_ocean_fraction: float,
+    ):
+        self.cubes = dict(cubes)
+        self.seasons = list(self.cubes)
+        self.records: List[Tuple[str, int, int, int, str]] = []
+        generator = np.random.default_rng(seed)
+        used = set()
+
+        targets: List[Tuple[str, str]] = []
+        if balanced:
+            combinations = [
+                (season, bin_name)
+                for season in self.seasons
+                for bin_name in OCEAN_BINS
+            ]
+            for index in range(samples):
+                targets.append(combinations[index % len(combinations)])
+        else:
+            for index in range(samples):
+                targets.append((self.seasons[index % len(self.seasons)], "any"))
+
+        for season, requested_bin in targets:
+            cube = self.cubes[season]
+            max_y = cube.height - cube.patch_size
+            max_x = cube.width - cube.patch_size
+            selected = None
+            for _ in range(5000):
+                time_index = int(generator.choice(cube.valid_times))
+                y = int(generator.integers(0, max_y + 1))
+                x = int(generator.integers(0, max_x + 1))
+                fraction = cube.valid_fraction(y, x)
+                current_bin = ocean_bin(fraction)
+                key = (season, time_index, y, x)
+                if key in used or fraction < minimum_ocean_fraction:
+                    continue
+                if requested_bin != "any" and current_bin != requested_bin:
+                    continue
+                selected = (season, time_index, y, x, current_bin)
+                break
+            if selected is None:
+                raise RuntimeError(
+                    f"Could not sample season={season}, bin={requested_bin}"
+                )
+            used.add(selected[:4])
+            self.records.append(selected)
+
+    def __len__(self) -> int:
+        return len(self.records)
+
+    def __getitem__(self, item: int) -> Dict[str, torch.Tensor]:
+        season, time_index, y, x, current_bin = self.records[item]
+        result = self.cubes[season].sample(time_index, y, x)
+        result["sample_index"] = torch.tensor(item, dtype=torch.long)
+        result["season_id"] = torch.tensor(
+            self.seasons.index(season), dtype=torch.long
+        )
+        return result
+
+
+def build_datasets(
+    native_roots: Mapping[str, Path],
+    reference_mean: np.ndarray,
+    reference_std: np.ndarray,
+    args: argparse.Namespace,
+) -> Tuple[Dict[str, MultiSeasonPatchDataset], Dict[str, SeasonCube]]:
+    cubes = {
+        season: SeasonCube(
+            season,
+            root,
+            reference_mean,
+            reference_std,
+            args.history,
+            args.patch_size,
+            args.max_horizon,
+        )
+        for season, root in native_roots.items()
+    }
+    datasets = {
+        "train": MultiSeasonPatchDataset(
+            {season: cubes[season] for season in ["winter", "spring"]},
+            args.train_samples,
+            args.train_seed,
+            balanced=True,
+            minimum_ocean_fraction=args.minimum_ocean_fraction,
+        ),
+        "validation": MultiSeasonPatchDataset(
+            {"summer": cubes["summer"]},
+            args.validation_samples,
+            args.validation_seed,
+            balanced=True,
+            minimum_ocean_fraction=args.minimum_ocean_fraction,
+        ),
+        "test": MultiSeasonPatchDataset(
+            {"autumn": cubes["autumn"]},
+            args.test_samples,
+            args.test_seed,
+            balanced=True,
+            minimum_ocean_fraction=args.minimum_ocean_fraction,
+        ),
+    }
+    return datasets, cubes
+
+
+def build_loaders(
+    datasets: Mapping[str, Dataset],
+    args: argparse.Namespace,
+) -> Dict[str, DataLoader]:
+    return {
+        "train": DataLoader(
+            datasets["train"],
+            batch_size=args.batch_size,
+            shuffle=True,
+            num_workers=args.num_workers,
+            pin_memory=torch.cuda.is_available(),
+        ),
+        "validation": DataLoader(
+            datasets["validation"],
+            batch_size=args.batch_size,
+            shuffle=False,
+            num_workers=args.num_workers,
+            pin_memory=torch.cuda.is_available(),
+        ),
+        "test": DataLoader(
+            datasets["test"],
+            batch_size=args.batch_size,
+            shuffle=False,
+            num_workers=args.num_workers,
+            pin_memory=torch.cuda.is_available(),
+        ),
+    }
+
+
+def instantiate_repaired_models(
+    parent_assets: Mapping[str, Any],
+    repaired_assets: Mapping[str, Any],
+    seed: int,
+    device: torch.device,
+) -> Tuple[nn.Module, nn.Module]:
+    explicit = s3a0.make_explicit(
+        parent_assets["explicit_parent_checkpoints"][seed],
+        device,
+    )
+    single = s3a0.make_single(
+        parent_assets["single_parent_checkpoints"][seed],
+        device,
+    )
+    explicit_payload = torch.load(
+        repaired_assets["explicit_checkpoints"][seed],
+        map_location="cpu",
+        weights_only=False,
+    )
+    single_payload = torch.load(
+        repaired_assets["single_checkpoints"][seed],
+        map_location="cpu",
+        weights_only=False,
+    )
+    explicit.load_state_dict(explicit_payload["model_state"], strict=True)
+    single.load_state_dict(single_payload["model_state"], strict=True)
+    return explicit, single
+
+
+def set_explicit_trainable_full(model: nn.Module) -> List[nn.Parameter]:
+    for parameter in model.parameters():
+        parameter.requires_grad = False
+    retained = [
+        model.encoder,
+        model.enc_film,
+        model.frame,
+        model.core,
+        model.decoder,
+        model.dec_film,
+        model.scale_out,
+        model.band_energy_closure,
+    ]
+    parameters: List[nn.Parameter] = []
+    for module in retained:
+        for parameter in module.parameters():
+            parameter.requires_grad = True
+            parameters.append(parameter)
+    # Deferred modules remain frozen even if present in the class.
+    for module in [
+        model.flux,
+        model.rt_closure,
+        model.slow_memory,
+        model.vertical_closure,
+        model.causal_variance,
+    ]:
+        for parameter in module.parameters():
+            parameter.requires_grad = False
+    return parameters
+
+
+def set_single_trainable(model: nn.Module) -> List[nn.Parameter]:
+    parameters = []
+    for parameter in model.parameters():
+        parameter.requires_grad = True
+        parameters.append(parameter)
+    return parameters
+
+
+def schedule(args: argparse.Namespace) -> List[int]:
+    base = [12, 20, 28, 40, 60, 60, 60]
+    if args.epochs <= len(base):
+        return base[:args.epochs]
+    return base + [60] * (args.epochs - len(base))
+
+
+
+def resume_repo_path(kind: str, seed: int) -> str:
+    return (
+        "Experiments/V3_S4_A0/resume/"
+        f"{kind}_seed_{seed}_latest.pt"
+    )
+
+
+def restore_resume_checkpoint(
+    args: argparse.Namespace,
+    kind: str,
+    seed: int,
+    local_path: Path,
+) -> Optional[Dict[str, Any]]:
+    if not args.resume or args.synthetic_smoke:
+        return None
+    token = args.hf_token or os.environ.get("HF_TOKEN") or None
+    if not token:
+        return None
+    if not hf_download_file(
+        args.hf_repo_id,
+        resume_repo_path(kind, seed),
+        local_path,
+        token,
+    ):
+        return None
+    payload = torch.load(
+        local_path, map_location="cpu", weights_only=False
+    )
+    saved_args = payload.get("args", {})
+    contract_keys = [
+        "train_samples",
+        "validation_samples",
+        "epochs",
+        "accumulation",
+        "minimum_ocean_fraction",
+    ]
+    mismatches = {
+        key: (saved_args.get(key), getattr(args, key))
+        for key in contract_keys
+        if saved_args.get(key) != getattr(args, key)
+    }
+    if mismatches:
+        print(
+            f"[resume ignored] {kind} seed={seed}, "
+            f"contract mismatch={mismatches}",
+            flush=True,
+        )
+        local_path.unlink(missing_ok=True)
+        return None
+    print(
+        f"[resume restored] {kind} seed={seed}, "
+        f"epoch={payload.get('epoch')}",
+        flush=True,
+    )
+    return payload
+
+
+def upload_resume_checkpoint(
+    args: argparse.Namespace,
+    kind: str,
+    seed: int,
+    local_path: Path,
+) -> None:
+    if not args.upload_each_epoch or args.synthetic_smoke:
+        return
+    token = args.hf_token or os.environ.get("HF_TOKEN") or None
+    if not token:
+        print(
+            "[resume upload skipped] HF_TOKEN unavailable",
+            flush=True,
+        )
+        return
+    from huggingface_hub import HfApi
+    HfApi(token=token).upload_file(
+        path_or_fileobj=str(local_path),
+        path_in_repo=resume_repo_path(kind, seed),
+        repo_id=args.hf_repo_id,
+        repo_type="dataset",
+    )
+    print(
+        f"[resume uploaded] {kind} seed={seed}",
+        flush=True,
+    )
+
+
+def train_medium(
+    model: nn.Module,
+    kind: str,
+    seed: int,
+    loaders: Mapping[str, DataLoader],
+    device: torch.device,
+    means: torch.Tensor,
+    stds: torch.Tensor,
+    args: argparse.Namespace,
+    output_dir: Path,
+) -> Tuple[nn.Module, Dict[str, Any]]:
+    seed_everything(seed)
+    if kind == "explicit":
+        parameters = set_explicit_trainable_full(model)
+        learning_rate = args.explicit_learning_rate
+    else:
+        parameters = set_single_trainable(model)
+        learning_rate = args.single_learning_rate
+
+    optimizer = torch.optim.AdamW(
+        parameters,
+        lr=learning_rate,
+        weight_decay=args.weight_decay,
+    )
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+        optimizer,
+        T_max=max(args.epochs, 1),
+        eta_min=learning_rate * 0.2,
+    )
+    best_score = float("inf")
+    best_epoch = -1
+    best_state = None
+    best_optimizer = None
+    logs = []
+    start_time = time.time()
+    horizons = schedule(args)
+    resume_path = (
+        output_dir / "resume" / f"{kind}_seed_{seed}_latest.pt"
+    )
+    resume_payload = restore_resume_checkpoint(
+        args, kind, seed, resume_path
+    )
+    start_epoch = 1
+    if resume_payload is not None:
+        model.load_state_dict(
+            resume_payload["model_state"], strict=True
+        )
+        optimizer.load_state_dict(
+            resume_payload["optimizer_state"]
+        )
+        scheduler.load_state_dict(
+            resume_payload["scheduler_state"]
+        )
+        best_state = resume_payload.get("best_state")
+        best_score = float(
+            resume_payload.get("best_score", best_score)
+        )
+        best_epoch = int(
+            resume_payload.get("best_epoch", best_epoch)
+        )
+        start_epoch = int(resume_payload["epoch"]) + 1
+
+    for epoch, horizon in enumerate(horizons, start=1):
+        if epoch < start_epoch:
+            continue
+        model.train()
+        optimizer.zero_grad(set_to_none=True)
+        totals: Dict[str, float] = {}
+        for batch_index, batch in enumerate(loaders["train"], start=1):
+            history = batch["history"].to(device, non_blocking=True)
+            future = batch["future"].to(device, non_blocking=True)
+            mask = batch["mask"].to(device, non_blocking=True)
+            if kind == "explicit":
+                outputs = s3a1.rollout_explicit_train(
+                    model, history, mask, horizon
+                )
+            else:
+                outputs = s3a1.rollout_single_train(
+                    model, history, mask, horizon
+                )
+            parts = s3a1.sequence_objective(
+                outputs,
+                history,
+                future[:, :horizon],
+                mask,
+                means,
+                stds,
+                args,
+            )
+            if not torch.isfinite(parts["total"]):
+                raise RuntimeError(
+                    f"Non-finite loss kind={kind}, seed={seed}, "
+                    f"epoch={epoch}, batch={batch_index}"
+                )
+            (parts["total"] / args.accumulation).backward()
+            if (
+                batch_index % args.accumulation == 0
+                or batch_index == len(loaders["train"])
+            ):
+                torch.nn.utils.clip_grad_norm_(parameters, args.grad_clip)
+                optimizer.step()
+                optimizer.zero_grad(set_to_none=True)
+            for key, value in parts.items():
+                totals[key] = totals.get(key, 0.0) + float(value.detach())
+
+            if batch_index % max(len(loaders["train"]) // 5, 1) == 0:
+                elapsed = time.time() - start_time
+                completed = (
+                    (epoch - 1) * len(loaders["train"]) + batch_index
+                )
+                total_batches = len(horizons) * len(loaders["train"])
+                eta = elapsed / max(completed, 1) * max(total_batches - completed, 0)
+                print(
+                    f"[{kind} seed={seed}] epoch={epoch}/{args.epochs} "
+                    f"H={horizon} batch={batch_index}/{len(loaders['train'])} "
+                    f"loss={totals['total']/batch_index:.6f} "
+                    f"ETA={eta/3600:.2f}h",
+                    flush=True,
+                )
+
+        scheduler.step()
+        validation = s3a1.validation_score(
+            model,
+            kind,
+            loaders["validation"],
+            device,
+            means,
+            stds,
+        )
+        row = {
+            "kind": kind,
+            "seed": seed,
+            "epoch": epoch,
+            "train_horizon": horizon,
+            "learning_rate": optimizer.param_groups[0]["lr"],
+            **{
+                f"train_{key}": value / max(len(loaders["train"]), 1)
+                for key, value in totals.items()
+            },
+            **{
+                f"validation_{key}": value
+                for key, value in validation.items()
+            },
+        }
+        logs.append(row)
+        print(
+            f"[VAL {kind} seed={seed}] epoch={epoch} "
+            f"score={validation['score']:.6f} "
+            f"72h={validation['rmse_h12']:.5f} "
+            f"7d={validation['rmse_h28']:.5f} "
+            f"15d={validation['rmse_h60']:.5f}",
+            flush=True,
+        )
+        if validation["score"] < best_score:
+            best_score = validation["score"]
+            best_epoch = epoch
+            best_state = {
+                key: value.detach().cpu().clone()
+                for key, value in model.state_dict().items()
+            }
+            best_optimizer = copy.deepcopy(optimizer.state_dict())
+
+        epoch_dir = output_dir / "resume"
+        epoch_dir.mkdir(parents=True, exist_ok=True)
+        latest_path = epoch_dir / f"{kind}_seed_{seed}_latest.pt"
+        torch.save(
+            {
+                "kind": kind,
+                "seed": seed,
+                "epoch": epoch,
+                "model_state": model.state_dict(),
+                "optimizer_state": optimizer.state_dict(),
+                "scheduler_state": scheduler.state_dict(),
+                "best_state": best_state,
+                "best_score": best_score,
+                "best_epoch": best_epoch,
+                "args": vars(args),
+            },
+            latest_path,
+        )
+        upload_resume_checkpoint(
+            args, kind, seed, latest_path
+        )
+
+    if best_state is None:
+        raise RuntimeError(f"No checkpoint selected for {kind} seed={seed}")
+    model.load_state_dict(best_state, strict=True)
+    checkpoint_dir = output_dir / "checkpoints" / kind
+    checkpoint_dir.mkdir(parents=True, exist_ok=True)
+    checkpoint = checkpoint_dir / f"seed_{seed}.pt"
+    torch.save(
+        {
+            "kind": kind,
+            "seed": seed,
+            "best_epoch": best_epoch,
+            "best_score": best_score,
+            "model_state": best_state,
+            "optimizer_state_at_best": best_optimizer,
+            "args": vars(args),
+            "architecture_change": "none",
+            "training_scope": "multi-season medium-scale qualification",
+        },
+        checkpoint,
+    )
+    log_path = output_dir / "training" / f"{kind}_seed_{seed}.csv"
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    pd.DataFrame(logs).to_csv(log_path, index=False)
+    return model, {
+        "kind": kind,
+        "seed": seed,
+        "best_epoch": best_epoch,
+        "best_score": best_score,
+        "checkpoint": str(checkpoint),
+    }
+
+
+def empty_accumulator() -> Dict[str, Any]:
+    return {
+        "squared": {step: 0.0 for step in HORIZONS},
+        "count": {step: 0.0 for step in HORIZONS},
+        "pred": {step: [] for step in HORIZONS},
+        "target": {step: [] for step in HORIZONS},
+        "samples": [],
+        "groups": {
+            (step, group): []
+            for step in HORIZONS
+            for group in GROUPS
+        },
+        "finite": True,
+        "max_abs": 0.0,
+        "wave_invalid": {step: [] for step in HORIZONS},
+        "direction_norm": {step: [] for step in HORIZONS},
+        "spectral_pred": {step: [] for step in [12, 28, 60]},
+        "spectral_target": {step: [] for step in [12, 28, 60]},
+    }
+
+
+def update_accumulator(
+    accumulator: Dict[str, Any],
+    outputs: Sequence[torch.Tensor],
+    future: torch.Tensor,
+    mask: torch.Tensor,
+    batch: Mapping[str, torch.Tensor],
+    means: torch.Tensor,
+    stds: torch.Tensor,
+) -> None:
+    for step in HORIZONS:
+        prediction = outputs[step - 1]
+        target = future[:, step - 1]
+        error = (prediction - target).square() * mask
+        sample_sse = error.flatten(1).sum(dim=1)
+        sample_count = mask.flatten(1).sum(dim=1).clamp_min(1.0)
+        sample_mse = sample_sse / sample_count
+        accumulator["squared"][step] += float(sample_sse.sum())
+        accumulator["count"][step] += float(sample_count.sum())
+        accumulator["pred"][step].append((prediction * mask).flatten(1).cpu())
+        accumulator["target"][step].append((target * mask).flatten(1).cpu())
+
+        for bi in range(prediction.shape[0]):
+            fraction = float(batch["ocean_fraction"][bi])
+            accumulator["samples"].append({
+                "sample_index": int(batch["sample_index"][bi]),
+                "time_index": int(batch["time_index"][bi]),
+                "origin_y": int(batch["origin_y"][bi]),
+                "origin_x": int(batch["origin_x"][bi]),
+                "horizon": step,
+                "sse": float(sample_sse[bi]),
+                "valid_count": float(sample_count[bi]),
+                "mse": float(sample_mse[bi]),
+                "rmse": math.sqrt(max(float(sample_mse[bi]), 0.0)),
+                "ocean_fraction": fraction,
+                "ocean_bin": ocean_bin(fraction),
+            })
+
+        for group, indices in GROUPS.items():
+            group_mask = mask[:, indices]
+            group_error = error[:, indices]
+            denominator = group_mask.flatten(1).sum(dim=1).clamp_min(1.0)
+            values = torch.sqrt(
+                group_error.flatten(1).sum(dim=1) / denominator
+            )
+            accumulator["groups"][(step, group)].extend(values.cpu().tolist())
+
+        invalid, direction = s3a0.physical_wave_audit(
+            prediction, means, stds, mask
+        )
+        accumulator["wave_invalid"][step].extend(invalid.cpu().tolist())
+        accumulator["direction_norm"][step].extend(direction.cpu().tolist())
+
+        if step in accumulator["spectral_pred"]:
+            accumulator["spectral_pred"][step].append(
+                s3a0.spectral_energy_ratios(prediction, mask).cpu()
+            )
+            accumulator["spectral_target"][step].append(
+                s3a0.spectral_energy_ratios(target, mask).cpu()
+            )
+
+        accumulator["finite"] = (
+            accumulator["finite"] and bool(torch.isfinite(prediction).all())
+        )
+        accumulator["max_abs"] = max(
+            accumulator["max_abs"], float(prediction.abs().max())
+        )
+
+
+def finalize_accumulator(accumulator: Dict[str, Any]) -> Dict[str, Any]:
+    result = {
+        "finite": bool(accumulator["finite"]),
+        "max_abs": float(accumulator["max_abs"]),
+    }
+    for step in HORIZONS:
+        result[f"rmse_h{step}"] = math.sqrt(
+            accumulator["squared"][step]
+            / max(accumulator["count"][step], 1.0)
+        )
+        prediction = torch.cat(accumulator["pred"][step], dim=0)
+        target = torch.cat(accumulator["target"][step], dim=0)
+        result[f"variance_ratio_h{step}"] = float(
+            prediction.var(unbiased=False)
+            / (target.var(unbiased=False) + 1e-8)
+        )
+        result[f"wave_invalid_fraction_h{step}"] = float(
+            np.mean(accumulator["wave_invalid"][step])
+        )
+        result[f"direction_norm_error_h{step}"] = float(
+            np.mean(accumulator["direction_norm"][step])
+        )
+        for group in GROUPS:
+            result[f"group_rmse_{group}_h{step}"] = float(
+                np.mean(accumulator["groups"][(step, group)])
+            )
+        if step in accumulator["spectral_pred"]:
+            pred_energy = torch.cat(
+                accumulator["spectral_pred"][step], dim=0
+            ).mean(dim=0)
+            target_energy = torch.cat(
+                accumulator["spectral_target"][step], dim=0
+            ).mean(dim=0)
+            ratio = pred_energy / (target_energy + 1e-8)
+            for index, band in enumerate(["low", "mid", "high"]):
+                result[f"spectral_{band}_ratio_h{step}"] = float(ratio[index])
+    result["sample_rows"] = accumulator["samples"]
+    return result
+
+
+@torch.no_grad()
+def evaluate_methods(
+    models: Mapping[str, nn.Module],
+    loader: DataLoader,
+    device: torch.device,
+    means: torch.Tensor,
+    stds: torch.Tensor,
+) -> Tuple[Dict[str, Dict[str, Any]], Dict[str, pd.DataFrame]]:
+    accumulators = {method: empty_accumulator() for method in METHODS}
+    for batch_number, batch in enumerate(loader, start=1):
+        history = batch["history"].to(device)
+        future = batch["future"].to(device)
+        mask = batch["mask"].to(device)
+        persistence = [history[:, -1] * mask for _ in range(60)]
+        outputs = {
+            "persistence": persistence,
+            "parent_single": s3a1.rollout_single(
+                models["parent_single"], history, mask, 60
+            ),
+            "parent_explicit_band": s3a1.rollout_explicit(
+                models["parent_explicit"], history, mask, 60, True
+            ),
+            "medium_single": s3a1.rollout_single(
+                models["medium_single"], history, mask, 60
+            ),
+            "medium_explicit_no_band": s3a1.rollout_explicit(
+                models["medium_explicit"], history, mask, 60, False
+            ),
+            "medium_explicit_band": s3a1.rollout_explicit(
+                models["medium_explicit"], history, mask, 60, True
+            ),
+        }
+        for method, current in outputs.items():
+            update_accumulator(
+                accumulators[method],
+                current,
+                future,
+                mask,
+                batch,
+                means,
+                stds,
+            )
+        if batch_number % max(len(loader) // 6, 1) == 0:
+            print(f"[test] batch={batch_number}/{len(loader)}", flush=True)
+
+    metrics = {}
+    tables = {}
+    for method, accumulator in accumulators.items():
+        current = finalize_accumulator(accumulator)
+        tables[method] = pd.DataFrame(current.pop("sample_rows"))
+        metrics[method] = current
+    return metrics, tables
+
+
+def block_bootstrap(
+    reference_tables: Sequence[pd.DataFrame],
+    candidate_tables: Sequence[pd.DataFrame],
+    horizon: int,
+    repetitions: int,
+    seed: int,
+) -> Dict[str, float]:
+    return s3a1.time_block_bootstrap(
+        reference_tables,
+        candidate_tables,
+        horizon,
+        repetitions,
+        seed,
+    )
+
+
+def ocean_bin_comparison(
+    candidate_tables: Sequence[pd.DataFrame],
+    reference_tables: Sequence[pd.DataFrame],
+    horizon: int,
+) -> List[Dict[str, Any]]:
+    candidate = pd.concat(candidate_tables, ignore_index=True)
+    reference = pd.concat(reference_tables, ignore_index=True)
+    keys = [
+        "seed",
+        "sample_index",
+        "time_index",
+        "origin_y",
+        "origin_x",
+        "horizon",
+        "ocean_bin",
+        "ocean_fraction",
+        "valid_count",
+    ]
+    merged = reference.merge(
+        candidate,
+        on=keys,
+        suffixes=("_reference", "_candidate"),
+    )
+    merged = merged[merged.horizon == horizon]
+    rows = []
+    for bin_name in OCEAN_BINS:
+        current = merged[merged.ocean_bin == bin_name]
+        if current.empty:
+            continue
+        reference_mse = (
+            current.sse_reference.sum() / current.valid_count.sum()
+        )
+        candidate_mse = (
+            current.sse_candidate.sum() / current.valid_count.sum()
+        )
+        rows.append({
+            "horizon": horizon,
+            "lead": HORIZON_LABELS[horizon],
+            "ocean_bin": bin_name,
+            "samples_with_seed_repeats": len(current),
+            "mean_ocean_fraction": float(current.ocean_fraction.mean()),
+            "weighted_mse_gain_percent": float(
+                100.0 * (reference_mse - candidate_mse)
+                / max(reference_mse, 1e-12)
+            ),
+            "equal_sample_mse_gain_percent": float(
+                100.0
+                * (
+                    current.mse_reference.mean()
+                    - current.mse_candidate.mean()
+                )
+                / max(current.mse_reference.mean(), 1e-12)
+            ),
+            "fraction_improved": float(
+                (current.mse_candidate < current.mse_reference).mean()
+            ),
+        })
+    return rows
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="CIDM-v3 multi-season medium-scale qualification"
+    )
+    parser.add_argument(
+        "--s3a1_zip",
+        default="/content/CIDM_v3_SCS_V3_S3_A1.zip",
+    )
+    parser.add_argument(
+        "--s3a0_zip",
+        default="/content/CIDM_v3_SCS_V3_S3_A0.zip",
+    )
+    parser.add_argument(
+        "--native_cache_dir",
+        default="/content/CIDM_v3_SCS_S2A2_NATIVE_1_12",
+    )
+    parser.add_argument(
+        "--parent_cache",
+        default="/content/CIDM_v3_SCS_S4A0_PARENT_CACHE",
+    )
+    parser.add_argument(
+        "--output_dir",
+        default="/content/CIDM_v3_SCS_V3_S4_A0",
+    )
+    parser.add_argument(
+        "--hf_repo_id",
+        default="wuff-mann/CIDM-v3-SCS-S2A0-Data",
+    )
+    parser.add_argument("--hf_token", default="")
+    parser.add_argument("--history", type=int, default=4)
+    parser.add_argument("--patch_size", type=int, default=48)
+    parser.add_argument("--max_horizon", type=int, default=60)
+    parser.add_argument("--minimum_ocean_fraction", type=float, default=0.10)
+    parser.add_argument("--train_samples", type=int, default=288)
+    parser.add_argument("--validation_samples", type=int, default=72)
+    parser.add_argument("--test_samples", type=int, default=96)
+    parser.add_argument("--train_seed", type=int, default=20261031)
+    parser.add_argument("--validation_seed", type=int, default=20261101)
+    parser.add_argument("--test_seed", type=int, default=20261102)
+    parser.add_argument("--batch_size", type=int, default=1)
+    parser.add_argument("--num_workers", type=int, default=0)
+    parser.add_argument("--epochs", type=int, default=7)
+    parser.add_argument("--accumulation", type=int, default=4)
+    parser.add_argument("--explicit_learning_rate", type=float, default=1.5e-5)
+    parser.add_argument("--single_learning_rate", type=float, default=2.5e-5)
+    parser.add_argument("--weight_decay", type=float, default=1e-4)
+    parser.add_argument("--grad_clip", type=float, default=1.0)
+    parser.add_argument("--gradient_weight", type=float, default=0.08)
+    parser.add_argument("--increment_weight", type=float, default=0.12)
+    parser.add_argument("--persistence_skill_weight", type=float, default=0.25)
+    parser.add_argument("--persistence_target_ratio", type=float, default=0.98)
+    parser.add_argument("--variance_weight", type=float, default=0.08)
+    parser.add_argument("--spectral_weight", type=float, default=0.04)
+    parser.add_argument("--wave_nonnegative_weight", type=float, default=0.02)
+    parser.add_argument("--direction_circle_weight", type=float, default=0.08)
+    parser.add_argument("--bootstrap_reps", type=int, default=1000)
+    parser.add_argument(
+        "--resume",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+    )
+    parser.add_argument(
+        "--upload_each_epoch",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+    )
+    parser.add_argument(
+        "--seeds",
+        default="20260902,20260903,20260904",
+    )
+    parser.add_argument("--no_live_download", action="store_true")
+    parser.add_argument("--delete_native_raw", action="store_true")
+    parser.add_argument("--synthetic_smoke", action="store_true")
+    return parser
+
+
+def create_synthetic_native(
+    destination: Path,
+    metadata: Mapping[str, Any],
+    season_index: int,
+    time_steps: int = 80,
+    height: int = 64,
+    width: int = 96,
+) -> None:
+    destination.mkdir(parents=True, exist_ok=True)
+    generator = np.random.default_rng(20261100 + season_index)
+    data = generator.normal(
+        0.0, 1.0,
+        (time_steps, len(VARIABLE_NAMES), height, width),
+    ).astype(np.float32)
+    np.save(destination / "scs_c0_data.npy", data)
+    np.save(
+        destination / "scs_c0_mask.npy",
+        np.ones((height, width), dtype=np.float32),
+    )
+    variable_masks = np.ones(
+        (len(VARIABLE_NAMES), height, width),
+        dtype=np.float32,
+    )
+    # Add a deterministic coastal strip for bin-path validation.
+    variable_masks[:, :, :32] = 0.0
+    np.save(destination / "scs_c0_variable_masks.npy", variable_masks)
+    current = {
+        "variable_names": VARIABLE_NAMES,
+        "means": metadata["means"],
+        "stds": metadata["stds"],
+        "times_ns": (
+            np.datetime64("2023-01-15")
+            + np.arange(time_steps) * np.timedelta64(6, "h")
+        ).astype("datetime64[ns]").astype(np.int64).tolist(),
+        "latitude": np.linspace(0, 25, height).tolist(),
+        "longitude": np.linspace(99, 123, width).tolist(),
+        "shape": list(data.shape),
+        "native_resolution_degrees": 1 / 12,
+    }
+    atomic_json(current, destination / "scs_c0_metadata.json")
+    pd.DataFrame({
+        "variable": VARIABLE_NAMES,
+        "mean": current["means"],
+        "std": current["stds"],
+    }).to_csv(destination / "C0_data_audit.csv", index=False)
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    seeds = [
+        int(value) for value in args.seeds.split(",") if value.strip()
+    ]
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    if not args.synthetic_smoke and device.type != "cuda":
+        raise RuntimeError("Formal S4-A0 requires CUDA.")
+    torch.set_float32_matmul_precision("highest")
+    if torch.cuda.is_available():
+        torch.backends.cuda.matmul.allow_tf32 = False
+        torch.backends.cudnn.allow_tf32 = False
+
+    output_dir = Path(args.output_dir)
+    shutil.rmtree(output_dir, ignore_errors=True)
+    for subdir in [
+        "audits", "training", "checkpoints", "resume",
+        "evaluation", "figures", "lineage", "deployment",
+    ]:
+        (output_dir / subdir).mkdir(parents=True, exist_ok=True)
+
+    try:
+        stage(1, 10, "恢复S3-A1/S3-A0父资产")
+        if args.synthetic_smoke:
+            if not Path(args.s3a1_zip).is_file() or not Path(args.s3a0_zip).is_file():
+                raise FileNotFoundError("Synthetic smoke requires local parent ZIPs.")
+            parent_report = {
+                "synthetic_smoke": True,
+                "s3a1_sha256": sha256_file(Path(args.s3a1_zip)),
+                "s3a0_sha256": sha256_file(Path(args.s3a0_zip)),
+            }
+        else:
+            parent_report = ensure_parent_assets(args)
+        atomic_json(
+            parent_report,
+            output_dir / "audits" / "S4A0_parent_asset_audit.json",
+        )
+
+        stage(2, 10, "提取结构父模型和S3-A1修复权重")
+        parent_cache = Path(args.parent_cache)
+        shutil.rmtree(parent_cache, ignore_errors=True)
+        s3a0_assets = extract_s3a0_assets(
+            Path(args.s3a0_zip), parent_cache / "s3a0"
+        )
+        s3a1_assets = extract_s3a1_assets(
+            Path(args.s3a1_zip), parent_cache / "s3a1"
+        )
+        reference_mean = np.asarray(
+            s3a0_assets["metadata"]["means"], dtype=np.float32
+        )
+        reference_std = np.asarray(
+            s3a0_assets["metadata"]["stds"], dtype=np.float32
+        )
+        atomic_json(
+            {
+                "s3a1_verdict": s3a1_assets["verdict"],
+                "architecture_changed": False,
+                "architecture_policy": {
+                    "keep": [
+                        "explicit multi-scale information state",
+                        "shared scale-conditioned CIDM Core",
+                        "multi-step recurrence",
+                        "Band Closure",
+                        "multi-resolution decoder",
+                    ],
+                    "remain_off": [
+                        "all BER branches",
+                        "learned cross-scale flux",
+                        "slow/vertical output closure",
+                        "causal variance amplifier",
+                        "event router",
+                    ],
+                },
+            },
+            output_dir / "lineage" / "S4A0_parent_lineage.json",
+        )
+
+        stage(3, 10, "准备四季原生1/12°缓存")
+        native_roots = {}
+        native_reports = []
+        for index, season in enumerate(SEASONS):
+            if args.synthetic_smoke:
+                root = Path(args.native_cache_dir) / season / "prepared"
+                create_synthetic_native(
+                    root,
+                    s3a0_assets["metadata"],
+                    index,
+                    time_steps=max(args.max_horizon + args.history + 16, 80),
+                )
+                report = {"season": season, "source": "synthetic"}
+            else:
+                root, report = prepare_native_season(args, season)
+            native_roots[season] = root
+            native_reports.append(report)
+        atomic_json(
+            native_reports,
+            output_dir / "audits" / "S4A0_native_sources.json",
+        )
+
+        stage(4, 10, "构建近岸/陆架/开阔海域平衡训练集")
+        datasets, cubes = build_datasets(
+            native_roots,
+            reference_mean,
+            reference_std,
+            args,
+        )
+        loaders = build_loaders(datasets, args)
+        split_audit = {}
+        for split, dataset in datasets.items():
+            bins = pd.Series(
+                [record[-1] for record in dataset.records]
+            ).value_counts().to_dict()
+            split_audit[split] = {
+                "samples": len(dataset),
+                "bin_counts": bins,
+                "seasons": sorted(set(record[0] for record in dataset.records)),
+                "unique_records": len(set(record[:4] for record in dataset.records)),
+            }
+        split_audit["training_schedule"] = schedule(args)
+        split_audit["minimum_ocean_fraction"] = args.minimum_ocean_fraction
+        atomic_json(
+            split_audit,
+            output_dir / "audits" / "S4A0_split_audit.json",
+        )
+
+        means = torch.as_tensor(reference_mean, device=device)
+        stds = torch.as_tensor(reference_std, device=device)
+
+        stage(5, 10, "三种子同目标多季节训练")
+        parents = {}
+        trained = {}
+        training_rows = []
+        for seed in seeds:
+            parent_explicit, parent_single = instantiate_repaired_models(
+                s3a0_assets,
+                s3a1_assets,
+                seed,
+                device,
+            )
+            medium_explicit = copy.deepcopy(parent_explicit)
+            medium_single = copy.deepcopy(parent_single)
+            medium_explicit, explicit_record = train_medium(
+                medium_explicit,
+                "explicit",
+                seed,
+                loaders,
+                device,
+                means,
+                stds,
+                args,
+                output_dir,
+            )
+            medium_single, single_record = train_medium(
+                medium_single,
+                "single",
+                seed,
+                loaders,
+                device,
+                means,
+                stds,
+                args,
+                output_dir,
+            )
+            parents[seed] = {
+                "parent_explicit": parent_explicit,
+                "parent_single": parent_single,
+            }
+            trained[seed] = {
+                "medium_explicit": medium_explicit,
+                "medium_single": medium_single,
+            }
+            training_rows.extend([explicit_record, single_record])
+        pd.DataFrame(training_rows).to_csv(
+            output_dir / "S4A0_training_summary.csv", index=False
+        )
+
+        stage(6, 10, "秋季独立测试和样本级记录")
+        metric_rows = []
+        sample_tables: Dict[Tuple[int, str], pd.DataFrame] = {}
+        for seed in seeds:
+            models = {
+                **parents[seed],
+                **trained[seed],
+            }
+            metrics, tables = evaluate_methods(
+                models,
+                loaders["test"],
+                device,
+                means,
+                stds,
+            )
+            for method, current in metrics.items():
+                metric_rows.append({
+                    "seed": seed,
+                    "method": method,
+                    **current,
+                })
+                table = tables[method].copy()
+                table["seed"] = seed
+                sample_tables[(seed, method)] = table
+                table.to_csv(
+                    output_dir
+                    / "evaluation"
+                    / f"S4A0_samples_{method}_seed_{seed}.csv",
+                    index=False,
+                )
+        metric_table = pd.DataFrame(metric_rows)
+        metric_table.to_csv(
+            output_dir / "evaluation" / "S4A0_seed_metrics.csv",
+            index=False,
+        )
+
+        stage(7, 10, "时间块Bootstrap和海洋占比分层")
+        comparisons = [
+            ("medium_explicit_band", "medium_single"),
+            ("medium_explicit_band", "parent_explicit_band"),
+            ("medium_explicit_band", "medium_explicit_no_band"),
+            ("medium_explicit_band", "persistence"),
+            ("medium_single", "parent_single"),
+        ]
+        comparison_rows = []
+        bootstrap_payload = {}
+        for candidate, reference in comparisons:
+            for horizon in [12, 28, 60]:
+                result = block_bootstrap(
+                    [sample_tables[(seed, reference)] for seed in seeds],
+                    [sample_tables[(seed, candidate)] for seed in seeds],
+                    horizon,
+                    args.bootstrap_reps,
+                    seeds[0] + horizon + sum(map(ord, candidate + reference)),
+                )
+                key = f"{candidate}_vs_{reference}_h{horizon}"
+                bootstrap_payload[key] = result
+                comparison_rows.append({
+                    "candidate": candidate,
+                    "reference": reference,
+                    "horizon": horizon,
+                    "lead": HORIZON_LABELS[horizon],
+                    **result,
+                })
+        comparison_table = pd.DataFrame(comparison_rows)
+        comparison_table.to_csv(
+            output_dir / "S4A0_block_bootstrap_comparisons.csv",
+            index=False,
+        )
+        atomic_json(
+            bootstrap_payload,
+            output_dir / "paired_block_bootstrap.json",
+        )
+
+        bin_rows = []
+        for horizon in [12, 28, 60]:
+            bin_rows.extend(
+                ocean_bin_comparison(
+                    [sample_tables[(seed, "medium_explicit_band")] for seed in seeds],
+                    [sample_tables[(seed, "medium_single")] for seed in seeds],
+                    horizon,
+                )
+            )
+        bin_table = pd.DataFrame(bin_rows)
+        bin_table.to_csv(
+            output_dir / "S4A0_ocean_fraction_bin_comparisons.csv",
+            index=False,
+        )
+
+        summary_rows = []
+        for method in METHODS:
+            current = metric_table[
+                metric_table.method == method
+            ].set_index("seed")
+            for horizon in HORIZONS:
+                summary_rows.append({
+                    "method": method,
+                    "horizon": horizon,
+                    "lead": HORIZON_LABELS[horizon],
+                    "rmse": float(current[f"rmse_h{horizon}"].mean()),
+                    "variance_ratio": float(
+                        current[f"variance_ratio_h{horizon}"].mean()
+                    ),
+                    "wave_invalid_fraction": float(
+                        current[f"wave_invalid_fraction_h{horizon}"].mean()
+                    ),
+                    "direction_norm_error": float(
+                        current[f"direction_norm_error_h{horizon}"].mean()
+                    ),
+                    "finite": bool(current["finite"].all()),
+                    "max_abs": float(current["max_abs"].max()),
+                })
+        summary = pd.DataFrame(summary_rows)
+        summary.to_csv(
+            output_dir / "S4A0_long_rollout_summary.csv",
+            index=False,
+        )
+
+        stage(8, 10, "正式训练启动资格判决")
+        mean_metrics = metric_table.groupby("method").mean(numeric_only=True)
+
+        def gain(candidate: str, reference: str, horizon: int) -> float:
+            return 100.0 * (
+                mean_metrics.loc[reference, f"rmse_h{horizon}"]
+                - mean_metrics.loc[candidate, f"rmse_h{horizon}"]
+            ) / mean_metrics.loc[reference, f"rmse_h{horizon}"]
+
+        def block(candidate: str, reference: str, horizon: int) -> pd.Series:
+            return comparison_table[
+                (comparison_table.candidate == candidate)
+                & (comparison_table.reference == reference)
+                & (comparison_table.horizon == horizon)
+            ].iloc[0]
+
+        scale_72 = gain("medium_explicit_band", "medium_single", 12)
+        scale_7d = gain("medium_explicit_band", "medium_single", 28)
+        scale_15d = gain("medium_explicit_band", "medium_single", 60)
+        repair_72 = gain(
+            "medium_explicit_band", "parent_explicit_band", 12
+        )
+        repair_7d = gain(
+            "medium_explicit_band", "parent_explicit_band", 28
+        )
+        repair_15d = gain(
+            "medium_explicit_band", "parent_explicit_band", 60
+        )
+        band_72 = gain(
+            "medium_explicit_band", "medium_explicit_no_band", 12
+        )
+        band_7d = gain(
+            "medium_explicit_band", "medium_explicit_no_band", 28
+        )
+        band_15d = gain(
+            "medium_explicit_band", "medium_explicit_no_band", 60
+        )
+        persistence_7d = gain(
+            "medium_explicit_band", "persistence", 28
+        )
+        persistence_15d = gain(
+            "medium_explicit_band", "persistence", 60
+        )
+        variance_7d = float(
+            mean_metrics.loc["medium_explicit_band", "variance_ratio_h28"]
+        )
+        variance_15d = float(
+            mean_metrics.loc["medium_explicit_band", "variance_ratio_h60"]
+        )
+        direction_15d = float(
+            mean_metrics.loc[
+                "medium_explicit_band", "direction_norm_error_h60"
+            ]
+        )
+        wave_invalid_15d = float(
+            mean_metrics.loc[
+                "medium_explicit_band", "wave_invalid_fraction_h60"
+            ]
+        )
+        finite = bool(
+            metric_table[
+                metric_table.method == "medium_explicit_band"
+            ]["finite"].all()
+        )
+
+        def bin_gain(bin_name: str) -> float:
+            selected = bin_table[
+                (bin_table.horizon == 28)
+                & (bin_table.ocean_bin == bin_name)
+            ]["weighted_mse_gain_percent"]
+            return float(selected.iloc[0]) if len(selected) else float("nan")
+
+        coastal_7d = bin_gain("coastal")
+        shelf_7d = bin_gain("shelf")
+        open_7d = bin_gain("open_ocean")
+
+        checks = {
+            "architecture_unchanged": True,
+            "four_season_native_data_available": len(native_roots) == 4,
+            "winter_spring_training_summer_validation_autumn_test": True,
+            "balanced_training_bins_present": all(
+                split_audit["train"]["bin_counts"].get(name, 0) > 0
+                for name in OCEAN_BINS
+            ),
+            "three_explicit_and_single_pairs": len(seeds) == 3,
+            "all_explicit_rollouts_finite": finite,
+            "multi_season_repair_improves_parent_72h": repair_72 > 0.0,
+            "multi_season_repair_improves_parent_7d": repair_7d > 0.0,
+            "multi_season_repair_improves_parent_15d": repair_15d > 0.0,
+            "explicit_beats_single_72h_ge_2pct": scale_72 >= 2.0,
+            "explicit_beats_single_7d_ge_1pct": scale_7d >= 1.0,
+            "explicit_15d_nonworse_than_single": scale_15d >= 0.0,
+            "scale_72h_block_bootstrap_positive": (
+                float(block(
+                    "medium_explicit_band", "medium_single", 12
+                ).weighted_ci_high) < 0.0
+            ),
+            "scale_7d_block_bootstrap_positive": (
+                float(block(
+                    "medium_explicit_band", "medium_single", 28
+                ).weighted_ci_high) < 0.0
+            ),
+            "scale_15d_not_significantly_worse": (
+                float(block(
+                    "medium_explicit_band", "medium_single", 60
+                ).weighted_ci_high) <= 0.02
+            ),
+            "band_closure_72h_positive": band_72 >= 0.2,
+            "band_closure_7d_nonnegative": band_7d >= 0.0,
+            "band_closure_15d_nonnegative": band_15d >= 0.0,
+            "coastal_7d_not_worse_by_2pct_mse": bool(np.isfinite(coastal_7d) and coastal_7d >= -2.0),
+            "shelf_7d_positive": bool(np.isfinite(shelf_7d) and shelf_7d > 0.0),
+            "open_ocean_7d_positive": bool(np.isfinite(open_7d) and open_7d > 0.0),
+            "variance_ratio_7d_ge_0_45": variance_7d >= 0.45,
+            "variance_ratio_15d_ge_0_30": variance_15d >= 0.30,
+            "direction_norm_error_15d_lt_0_35": direction_15d < 0.35,
+            "wave_invalid_fraction_15d_lt_0_03": wave_invalid_15d < 0.03,
+            "all_metrics_finite": bool(
+                np.isfinite(
+                    metric_table.select_dtypes(
+                        include=[np.number]
+                    ).to_numpy()
+                ).all()
+            ),
+        }
+        passed = sum(bool(value) for value in checks.values())
+        architecture_freeze = [
+            "all_explicit_rollouts_finite",
+            "multi_season_repair_improves_parent_7d",
+            "multi_season_repair_improves_parent_15d",
+            "explicit_beats_single_72h_ge_2pct",
+            "explicit_beats_single_7d_ge_1pct",
+            "explicit_15d_nonworse_than_single",
+            "band_closure_72h_positive",
+            "band_closure_7d_nonnegative",
+            "band_closure_15d_nonnegative",
+            "coastal_7d_not_worse_by_2pct_mse",
+        ]
+        architecture_qualified = all(checks[key] for key in architecture_freeze)
+        product_signal = (
+            persistence_7d > 0.0
+            and float(block(
+                "medium_explicit_band", "persistence", 28
+            ).weighted_ci_high) < 0.0
+        )
+
+        if architecture_qualified and passed >= 21:
+            verdict_name = (
+                "V3_S4_A0_ARCHITECTURE_AND_TRAINING_CONTRACT_QUALIFIED"
+            )
+            recommendation = (
+                "Freeze CIDM-v3. Start the formal multi-year distributed "
+                "training run. No architecture modules may be added."
+            )
+        elif architecture_qualified:
+            verdict_name = (
+                "V3_S4_A0_ARCHITECTURE_QUALIFIED_FORMAL_TRAINING_ALLOWED"
+            )
+            recommendation = (
+                "Freeze CIDM-v3 and begin formal training. Treat persistence "
+                "and physical gaps as training-scale targets, not architecture gates."
+            )
+        elif finite and passed >= 16:
+            verdict_name = (
+                "V3_S4_A0_MULTI_SEASON_TRAINING_PARTIALLY_QUALIFIED"
+            )
+            recommendation = (
+                "Do not add modules. One data/loss calibration pass is allowed; "
+                "otherwise select the mature Single-State baseline for V3."
+            )
+        else:
+            verdict_name = (
+                "V3_S4_A0_EXPLICIT_SCALE_VALUE_NOT_CONFIRMED_AT_MEDIUM_SCALE"
+            )
+            recommendation = (
+                "Do not add modules. Prefer the mature Single-State backbone "
+                "for V3 product training and retain explicit-scale research for V4."
+            )
+
+        aggregate = {
+            "scale_vs_single_72h_percent": scale_72,
+            "scale_vs_single_7d_percent": scale_7d,
+            "scale_vs_single_15d_percent": scale_15d,
+            "repair_gain_72h_percent": repair_72,
+            "repair_gain_7d_percent": repair_7d,
+            "repair_gain_15d_percent": repair_15d,
+            "band_gain_72h_percent": band_72,
+            "band_gain_7d_percent": band_7d,
+            "band_gain_15d_percent": band_15d,
+            "vs_persistence_7d_percent": persistence_7d,
+            "vs_persistence_15d_percent": persistence_15d,
+            "coastal_7d_mse_gain_percent": coastal_7d,
+            "shelf_7d_mse_gain_percent": shelf_7d,
+            "open_ocean_7d_mse_gain_percent": open_7d,
+            "variance_ratio_7d": variance_7d,
+            "variance_ratio_15d": variance_15d,
+            "direction_norm_error_15d": direction_15d,
+            "wave_invalid_fraction_15d": wave_invalid_15d,
+            "architecture_qualified": architecture_qualified,
+            "product_signal_vs_persistence": product_signal,
+        }
+        verdict = {
+            "automatic_verdict": verdict_name,
+            "passed": passed,
+            "total": len(checks),
+            "checks": checks,
+            "architecture_freeze_checks": architecture_freeze,
+            "aggregate": aggregate,
+            "final_candidate": {
+                "modules": [
+                    "MultiScalePhysicalEncoder",
+                    "ExplicitScaleInformationState",
+                    "SharedScaleConditionedCIDMCore",
+                    "MultiStepRecurrence",
+                    "BandClosure",
+                    "MultiResolutionDecoder",
+                ],
+                "permanently_deferred_from_v3": [
+                    "all BER branches",
+                    "learned CrossScaleFlux",
+                    "SlowMemoryClosure",
+                    "VerticalOutputClosure",
+                    "CausalVarianceAmplifier",
+                    "EventRouter",
+                ],
+            },
+            "next_stage_recommendation": recommendation,
+        }
+        atomic_json(
+            aggregate,
+            output_dir / "S4A0_main_aggregate.json",
+        )
+        atomic_json(
+            verdict,
+            output_dir / "S4A0_verdict.json",
+        )
+
+        stage(9, 10, "图表、冻结合同和HF交接")
+        plt.figure(figsize=(11, 6))
+        for method in METHODS:
+            current = summary[summary.method == method]
+            plt.plot(
+                current.horizon,
+                current.rmse,
+                marker="o",
+                label=method,
+            )
+        plt.xlabel("Rollout steps (6 h each)")
+        plt.ylabel("RMSE")
+        plt.legend()
+        plt.tight_layout()
+        plt.savefig(
+            output_dir / "figures" / "S4A0_RMSE_growth.png",
+            dpi=180,
+        )
+        plt.close()
+
+        atomic_json(
+            {
+                "architecture_name": "CIDM-v3-SCS-Minimal-Final-Candidate",
+                "architecture_changes_in_S4A0": False,
+                "modules": [
+                    "MultiScalePhysicalEncoder",
+                    "ExplicitScaleInformationState",
+                    "SharedScaleConditionedCIDMCore",
+                    "MultiStepRecurrence",
+                    "BandClosure",
+                    "MultiResolutionDecoder",
+                ],
+                "training_contract": {
+                    "native_grid": "1/12 degree",
+                    "base_timestep_hours": 6,
+                    "history_steps": args.history,
+                    "maximum_rollout_steps": args.max_horizon,
+                    "optimizer_persistent": True,
+                    "multi_season_training": True,
+                    "balanced_ocean_fraction_sampling": True,
+                    "persistence_relative_skill": True,
+                    "increment_variance_spectral_wave_losses": True,
+                    "per_epoch_resume_checkpoint": True,
+                },
+                "formal_training_allowed": architecture_qualified,
+            },
+            output_dir
+            / "deployment"
+            / "CIDM_v3_final_candidate_architecture_and_training_contract.json",
+        )
+        atomic_json(
+            {
+                "repo_id": args.hf_repo_id,
+                "native_cache_paths": {
+                    season: f"Cache/native_1_12/{season}/"
+                    for season in SEASONS
+                },
+                "result_path": (
+                    "Experiments/V3_S4_A0/"
+                    "CIDM_v3_SCS_V3_S4_A0.zip"
+                ),
+            },
+            output_dir / "S4A0_HF_handoff.json",
+        )
+        safe_args = dict(vars(args))
+        safe_args["hf_token"] = "<redacted>"
+        atomic_json(
+            {
+                "experiment": "CIDM_v3_SCS_V3_S4_A0",
+                "created_at": pd.Timestamp.now().isoformat(),
+                "device": str(device),
+                "arguments": safe_args,
+                "security": "No plaintext access token is written.",
+            },
+            output_dir / "S4A0_manifest.json",
+        )
+
+        stage(10, 10, "结果打包")
+        package = output_dir.parent / f"{output_dir.name}.zip"
+        package.unlink(missing_ok=True)
+        with zipfile.ZipFile(package, "w", zipfile.ZIP_DEFLATED) as archive:
+            for path in output_dir.rglob("*"):
+                if path.is_file():
+                    archive.write(
+                        path,
+                        path.relative_to(output_dir.parent),
+                    )
+        print(
+            json.dumps(
+                verdict,
+                ensure_ascii=False,
+                indent=2,
+                default=json_default,
+            ),
+            flush=True,
+        )
+        print(f"[result] {package}", flush=True)
+
+    except Exception:
+        trace = traceback.format_exc()
+        (output_dir / "failure_traceback.txt").write_text(
+            trace, encoding="utf-8"
+        )
+        print(trace, flush=True)
+        raise
+
+
+if __name__ == "__main__":
+    main()