Add pre-2024 chart and verified Trackformer 1.2 training sources and cutoffs

.gitattributes

@@ -198,3 +198,4 @@ evaluation/released_daily/pressure_comparison.png filter=lfs diff=lfs merge=lfs
 evaluation/released_daily/model_1_2_benchmark.png filter=lfs diff=lfs merge=lfs -text
 docs/trackformer_1_2_mangkhut.gif filter=lfs diff=lfs merge=lfs -text
 evaluation/released_daily/model_1_2_after_2024_benchmark.png filter=lfs diff=lfs merge=lfs -text
+evaluation/released_daily/model_1_2_before_2024_benchmark.png filter=lfs diff=lfs merge=lfs -text

docs/deepmind_daily_benchmark.md

@@ -43,7 +43,7 @@ Mini has better recent-only track scores even though 1.2 has lower position/head
 
 ### Strict forecast-date partition and separate charts
 
-Both README charts use **`WeatherNextCyclones_Mini_<2024`**, the same official checkpoint trained through 2023, software v0.3.0, native 1° and one CUDA member. A post-2024 forecast is not a post-2024-trained model. The following proportions refer to this evaluation cohort, not the model's training dataset.
+All three README charts—total, strict `<2024` and strict `>2024`—use **`WeatherNextCyclones_Mini_<2024`**, the same official checkpoint trained through 2023, software v0.3.0, native 1° and one CUDA member. A post-2024 forecast is not a post-2024-trained model. The following proportions refer to this evaluation cohort, not the model's training dataset.
 
 | UTC issue year | Starts / share | Storms / share |
 | --- | --- | --- |
@@ -53,7 +53,9 @@ Both README charts use **`WeatherNextCyclones_Mini_<2024`**, the same official c
 
 The original `recent_2024_onward` aggregate includes 2024 and is retained unchanged. The new **strict `after_2024`** derivative excludes 2024: track position MAE is **963.02 / 469.40 / 258.67 km**, direction error **57.88 / 33.81 / 28.73°**, and JMA pressure MAE **12.59 / 11.12 / 9.55 hPa** for 1.1 / 1.2 / Mini. Track uses 61 starts / 18 storms; pressure uses 59 starts / 18 storms / 1,174 exact common leads. The total chart still uses the original scores. Its historical 230 storms contribute 85.2% of equal-storm track weight, not 90.7%.
 
-[UTC partitions, exact case IDs, all metrics and source hashes](../evaluation/deepmind_daily/period_comparison.json) · [Total chart](../evaluation/released_daily/model_1_2_benchmark.png) · [Post-2024 chart](../evaluation/released_daily/model_1_2_after_2024_benchmark.png)
+The strict **`before_2024`** chart uses the 1,336 historical starts / 230 storms (1980–1999 here): position MAE **780.50 / 470.17 / 534.86 km** and direction error **51.36 / 35.01 / 41.26°** for 1.1 / 1.2 / Mini. All three shared JMA pressure scores are null, with zero eligible common starts: frozen historical 1.1 intensity inputs are unavailable. That panel says **Not scored** and contains no bars, not zero-height bars. Track coverage must never be reused as pressure coverage.
+
+[UTC partitions, exact case IDs, all metrics and source hashes](../evaluation/deepmind_daily/period_comparison.json) · [Total chart](../evaluation/released_daily/model_1_2_benchmark.png) · [Pre-2024 chart](../evaluation/released_daily/model_1_2_before_2024_benchmark.png) · [Post-2024 chart](../evaluation/released_daily/model_1_2_after_2024_benchmark.png)
 
 Reproduce these derivative summaries without inference or raw-weather downloads:
 

docs/trackformer_1_2_evaluation.md

@@ -51,3 +51,5 @@ This plots the saved completed equal-storm results; it performs no new inference
 ## Validation boundary
 
 Training used whole-storm year partitions: 2000–2021 training, 2022–2023 validation, 2024–2025 test in the original pipeline, with 13,949 / 1,041 / 1,195 windows respectively; native-pressure windows total 800 / 100 / 100. Repeatedly viewed benchmarks, TIP and calibration cases have become development evidence. Freeze a genuinely unused storm-level holdout with matched issue-time data before claiming generalization. Evaluate route, central pressure and pressure fields at every lead on common cases and masks; a lower map average alone is not a model win.
+
+The fitting sources are IBTrACS-derived storm records, NOAA PSL NCEP/NCAR basin analyses, ARCO-ERA5 regional MSLP and static ERA5 land fraction/elevation. Newer 2026 archive records are not part of the released model's gradient fitting. See [training-source documentation](trackformer_1_2_training_data.md) and [checksum-verified split receipt](../evaluation/training_data/trackformer_1_2_provenance.json).

docs/trackformer_1_2_training_data.md

@@ -0,0 +1,56 @@
+# Trackformer 1.2 training data
+
+The **released 1.2 model's fitting cutoff is 2021**, not 2025 or 2026. Its selected checkpoint is development version 1.2.73, epoch 4. The dataset and normalization identities are frozen in the [release manifest](../models/trackformer_1_2_field/manifest.json). This document describes that release, not later 1.3 training or live-input downloads.
+
+## Sources actually consumed by the released training loader
+
+| Component | Dataset | Variables and sampling |
+| --- | --- | --- |
+| Storm observations / supervised labels | [NOAA IBTrACS](https://www.ncei.noaa.gov/products/international-best-track-archive)-derived `track_windows_v13.npz` | Position, prior motion, available maximum wind and central pressure, exact storm/time identities and label masks. Only eligible Western Pacific-domain windows enter this release. |
+| Basin weather | [NOAA PSL NCEP/NCAR Reanalysis 1](https://psl.noaa.gov/data/gridded/data.ncep.reanalysis.html), `basin_all_int8.npz` and the exact-time SLP atlas | MSLP, 500 hPa geopotential height, zonal/meridional winds at 850/500/200 hPa. Six-hour analyses on 100–180°E, 0–60°N; 2.5° grid, 25 × 33 cells. |
+| Native regional pressure | [ARCO-ERA5](https://github.com/google-research/arco-era5), `pressure_hpa.npy` with its frozen `plan.json` | Mean sea-level pressure on 0.25° fixed issue-centred 121 × 121 patches. 1,000 original windows across all three partitions, not native detail for every coarse window. |
+| Static geography | Same ARCO-ERA5 source, `geography.npz` | Land fraction and surface geopotential / 9.80665 to obtain elevation in metres; latitude/longitude encodings. Static context is not an additional temporal fitting period. |
+
+The eight weather channels are **MSLP, HGT500, U850, V850, U500, V500, U200, V200**. No satellite cloud imagery, humidity/vapour, SST or ocean-heat-content channel is present in this released input contract. Such features in other experiments must not be attributed to 1.2.
+
+The selected dataset manifest identifies the **derived IBTrACS archive by SHA-256**, not by an independently recorded raw IBTrACS release/download ID. A newer downloaded IBTrACS file elsewhere is not evidence of which raw snapshot built these frozen windows. Available wind labels and the learned auxiliary head do not establish a harmonized agency averaging period or a validated surface-wind/radius forecast.
+
+## Temporal partitions
+
+| Role | Whole-storm years | Eligible windows / storms | Native-pressure windows | First → last eligible UTC issue |
+| --- | --- | --- | ---: | --- |
+| Fitting and normalization | 2000–2021 | 13,949 / 611 | 800 | 2000-05-05 18:00 → 2021-12-20 12:00 |
+| Validation / checkpoint selection | 2022–2023 | 1,041 / 46 | 100 | 2022-03-31 00:00 → 2023-12-17 18:00 |
+| Original test / evaluation | 2024–2025 | 1,195 / 56 | 100 | 2024-05-22 00:00 → 2025-12-02 12:00 |
+
+These are loader-eligible window counts, not independent storms or the number of gradient updates. Native-pressure windows are a **subset** of the corresponding eligible windows, not additional cases. Storm membership uses each storm's first year in the frozen archive. Windows whose −48 h history or +120 h targets cross a partition boundary are excluded. Weather normalization uses the 2000–2021 basin frames only.
+
+Every forecast history comprises nine consecutive six-hour analyses at **−48, −42, …, 0 h**. Supervised fields and storm labels at **+6, +12, …, +120 h** are targets only; they cannot be inference inputs. Missing native detail and missing intensity labels retain their masks. Validation is not gradient fitting, but it does inform checkpoint selection. Previously inspected original tests and showcases are development evidence, not a new unused holdout.
+
+## Newer data do not change the fitting cutoff
+
+The checksum-pinned caches contain records beyond the fitting years:
+
+- Derived storm-window archive: **1980-01-03 00 UTC to 2026-07-13 00 UTC**.
+- Coarse NCEP weather archive: **1980-01-01 00 UTC to 2026-03-17 18 UTC**.
+- Original native-pressure plan: fitting, validation and test windows in **2000–2025**, separated as above.
+
+Those are **source-cache endpoints**, not years all used to fit 1.2. The 2026 live/backfill pipeline uses the unchanged released model with later causal inputs; GFS transfer is experimental, and generating a new forecast does not retrain the weights. Retrospective reanalysis availability is not proof that the same inputs were available operationally at each historical issue time.
+
+## Verified identity and reproduction
+
+The [training-data receipt](../evaluation/training_data/trackformer_1_2_provenance.json) rechecks all six derived dataset file hashes, the released dataset-manifest hash, exact split counts, storm separation and native-patch membership. It records the original cache endpoints and exact earliest histories/latest targets. This is not a new raw-source-download audit.
+
+| Frozen identity | SHA-256 |
+| --- | --- |
+| Dataset manifest | `04fd0d30620137aad20173dcd59e22da2a6c20fae2f17de593e91a59517459c1` |
+| Selected training checkpoint | `f194a23d3f91ea76ad776dfad942fabd669eeae8b3fd665815463095367e9ee0` |
+| Inference-only weights | `db49f36e85a3766defc4c172746897a1f783705d1ce8e6f9dfb8e87ae1d902cb` |
+
+With the original frozen dataset available, reproduce the small receipt without inference, downloads or refreshing the training cache:
+
+```bash
+python release_tools/audit_training_data.py --dataset-root /Volumes/D/typhoon_predict/data/v164_reuse --output /Volumes/D/typhoon_predict/remote_typhoon_predict_repo/evaluation/training_data/trackformer_1_2_provenance.json
+```
+
+The original full training arrays are not newly bundled by this documentation update. Model weights, neural source, forecasts and training processes are unchanged.

evaluation/released_daily/model_1_2_after_2024_benchmark.json

@@ -48,6 +48,26 @@
     "deepmind"
   ],
   "bars_per_panel": 3,
+  "available_bars_per_panel": {
+    "pressure_JMA_hpa": 3,
+    "mean_track_error_km": 3,
+    "direction_error_deg": 3
+  },
+  "coverage": {
+    "pressure_JMA_hpa": {
+      "daily_issues": 59,
+      "storms": 18
+    },
+    "mean_track_error_km": {
+      "daily_issues": 61,
+      "storms": 18
+    },
+    "direction_error_deg": {
+      "daily_issues": 61,
+      "storms": 18
+    }
+  },
+  "unavailable_metrics": [],
   "error_bars": false,
   "zero_fill": false,
   "model_forecasts_modified": false,

evaluation/released_daily/model_1_2_before_2024_benchmark.json

@@ -0,0 +1,77 @@
+{
+  "source": "evaluation/deepmind_daily/period_comparison.json",
+  "source_sha256": "0aef2eb8b5f808e5100cbbe132af3dc3e5d2de6fefe7d92d916190049cdf25cb",
+  "chart": "evaluation/released_daily/model_1_2_before_2024_benchmark.png",
+  "chart_sha256": "d441f512bd6eeb6761bc2ac4bb3bb09d64c9efccc8241fdc93b489fd442f5104",
+  "period": "before_2024",
+  "period_definition": "UTC issue year < 2024",
+  "metrics": [
+    "pressure_JMA_hpa",
+    "mean_track_error_km",
+    "direction_error_deg"
+  ],
+  "values": {
+    "pressure_JMA_hpa": {
+      "1.1": null,
+      "1.2": null,
+      "deepmind": null
+    },
+    "mean_track_error_km": {
+      "1.1": 780.4956251297209,
+      "1.2": 470.1683227329181,
+      "deepmind": 534.8619522162429
+    },
+    "direction_error_deg": {
+      "1.1": 51.35513468466848,
+      "1.2": 35.008663500237326,
+      "deepmind": 41.2608569444939
+    }
+  },
+  "deepmind_status": "complete_verified",
+  "deepmind_model": {
+    "key": "deepmind",
+    "label": "Google DeepMind WeatherNext Cyclones Mini (<2024)",
+    "model_checkpoint": "WeatherNextCyclones_Mini_<2024",
+    "software_version": "0.3.0",
+    "software_commit": "89c4b2a77a1c57b328b909c575550fd2e5aadc9c",
+    "trained_through": 2023,
+    "resolution_degrees": 1,
+    "member_count": 1,
+    "member_policy": "One official Mini member, seed 0",
+    "checkpoint_sha256": "a1bb151457077248d70a458b1a7b19deacd2926fbcb46eee4ff2691444e3596e",
+    "method": "Official predictor and initialized-storm tracker; causal ERA5; RTX 3070 CUDA",
+    "status": "complete_verified"
+  },
+  "models": [
+    "1.1",
+    "1.2",
+    "deepmind"
+  ],
+  "bars_per_panel": null,
+  "available_bars_per_panel": {
+    "pressure_JMA_hpa": 0,
+    "mean_track_error_km": 3,
+    "direction_error_deg": 3
+  },
+  "coverage": {
+    "pressure_JMA_hpa": {
+      "daily_issues": 0,
+      "storms": 0
+    },
+    "mean_track_error_km": {
+      "daily_issues": 1336,
+      "storms": 230
+    },
+    "direction_error_deg": {
+      "daily_issues": 1336,
+      "storms": 230
+    }
+  },
+  "unavailable_metrics": [
+    "pressure_JMA_hpa"
+  ],
+  "error_bars": false,
+  "zero_fill": false,
+  "model_forecasts_modified": false,
+  "publication_audit_sha256": "52c767b46452a29341c024f24a774328ed6fd4169f5f28e923a81e01c641b222"
+}

evaluation/released_daily/model_1_2_benchmark.json

@@ -48,6 +48,26 @@
     "deepmind"
   ],
   "bars_per_panel": 3,
+  "available_bars_per_panel": {
+    "pressure_JMA_hpa": 3,
+    "mean_track_error_km": 3,
+    "direction_error_deg": 3
+  },
+  "coverage": {
+    "pressure_JMA_hpa": {
+      "daily_issues": 134,
+      "storms": 40
+    },
+    "mean_track_error_km": {
+      "daily_issues": 1473,
+      "storms": 270
+    },
+    "direction_error_deg": {
+      "daily_issues": 1473,
+      "storms": 270
+    }
+  },
+  "unavailable_metrics": [],
   "error_bars": false,
   "zero_fill": false,
   "model_forecasts_modified": false,

evaluation/training_data/trackformer_1_2_provenance.json

@@ -0,0 +1,153 @@
+{
+  "schema": "trackformer-1.2-training-data-audit-v1",
+  "status": "verified",
+  "public_version": "1.2",
+  "source_checkpoint_version": "1.2.73",
+  "source_checkpoint_sha256": "f194a23d3f91ea76ad776dfad942fabd669eeae8b3fd665815463095367e9ee0",
+  "inference_weights_sha256": "db49f36e85a3766defc4c172746897a1f783705d1ce8e6f9dfb8e87ae1d902cb",
+  "dataset_manifest_sha256": "04fd0d30620137aad20173dcd59e22da2a6c20fae2f17de593e91a59517459c1",
+  "verified_archive_files": {
+    "track": {
+      "file": "track_windows_v13.npz",
+      "sha256": "cb8d7291aa8140124ca522feb448a1d44124b018efc4ba1d54824b60a4f73451",
+      "bytes": 42755049
+    },
+    "basin": {
+      "file": "basin_all_int8.npz",
+      "sha256": "71e5f1bb46c44e5936c506a3f8af021c1fe94c238ed030c05c66e8f342374b6d",
+      "bytes": 274115577
+    },
+    "slp": {
+      "file": "basin_slp_atlas_float16.npy",
+      "sha256": "9f6a4ec7b2f6beadfa1075af9176d2a653e39a824d504d989e5e56e19c571521",
+      "bytes": 111394928
+    },
+    "pressure": {
+      "file": "pressure_hpa.npy",
+      "sha256": "16cc1b153aeee5eff4b67337b599892dcd86a5716554596b8031048035d247ba",
+      "bytes": 1698356128
+    },
+    "plan": {
+      "file": "plan.json",
+      "sha256": "117eb291e385a326191be2f73182ed6dcbf0e9f99745780ac9e49a29def3d8da",
+      "bytes": 295005
+    },
+    "geography": {
+      "file": "geography.npz",
+      "sha256": "f5471471da4a1e15f85fbfb2529065806281357c8e50cb272fcd2b02e8553b96",
+      "bytes": 2547017
+    }
+  },
+  "sources": {
+    "track": "NOAA IBTrACS-derived track_windows_v13",
+    "basin": "NOAA PSL NCEP/NCAR Reanalysis 1",
+    "native_pressure": "https://storage.googleapis.com/gcp-public-data-arco-era5/ar/full_37-1h-0p25deg-chunk-1.zarr-v3",
+    "geography": "https://storage.googleapis.com/gcp-public-data-arco-era5/ar/full_37-1h-0p25deg-chunk-1.zarr-v3",
+    "raw_ibtracs_release": "Not recorded in the selected dataset manifest; derived archive hash is authoritative"
+  },
+  "channels": [
+    "mslp",
+    "hgt500",
+    "uwnd850",
+    "vwnd850",
+    "uwnd500",
+    "vwnd500",
+    "uwnd200",
+    "vwnd200"
+  ],
+  "normalization_fit_years": [
+    2000,
+    2021
+  ],
+  "partitions": {
+    "train": {
+      "years": [
+        2000,
+        2021
+      ],
+      "windows": 13949,
+      "storms": 611,
+      "native_pressure_windows": 800,
+      "first_issue_utc": "2000-05-05T18:00:00Z",
+      "last_issue_utc": "2021-12-20T12:00:00Z",
+      "earliest_history_utc": "2000-05-03T18:00:00Z",
+      "latest_target_utc": "2021-12-25T12:00:00Z"
+    },
+    "validation": {
+      "years": [
+        2022,
+        2023
+      ],
+      "windows": 1041,
+      "storms": 46,
+      "native_pressure_windows": 100,
+      "first_issue_utc": "2022-03-31T00:00:00Z",
+      "last_issue_utc": "2023-12-17T18:00:00Z",
+      "earliest_history_utc": "2022-03-29T00:00:00Z",
+      "latest_target_utc": "2023-12-22T18:00:00Z"
+    },
+    "test": {
+      "years": [
+        2024,
+        2025
+      ],
+      "windows": 1195,
+      "storms": 56,
+      "native_pressure_windows": 100,
+      "first_issue_utc": "2024-05-22T00:00:00Z",
+      "last_issue_utc": "2025-12-02T12:00:00Z",
+      "earliest_history_utc": "2024-05-20T00:00:00Z",
+      "latest_target_utc": "2025-12-07T12:00:00Z"
+    }
+  },
+  "whole_storm_splits": true,
+  "boundary_crossing_windows_excluded": true,
+  "history_leads_hours": [
+    -48,
+    -42,
+    -36,
+    -30,
+    -24,
+    -18,
+    -12,
+    -6,
+    0
+  ],
+  "target_leads_hours": [
+    6,
+    12,
+    18,
+    24,
+    30,
+    36,
+    42,
+    48,
+    54,
+    60,
+    66,
+    72,
+    78,
+    84,
+    90,
+    96,
+    102,
+    108,
+    114,
+    120
+  ],
+  "upstream_cache_coverage": {
+    "track": {
+      "first_issue_utc": "1980-01-03T00:00:00Z",
+      "last_issue_utc": "2026-07-13T00:00:00Z"
+    },
+    "basin": {
+      "first_analysis_utc": "1980-01-01T00:00:00Z",
+      "last_analysis_utc": "2026-03-17T18:00:00Z"
+    }
+  },
+  "cutoff_interpretation": "Fitting through 2021; validation through 2023; original test through 2025. Newer cache/live records are not gradient fitting.",
+  "inference_performed": false,
+  "model_weights_modified": false,
+  "training_data_modified": false,
+  "audit_scope": "All six derived archive file hashes, release manifest identity and loader-equivalent split/patch membership. Not a new raw-download or operational-availability audit."
+}

models/trackformer_1_2_field/README.md

@@ -4,6 +4,8 @@ The released pressure-field model predicts Western Pacific storm tracks, central
 
 This folder contains the exact source, input contract and inference-only weights for the research model in the [main README](../../README.md). `model.py`, `baseline_model.py` and `v165_base.py` are source-identical to the selected training implementation. The weight file is distributed via the [GitHub release](https://github.com/yu314-coder/typhoon-predict/releases/tag/trackformer-1.2) and [Hugging Face](https://huggingface.co/euler314/typhoon-predict/tree/main/models/trackformer_1_2_field), not Git.
 
+**Training-data cutoff:** fitting and weather normalization use **2000–2021**; validation/checkpoint selection uses **2022–2023**; the original test partition uses **2024–2025**. Inputs come from IBTrACS-derived storm records, NOAA PSL NCEP/NCAR Reanalysis basin fields, ARCO-ERA5 regional pressure and static land/elevation. Newer 2026 archive/live inputs are inference, not retraining. [Sources and exact split coverage](../../docs/trackformer_1_2_training_data.md) · [Verified training-data receipt](../../evaluation/training_data/trackformer_1_2_provenance.json).
+
 Use Python with PyTorch and NumPy. The export environment used PyTorch 2.13.0; the source was evaluated on macOS MPS. Example:
 
 ```bash

release_tools/audit_training_data.py

@@ -0,0 +1,124 @@
+"""Read-only audit of the released 1.2 dataset; no inference or cache refresh.
+
+Requires the original checksum-pinned local dataset, not new downloads. Writes
+only the requested small provenance receipt on /Volumes/D. Unlike the training
+loader, this does not rewrite its verified basin mmap or initialize PyTorch.
+"""
+import argparse
+from collections import Counter
+import hashlib
+import json
+from pathlib import Path
+
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[1]
+HOUR = 3_600_000_000_000
+SPLITS = {'train': (2000, 2021, 13949, 800),
+          'validation': (2022, 2023, 1041, 100),
+          'test': (2024, 2025, 1195, 100)}
+
+
+def sha(path):
+    with path.open('rb') as stream:
+        return hashlib.file_digest(stream, 'sha256').hexdigest()
+
+
+def utc(ns):
+    return str(np.datetime64(int(ns), 'ns').astype('datetime64[s]')) + 'Z'
+
+
+def audit(dataset_root):
+    released = json.loads((ROOT / 'models/trackformer_1_2_field/manifest.json').read_text())
+    path = dataset_root / 'manifest.json'
+    if sha(path) != released['dataset_sha256']:
+        raise ValueError('Dataset manifest differs from the released checkpoint')
+    data = json.loads(path.read_text())
+    if data['schema'] != 'v164-reuse-pressure-v1' or data['pilot']:
+        raise ValueError('Exact full dataset required')
+    files = {}
+    for key, entry in data['files'].items():
+        local = dataset_root / entry['path']
+        actual = sha(local)
+        if actual != entry['sha256']:
+            raise ValueError('Dataset file checksum differs: ' + key)
+        files[key] = dict(file=entry['path'], sha256=actual, bytes=local.stat().st_size)
+    with np.load(dataset_root / files['track']['file'], allow_pickle=False) as z:
+        times, storms = z['base_time'], z['storm_id']
+        lat, lon = z['base_lat'], z['base_lon'] % 360
+    with np.load(dataset_root / files['basin']['file'], allow_pickle=False) as z:
+        atlas, channels = z['time'], z['channels'].tolist()
+        if channels != released['data_contract']['channels'][1:]:
+            raise ValueError('Basin channel order differs')
+    if not np.all(np.diff(atlas) == 6 * HOUR):
+        raise ValueError('Expected exact regular six-hour atlas')
+    years = times.astype('datetime64[ns]').astype('datetime64[Y]').astype(int) + 1970
+    first = {}
+    for sid, year in zip(storms, years):
+        first[str(sid)] = min(first.get(str(sid), 9999), int(year))
+    first_years = np.array([first[str(sid)] for sid in storms])
+    bounds = np.stack((times - 48 * HOUR, times + 120 * HOUR), axis=1)
+    bound_years = bounds.astype('datetime64[ns]').astype('datetime64[Y]').astype(int) + 1970
+    indices = np.searchsorted(atlas, times)
+    eligible = ((indices >= 8) & (indices + 20 < len(atlas)) &
+                (atlas[np.clip(indices, 0, len(atlas) - 1)] == times) &
+                np.isfinite(lat) & np.isfinite(lon) &
+                (lat > 0) & (lat < 60) & (lon > 100) & (lon < 180))
+    plan = json.loads((dataset_root / files['plan']['file']).read_text())
+    patches = Counter(row['split'] for row in plan['rows'])
+    if plan['shape'] != [1000, 29, 121, 121] or plan['lead_hours'] != list(range(-48, 121, 6)):
+        raise ValueError('Native pressure package shape/time mismatch')
+    split_report, split_ids = {}, {}
+    for name, (low, high, expected, native) in SPLITS.items():
+        mask = (eligible & (first_years >= low) & (first_years <= high) &
+                (bound_years[:, 0] >= low) & (bound_years[:, 1] <= high))
+        if int(mask.sum()) != expected or patches[name] != native:
+            raise ValueError('Split counts differ: ' + name)
+        split_ids[name] = set(storms[mask])
+        rows = set(np.flatnonzero(mask).tolist())
+        for patch in (r for r in plan['rows'] if r['split'] == name):
+            i = patch['track_archive_row']
+            if i not in rows or patch['issue_ns'] != int(times[i]) or patch['storm_id'] != str(storms[i]):
+                raise ValueError('Native patch is not in the matching original split')
+        split_report[name] = dict(years=[low, high], windows=expected,
+            storms=len(split_ids[name]), native_pressure_windows=native,
+            first_issue_utc=utc(times[mask].min()), last_issue_utc=utc(times[mask].max()),
+            earliest_history_utc=utc(bounds[mask, 0].min()),
+            latest_target_utc=utc(bounds[mask, 1].max()))
+    if any(split_ids[a] & split_ids[b] for a, b in (('train', 'validation'), ('train', 'test'), ('validation', 'test'))):
+        raise ValueError('A storm appears in multiple partitions')
+    norm = released['data_contract']['normalization']
+    if norm['fit_split'] != 'train' or norm['end_year'] != 2021:
+        raise ValueError('Released normalization cutoff differs')
+    return dict(schema='trackformer-1.2-training-data-audit-v1', status='verified',
+        public_version='1.2', source_checkpoint_version=released['source_checkpoint_version'],
+        source_checkpoint_sha256=released['source_checkpoint_sha256'],
+        inference_weights_sha256=released['inference_weights_sha256'],
+        dataset_manifest_sha256=released['dataset_sha256'], verified_archive_files=files,
+        sources=dict(track='NOAA IBTrACS-derived track_windows_v13',
+            basin='NOAA PSL NCEP/NCAR Reanalysis 1',
+            native_pressure=plan['source'], geography=plan['source'],
+            raw_ibtracs_release='Not recorded in the selected dataset manifest; derived archive hash is authoritative'),
+        channels=released['data_contract']['channels'], normalization_fit_years=[2000, 2021],
+        partitions=split_report, whole_storm_splits=True, boundary_crossing_windows_excluded=True,
+        history_leads_hours=list(range(-48, 1, 6)), target_leads_hours=list(range(6, 121, 6)),
+        upstream_cache_coverage=dict(
+            track=dict(first_issue_utc=utc(times.min()), last_issue_utc=utc(times.max())),
+            basin=dict(first_analysis_utc=utc(atlas.min()), last_analysis_utc=utc(atlas.max()))),
+        cutoff_interpretation='Fitting through 2021; validation through 2023; original test through 2025. Newer cache/live records are not gradient fitting.',
+        inference_performed=False, model_weights_modified=False, training_data_modified=False,
+        audit_scope='All six derived archive file hashes, release manifest identity and loader-equivalent split/patch membership. Not a new raw-download or operational-availability audit.')
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--dataset-root', type=Path, required=True)
+    parser.add_argument('--output', type=Path, required=True)
+    args = parser.parse_args()
+    output = args.output.resolve()
+    if not output.is_relative_to(Path('/Volumes/D')):
+        raise ValueError('Diagnostic output must remain on /Volumes/D')
+    report = audit(args.dataset_root.resolve())
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(report, indent=2, allow_nan=False) + '\n')
+    print(json.dumps({'status': report['status'], 'partitions': report['partitions'], 'output': str(output)}))

release_tools/plot_model_announcement.py

@@ -12,6 +12,21 @@ SOURCE = ROOT/'evaluation/released_daily/released_daily_benchmark.json'
 DEST = ROOT/'evaluation/released_daily/model_1_2_benchmark.png'
 PERIOD_SOURCE = ROOT/'evaluation/deepmind_daily/period_comparison.json'
 POST_DEST = ROOT/'evaluation/released_daily/model_1_2_after_2024_benchmark.png'
+PRE_DEST = ROOT/'evaluation/released_daily/model_1_2_before_2024_benchmark.png'
+
+
+def metric_available(row):
+    """A zero-support metric is unavailable, never an error of zero."""
+    values = list(row['values'].values())
+    coverage = row['coverage']
+    if coverage['daily_issues'] == 0 and coverage['storms'] == 0:
+        if not all(v is None for v in values):
+            raise ValueError('Zero support requires null scores, not numeric bars')
+        return False
+    if coverage['daily_issues'] <= 0 or coverage['storms'] <= 0 or any(
+            v is None or not np.isfinite(v) or v < 0 for v in values):
+        raise ValueError('Missing or invalid metric cannot become a zero bar')
+    return True
 
 
 def period_metrics(period):
@@ -42,6 +57,7 @@ def main():
     if periods['model'] != reference or not periods['single_checkpoint_across_all_periods']:
         raise ValueError('Period groups are not different checkpoint generations')
     for key, dest, title in (('total', DEST, 'Total · mixed-year comparison'),
+                             ('before_2024', PRE_DEST, 'Before 2024 · historical comparison'),
                              ('after_2024', POST_DEST, 'After 2024 · 2025–2026 comparison')):
         metrics = period_metrics(periods['periods'][key])
         draw_chart(metrics, reference, periods, key, dest, title)
@@ -60,9 +76,20 @@ def draw_chart(metrics, reference, periods, period_key, dest, title):
     for ax, (key, panel_title, label, maximum, digits) in zip(axes, specs):
         row = metrics[key]
         values = [row['values'][k] for k in models]
-        if any(v is None or not np.isfinite(v) or v < 0 for v in values):
-            raise ValueError('Missing or invalid metric cannot become a zero bar')
         ax.set_facecolor('#f6f8fc')
+        ax.set_title(panel_title, loc='left', fontsize=16, fontweight='bold', color='#21334c', pad=38)
+        ax.text(0, 1.03, label, transform=ax.transAxes, color='#53647c', fontsize=10)
+        if not metric_available(row):
+            ax.set_xticks([])
+            ax.set_yticks([])
+            ax.text(.5, .65, 'Not scored', transform=ax.transAxes, ha='center',
+                    fontsize=22, fontweight='bold', color='#53647c')
+            ax.text(.5, .35, 'No shared valid JMA pressure cases.\nFrozen 1.1 intensity inputs unavailable.\nMissing is not a zero error.',
+                    transform=ax.transAxes, ha='center', va='center',
+                    fontsize=11, linespacing=1.65, color='#53647c')
+            ax.text(.5, -.33, '0 shared pressure starts / 0 storms · no bars',
+                    transform=ax.transAxes, ha='center', color='#53647c', fontsize=10)
+            continue
         ax.set_axisbelow(True)
         ax.grid(axis='y', color='#dfe5ee', linewidth=.8)
         ax.bar([0, 1, 2], values, width=.55, color=['#9aa9bc', '#3c67d6', '#9073cf'], zorder=3)
@@ -72,8 +99,6 @@ def draw_chart(metrics, reference, periods, period_key, dest, title):
         ax.set_ylim(0, maximum)
         ax.set_xticks([0, 1, 2], ['1.1', '1.2\nmean of 50', 'DeepMind Mini\n<2024 · 1 member'])
         ax.tick_params(axis='both', length=0, labelcolor='#53647c')
-        ax.set_title(panel_title, loc='left', fontsize=16, fontweight='bold', color='#21334c', pad=38)
-        ax.text(0, 1.03, label, transform=ax.transAxes, color='#53647c', fontsize=10)
         coverage = row['coverage']
         ax.text(.5, -.33, f"{coverage['daily_issues']:,} daily starts / {coverage['storms']} storms",
                 transform=ax.transAxes, ha='center', color='#53647c', fontsize=10)
@@ -82,6 +107,8 @@ def draw_chart(metrics, reference, periods, period_key, dest, title):
     fig.text(.055, .84, 'Same saved forecasts and valid times · +6 to +120 h · equal storm weight · lower is better', fontsize=11, color='#53647c')
     if period_key == 'total':
         note = 'Storm proportions: <2024 85.2% · 2024 8.1% · >2024 6.7%. Historical dates overlap Mini fitting years.'
+    elif period_key == 'before_2024':
+        note = 'Strict UTC issue year <2024: 1,336 starts / 230 storms, all 1980–1999 here. These dates overlap Mini fitting years.'
     else:
         note = 'Strict UTC issue year >2024: 61 starts / 18 storms. Calendar 2024 is excluded, not counted as >2024.'
     fig.text(.055, .09, note, fontsize=10, color='#53647c')
@@ -94,7 +121,12 @@ def draw_chart(metrics, reference, periods, period_key, dest, title):
                'period': period_key, 'period_definition': periods['period_definition'][period_key],
                'metrics': [s[0] for s in specs], 'values': {k: metrics[k]['values'] for k, *_ in specs},
                'deepmind_status': 'complete_verified', 'deepmind_model': reference,
-               'models': list(models), 'bars_per_panel': 3, 'error_bars': False,
+               'models': list(models),
+               'bars_per_panel': 3 if all(metric_available(r) for r in metrics.values()) else None,
+               'available_bars_per_panel': {k: 3 if metric_available(r) else 0 for k, r in metrics.items()},
+               'coverage': {k: r['coverage'] for k, r in metrics.items()},
+               'unavailable_metrics': [k for k, r in metrics.items() if not metric_available(r)],
+               'error_bars': False,
                'zero_fill': False, 'model_forecasts_modified': False,
                'publication_audit_sha256': hashlib.sha256((ROOT/'evaluation/deepmind_daily/publication_audit.json').read_bytes()).hexdigest()}
     dest.with_suffix('.json').write_text(json.dumps(receipt, indent=2)+'\n')

release_tools/sync_public_model_cards.py

@@ -24,6 +24,7 @@ FILMS = ('mangkhut',)
 CURRENT_FIGURES = frozenset((
     'evaluation/released_daily/model_1_2_benchmark.png',
     'evaluation/released_daily/model_1_2_after_2024_benchmark.png',
+    'evaluation/released_daily/model_1_2_before_2024_benchmark.png',
     'docs/trackformer_1_2_architecture.svg',
 ))
 SYNC_FILES = (
@@ -51,6 +52,9 @@ SYNC_FILES = (
     'docs/daily_storm_benchmark.md',
     'docs/intensity_benchmark.md',
     'docs/trackformer_1_2_evaluation.md',
+    'docs/trackformer_1_2_training_data.md',
+    'evaluation/training_data/trackformer_1_2_provenance.json',
+    'release_tools/audit_training_data.py',
     'docs/deepmind_daily_benchmark.md',
     'docs/showcase_archive.md',
     'evaluation/README.md',
@@ -68,6 +72,8 @@ SYNC_FILES = (
     'evaluation/released_daily/model_1_2_benchmark.json',
     'evaluation/released_daily/model_1_2_after_2024_benchmark.png',
     'evaluation/released_daily/model_1_2_after_2024_benchmark.json',
+    'evaluation/released_daily/model_1_2_before_2024_benchmark.png',
+    'evaluation/released_daily/model_1_2_before_2024_benchmark.json',
     'evaluation/deepmind_daily/benchmark.json',
     'evaluation/deepmind_daily/verification.json',
     'evaluation/deepmind_daily/publication_audit.json',
@@ -187,13 +193,13 @@ def run(output, publish=False):
         # immutable commit in the card. Never pin new bytes to the old movie
         # revision or let a missing future image render as a stale figure.
         assets = api.create_commit(repo_id=REPO, repo_type='model', parent_commit=parent,
-            commit_message='Publish exact Mini <2024 identity, UTC proportions and total/post-2024 comparison charts',
+            commit_message='Add pre-2024 chart and verified Trackformer 1.2 training sources and cutoffs',
             operations=[CommitOperationAdd(path_in_repo=name, path_or_fileobj=str(ROOT/name)) for name in SYNC_FILES])
         card_path.write_text(render_card(original.read_text(), github, assets.oid))
         receipt['files']['README.md'] = sha(card_path)
         receipt['figure_revision'] = assets.oid
         committed = api.create_commit(repo_id=REPO, repo_type='model', parent_commit=assets.oid,
-            commit_message='Show completed Mini <2024 results with separate total and post-2024 benchmarks',
+            commit_message='Show total, pre-2024 and post-2024 results with explicit 1.2 training years',
             operations=[CommitOperationAdd(path_in_repo='README.md', path_or_fileobj=str(card_path))])
         for name, expected in receipt['files'].items():
             saved = hf_hub_download(REPO, name, revision=committed.oid, cache_dir=CACHE)

release_tools/test_deepmind_period_comparison.py

@@ -5,7 +5,7 @@ import unittest
 
 from build_deepmind_period_comparison import FOLDER, MODELS, ROOT, period_key, summarize
 from import_deepmind_release_results import same
-from plot_model_announcement import period_metrics
+from plot_model_announcement import metric_available, period_metrics
 
 
 class DeepMindPeriodComparisonTest(unittest.TestCase):
@@ -85,7 +85,9 @@ class DeepMindPeriodComparisonTest(unittest.TestCase):
         self.assertEqual(self.report['missing_results_scored_as_zero'], 0)
 
     def test_chart_receipts_match_exact_data_and_bytes(self):
-        for name, key in (('model_1_2_benchmark', 'total'), ('model_1_2_after_2024_benchmark', 'after_2024')):
+        for name, key in (('model_1_2_benchmark', 'total'),
+                          ('model_1_2_before_2024_benchmark', 'before_2024'),
+                          ('model_1_2_after_2024_benchmark', 'after_2024')):
             base = ROOT / 'evaluation/released_daily' / name
             receipt = json.loads(base.with_suffix('.json').read_text())
             self.assertEqual(receipt['period'], key)
@@ -95,6 +97,21 @@ class DeepMindPeriodComparisonTest(unittest.TestCase):
             expected = period_metrics(self.report['periods'][key])
             self.assertEqual(receipt['values'], {k: v['values'] for k, v in expected.items()})
             self.assertFalse(receipt['zero_fill'])
+            self.assertEqual(receipt['available_bars_per_panel'],
+                             {k: 3 if metric_available(v) else 0 for k, v in expected.items()})
+            self.assertEqual(receipt['coverage'], {k: v['coverage'] for k, v in expected.items()})
+            if key == 'before_2024':
+                self.assertIsNone(receipt['bars_per_panel'])
+                self.assertEqual(receipt['unavailable_metrics'], ['pressure_JMA_hpa'])
+
+    def test_unavailable_panel_is_not_zero_fill_or_invalid_numeric_score(self):
+        empty = {'values': {m: None for m in MODELS}, 'coverage': {'daily_issues': 0, 'storms': 0}}
+        self.assertFalse(metric_available(empty))
+        for values, coverage in (({m: 0 for m in MODELS}, empty['coverage']),
+                                 (empty['values'], {'daily_issues': 1, 'storms': 1}),
+                                 ({m: float('nan') for m in MODELS}, {'daily_issues': 1, 'storms': 1})):
+            with self.assertRaises(ValueError):
+                metric_available({'values': values, 'coverage': coverage})
 
 
 if __name__ == '__main__':

release_tools/test_public_model_cards.py

@@ -156,6 +156,7 @@ class PublicModelCardsTest(unittest.TestCase):
         for source in (self.source, render_card(self.original, self.source)):
             self.assertLess(source.index('**DeepMind checkpoint:'), source.index('model_1_2_benchmark.png'))
             self.assertEqual(source.count('model_1_2_benchmark.png'), 1)
+            self.assertEqual(source.count('model_1_2_before_2024_benchmark.png'), 1)
             self.assertEqual(source.count('model_1_2_after_2024_benchmark.png'), 1)
             for text in ('90.7%', '85.2%', '5.2%', '8.1%', '4.1%', '6.7%',
                          'Calendar 2024', '59 days / 18 storms / 1,174',
@@ -163,6 +164,45 @@ class PublicModelCardsTest(unittest.TestCase):
                          '100% Mini `<2024`; 0% other checkpoints'):
                 self.assertIn(text, source)
 
+    def test_historical_chart_and_missing_pressure_are_explicit(self):
+        report = json.loads((ROOT / 'evaluation/deepmind_daily/period_comparison.json').read_text())
+        before = report['periods']['before_2024']
+        for source in (self.source, render_card(self.original, self.source)):
+            section = source.split('### Before 2024', 1)[1].split('### After 2024', 1)[0]
+            for label, key, places in (('Historical track position MAE', 'mean_track_error_km', 1),
+                                       ('Historical track-direction error', 'direction_error_deg', 2),
+                                       ('Historical route-shape similarity', 'shape_similarity', 4)):
+                self.assert_metric_row(section, label,
+                    {m: before['scores']['route'][m][key]['value'] for m in ('1.1', '1.2', 'deepmind')}, places)
+            for text in ('Pressure is not scored', '0 shared valid pressure starts', 'not zero error', '1980–1999'):
+                self.assertIn(text, section)
+
+    def test_training_years_sources_and_receipt_match_release(self):
+        manifest = json.loads((ROOT / 'models/trackformer_1_2_field/manifest.json').read_text())
+        audit = json.loads((ROOT / 'evaluation/training_data/trackformer_1_2_provenance.json').read_text())
+        self.assertEqual(audit['status'], 'verified')
+        for key in ('source_checkpoint_sha256', 'inference_weights_sha256'):
+            self.assertEqual(audit[key], manifest[key])
+        self.assertEqual(audit['dataset_manifest_sha256'], manifest['dataset_sha256'])
+        self.assertEqual(audit['normalization_fit_years'], [2000, 2021])
+        self.assertEqual(len(audit['verified_archive_files']), 6)
+        self.assertTrue(audit['whole_storm_splits'])
+        for name, years, count, native in (('train', [2000, 2021], 13949, 800),
+                                           ('validation', [2022, 2023], 1041, 100),
+                                           ('test', [2024, 2025], 1195, 100)):
+            row = audit['partitions'][name]
+            self.assertEqual((row['years'], row['windows'], row['native_pressure_windows']), (years, count, native))
+        for key in ('inference_performed', 'model_weights_modified', 'training_data_modified'):
+            self.assertFalse(audit[key])
+        for source in (self.source, render_card(self.original, self.source)):
+            for text in ('## Training data and year cutoffs', '2000–2021', '2022–2023', '2024–2025',
+                         'not training through 2026', 'IBTrACS', 'NCEP/NCAR Reanalysis 1',
+                         'ARCO-ERA5', 'land fraction', '13,949', '1,041', '1,195'):
+                self.assertIn(text, source)
+        for path in ('docs/trackformer_1_2_training_data.md',
+                     'evaluation/training_data/trackformer_1_2_provenance.json', 'release_tools/audit_training_data.py'):
+            self.assertIn(path, SYNC_FILES)
+
     def test_evaluation_index_and_worker_handoff_metadata_are_explained(self):
         index = (ROOT / 'evaluation/README.md').read_text()
         self.assertIn('completed three-model comparison', index)