Open released TrackFormer 1.2 training source, exact corpus and optimizer checkpoints

.gitattributes

@@ -209,3 +209,10 @@ docs/report_figures/mangkhut_observed_r34.png filter=lfs diff=lfs merge=lfs -tex
 docs/report_figures/jebi_pressure_comparison.png filter=lfs diff=lfs merge=lfs -text
 docs/report_figures/jebi_track_pressure.png filter=lfs diff=lfs merge=lfs -text
 docs/report_figures/jebi_observed_r34.png filter=lfs diff=lfs merge=lfs -text
+training/trackformer_1_2/data/track_windows_v13.npz filter=lfs diff=lfs merge=lfs -text
+training/trackformer_1_2/data/basin_all_int8.npz filter=lfs diff=lfs merge=lfs -text
+training/trackformer_1_2/data/basin_slp_atlas_float16.npy filter=lfs diff=lfs merge=lfs -text
+training/trackformer_1_2/data/pressure_hpa.npy filter=lfs diff=lfs merge=lfs -text
+training/trackformer_1_2/data/geography.npz filter=lfs diff=lfs merge=lfs -text
+training/trackformer_1_2/checkpoints/v168_epoch_003.pt filter=lfs diff=lfs merge=lfs -text
+training/trackformer_1_2/checkpoints/v173_epoch_004.pt filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,19 +1,10 @@
----
-license: mit
-tags:
-- tropical-cyclone
-- weather-forecasting
-- sea-level-pressure
-- research
----
-
 # TrackFormer 1.2 — pressure maps and five-day typhoon forecasts
 
 An AI weather-research model designed to be trained and run on an ordinary home computer.
 
 TrackFormer 1.2 predicts **Western Pacific pressure maps**, then obtains the typhoon's route and central pressure from the predicted pressure field. It updates the surrounding weather and a moving storm core together, every six hours from **+6 to +120 hours**. Horizontal winds at three pressure levels are updated within the model, providing a basis for studying northeasterly and southwesterly flow; this report's scored results concern track and pressure, not demonstrated monsoon-wind skill.
 
-[Get the model](https://github.com/yu314-coder/typhoon-predict/releases/tag/trackformer-1.2) · [Hugging Face](https://huggingface.co/euler314/typhoon-predict) · [中文研究說明（與報告對照）](https://huggingface.co/euler314/typhoon-predict/blob/main/docs/research_report_zh.md) · [Live forecast](https://trackformer-weatherlab.rudin-euler-8253.chatgpt.site/live) · [Technical paper](https://huggingface.co/euler314/typhoon-predict/blob/main/paper/trackformer.pdf)
+[Get the model](https://github.com/yu314-coder/typhoon-predict/releases/tag/trackformer-1.2) · [Hugging Face](https://huggingface.co/euler314/typhoon-predict) · [中文研究說明（與報告對照）](docs/research_report_zh.md) · [Live forecast](https://trackformer-weatherlab.rudin-euler-8253.chatgpt.site/live) · [Technical paper](paper/trackformer.pdf)
 
 This page follows the Chinese research report **「訓練AI模型探討西北太平洋氣壓系統影響臺灣附近颱風的預測評估」** and its approved figure/text updates. It describes the released **1.2** model; later rainfall research is not a capability of these weights. The existing technical paper and older evaluation records remain separate, versioned references.
 
@@ -30,7 +21,7 @@ This is a **research release**, not an operational warning service. Follow offic
 
 ## See the forecast: Mangkhut (2018)
 
-<video controls preload="metadata" width="100%" aria-label="Trackformer 1.2 Mangkhut pressure and route forecast" poster="https://huggingface.co/euler314/typhoon-predict/resolve/87a6e366b42bb4cc0edc95d2c50c55fca21a2c93/evaluation/trackformer_1_2_mangkhut_video_poster.png" src="https://huggingface.co/euler314/typhoon-predict/resolve/87a6e366b42bb4cc0edc95d2c50c55fca21a2c93/docs/trackformer_1_2_mangkhut.mp4"></video>
+[![Trackformer 1.2 Mangkhut pressure and route forecast](docs/trackformer_1_2_mangkhut.gif)](https://huggingface.co/euler314/typhoon-predict/resolve/87a6e366b42bb4cc0edc95d2c50c55fca21a2c93/docs/trackformer_1_2_mangkhut.mp4)
 
 [Watch / download MP4](https://huggingface.co/euler314/typhoon-predict/resolve/87a6e366b42bb4cc0edc95d2c50c55fca21a2c93/docs/trackformer_1_2_mangkhut.mp4) · **11 September 2018, 00 UTC** · **50-member mean** · **20 seconds**
 
@@ -40,15 +31,15 @@ The animation shows twenty actual six-hour forecasts through +120 h. The Western
 
 This selected example illustrates the model, not typical skill. Observations are verification only. The 50 members are distinct seeded perturbations of **past and issue-time inputs**, not separately trained networks. Member fields are registered geographically before averaging; the mean centre need not locate the minimum of the mean map. Display interpolation does not add resolution to the approximately 20 km core.
 
-[Pressure arrays](https://huggingface.co/euler314/typhoon-predict/blob/main/evaluation/release_data/pressure_core/mangkhut/common-pressure.npz) · [Field verification](https://huggingface.co/euler314/typhoon-predict/blob/main/evaluation/release_data/pressure_core/mangkhut/verification.json) · [Playback verification](https://huggingface.co/euler314/typhoon-predict/blob/main/evaluation/release_data/mangkhut_playback_verification.json) · [More examples and diagnostics](https://huggingface.co/euler314/typhoon-predict/blob/main/docs/showcase_archive.md)
+[Pressure arrays](evaluation/release_data/pressure_core/mangkhut/common-pressure.npz) · [Field verification](evaluation/release_data/pressure_core/mangkhut/verification.json) · [Playback verification](evaluation/release_data/mangkhut_playback_verification.json) · [More examples and diagnostics](docs/showcase_archive.md)
 
 ## Results in the research report
 
 The completed comparison uses **1,473 daily starts / 270 storms**, with all twenty +6 to +120 h leads. The pressure comparison uses a **subset of those same 270 storms**, not a different 270-storm dataset.
 
-**DeepMind checkpoint: `WeatherNextCyclones_Mini_<2024` · trained through 2023 · native 1° · one member · WeatherNext software v0.3.0.** This is the official **Mini, not the full-sized WeatherNext model**. All reference forecasts completed on an **NVIDIA GeForce RTX 3070 using CUDA**. [Model identity and protocol](https://huggingface.co/euler314/typhoon-predict/blob/main/docs/deepmind_daily_benchmark.md) · [Completion receipt](https://huggingface.co/euler314/typhoon-predict/blob/main/evaluation/deepmind_daily/verification.json).
+**DeepMind checkpoint: `WeatherNextCyclones_Mini_<2024` · trained through 2023 · native 1° · one member · WeatherNext software v0.3.0.** This is the official **Mini, not the full-sized WeatherNext model**. All reference forecasts completed on an **NVIDIA GeForce RTX 3070 using CUDA**. [Model identity and protocol](docs/deepmind_daily_benchmark.md) · [Completion receipt](evaluation/deepmind_daily/verification.json).
 
-![Day 1 to day 5 track and central-pressure errors, matching the Chinese report](https://huggingface.co/euler314/typhoon-predict/resolve/2b6488f02f9eae6893fe174ddcde96b67151acb3/docs/report_figures/day_1_to_5.png)
+![Day 1 to day 5 track and central-pressure errors, matching the Chinese report](docs/report_figures/day_1_to_5.png)
 
 The bars show exact **24, 48, 72, 96 and 120 h** leads, not averages over each day. Track uses 270 storms; pressure uses 39–40 storms per displayed lead, with the counts printed in the figure. The table below averages all available six-hour leads using the common scoring procedure.
 
@@ -65,7 +56,7 @@ The bars show exact **24, 48, 72, 96 and 120 h** leads, not averages over each d
 
 On this mixed historical/recent development cohort, 1.2 has lower mean position and heading errors; Mini has lower central-pressure MAE. **The recent-only track results favour Mini**: for strict issue years after 2024 (2025–2026), mean error is **258.7 km** for Mini versus **469.4 km** for 1.2, on 61 starts / 18 storms. Calendar 2024 is excluded from that subset. The combined cohort contains 230 storms from 1980–1999 and 40 recent storms; historical dates overlap Mini's training years. Different inputs and member counts make this a development comparison, **not a controlled architecture ablation, equal-compute test or certified untouched holdout**.
 
-[Full saved scores and common support](https://huggingface.co/euler314/typhoon-predict/blob/main/evaluation/deepmind_daily/benchmark.json) · [Period breakdowns](https://huggingface.co/euler314/typhoon-predict/blob/main/evaluation/deepmind_daily/period_comparison.json) · [Independent publication audit](https://huggingface.co/euler314/typhoon-predict/blob/main/evaluation/deepmind_daily/publication_audit.json) · [Daily scoring protocol](https://huggingface.co/euler314/typhoon-predict/blob/main/docs/daily_storm_benchmark.md) · [Evaluation details and older comparisons](https://huggingface.co/euler314/typhoon-predict/blob/main/docs/trackformer_1_2_evaluation.md)
+[Full saved scores and common support](evaluation/deepmind_daily/benchmark.json) · [Period breakdowns](evaluation/deepmind_daily/period_comparison.json) · [Independent publication audit](evaluation/deepmind_daily/publication_audit.json) · [Daily scoring protocol](docs/daily_storm_benchmark.md) · [Evaluation details and older comparisons](docs/trackformer_1_2_evaluation.md)
 
 ## Three report examples
 
@@ -73,13 +64,13 @@ The report compares predicted and reference pressure at **+48 h**, and routes an
 
 | Example | Forecast issue (UTC) | Report figures |
 | --- | --- | --- |
-| Fung-wong / 鳳凰 (2025) | 2025-11-07 00:00 | [Pressure](https://huggingface.co/euler314/typhoon-predict/resolve/2b6488f02f9eae6893fe174ddcde96b67151acb3/docs/report_figures/fung_wong_pressure_comparison.png) · [Track / central pressure](https://huggingface.co/euler314/typhoon-predict/resolve/2b6488f02f9eae6893fe174ddcde96b67151acb3/docs/report_figures/fung_wong_track_pressure.png) · [Observed R34](https://huggingface.co/euler314/typhoon-predict/resolve/2b6488f02f9eae6893fe174ddcde96b67151acb3/docs/report_figures/fung_wong_observed_r34.png) |
-| Mangkhut / 山竹 (2018) | 2018-09-11 00:00 | [Pressure](https://huggingface.co/euler314/typhoon-predict/resolve/2b6488f02f9eae6893fe174ddcde96b67151acb3/docs/report_figures/mangkhut_pressure_comparison.png) · [Track / central pressure](https://huggingface.co/euler314/typhoon-predict/resolve/2b6488f02f9eae6893fe174ddcde96b67151acb3/docs/report_figures/mangkhut_track_pressure.png) · [Observed R34](https://huggingface.co/euler314/typhoon-predict/resolve/2b6488f02f9eae6893fe174ddcde96b67151acb3/docs/report_figures/mangkhut_observed_r34.png) |
-| Jebi / 燕子 (2018) | 2018-08-31 00:00 | [Pressure](https://huggingface.co/euler314/typhoon-predict/resolve/2b6488f02f9eae6893fe174ddcde96b67151acb3/docs/report_figures/jebi_pressure_comparison.png) · [Track / central pressure](https://huggingface.co/euler314/typhoon-predict/resolve/2b6488f02f9eae6893fe174ddcde96b67151acb3/docs/report_figures/jebi_track_pressure.png) · [Observed R34](https://huggingface.co/euler314/typhoon-predict/resolve/2b6488f02f9eae6893fe174ddcde96b67151acb3/docs/report_figures/jebi_observed_r34.png) |
+| Fung-wong / 鳳凰 (2025) | 2025-11-07 00:00 | [Pressure](docs/report_figures/fung_wong_pressure_comparison.png) · [Track / central pressure](docs/report_figures/fung_wong_track_pressure.png) · [Observed R34](docs/report_figures/fung_wong_observed_r34.png) |
+| Mangkhut / 山竹 (2018) | 2018-09-11 00:00 | [Pressure](docs/report_figures/mangkhut_pressure_comparison.png) · [Track / central pressure](docs/report_figures/mangkhut_track_pressure.png) · [Observed R34](docs/report_figures/mangkhut_observed_r34.png) |
+| Jebi / 燕子 (2018) | 2018-08-31 00:00 | [Pressure](docs/report_figures/jebi_pressure_comparison.png) · [Track / central pressure](docs/report_figures/jebi_track_pressure.png) · [Observed R34](docs/report_figures/jebi_observed_r34.png) |
 
 All three use the same released checkpoint and 50-input-member policy. Fung-wong and Mangkhut use saved Metal forecasts; Jebi uses CPU forecasts from the same weights. Mangkhut and Jebi lie within the fitting years and are retrospective demonstrations, not unseen-case accuracy evidence. **The R34 panels are IBTrACS observed 34-knot quadrant-radius records, not model radius predictions or full wind maps.** Missing radii are left missing. There is **no native wind-radius forecast head** in 1.2.
 
-[All report panels with captions](https://huggingface.co/euler314/typhoon-predict/blob/main/docs/research_report_zh.md#三個颱風展示) · [Figure hashes and sources](https://huggingface.co/euler314/typhoon-predict/blob/main/docs/report_figures/provenance.json) · [Earlier films and diagnostic archive](https://huggingface.co/euler314/typhoon-predict/blob/main/docs/showcase_archive.md)
+[All report panels with captions](docs/research_report_zh.md#三個颱風展示) · [Figure hashes and sources](docs/report_figures/provenance.json) · [Earlier films and diagnostic archive](docs/showcase_archive.md)
 
 ## Training data and year cutoffs
 
@@ -104,11 +95,11 @@ The eastward/northward wind pairs **u/v carry both direction and speed** at 850,
 
 The checksum-pinned source caches extend further: the derived typhoon archive reaches **13 July 2026**, and the NCEP basin archive reaches **17 March 2026, 18 UTC**. Those endpoints describe archive availability, **not the fitting cutoff**. Later live weather uses separately documented experimental GFS transfer; it does not update the released weights. This release has no satellite cloud-image or humidity input channel. Previously inspected test/showcase storms remain development evidence, not a newly untouched holdout.
 
-[Training-source details and exact date ranges](https://huggingface.co/euler314/typhoon-predict/blob/main/docs/trackformer_1_2_training_data.md) · [Recomputed split counts and verified dataset hashes](https://huggingface.co/euler314/typhoon-predict/blob/main/evaluation/training_data/trackformer_1_2_provenance.json)
+[Training-source details and exact date ranges](docs/trackformer_1_2_training_data.md) · [Recomputed split counts and verified dataset hashes](evaluation/training_data/trackformer_1_2_provenance.json)
 
 ## How Trackformer 1.2 works
 
-![Trackformer 1.2: causal weather history, coupled basin and moving core, pressure-based readout and autoregressive rollout](https://huggingface.co/euler314/typhoon-predict/resolve/2b6488f02f9eae6893fe174ddcde96b67151acb3/docs/trackformer_1_2_architecture.svg)
+![Trackformer 1.2: causal weather history, coupled basin and moving core, pressure-based readout and autoregressive rollout](docs/trackformer_1_2_architecture.svg)
 
 1. **Initialize from the past.** Nine six-hour analyses provide MSLP, 500 hPa height and winds at 850/500/200 hPa, ending at issue time. Static geography, the current observed centre, recent motion, current intensity and validity masks accompany the history. Native regional pressure detail is used when available; missing detail stays flagged. Current observations initialize the core, not future labels.
 2. **Update the surrounding weather.** The model estimates changes in pressure and horizontal winds and carries information forward to the next six-hour step.
@@ -123,7 +114,7 @@ The checksum-pinned source caches extend further: the derived typhoon archive re
 | Moving core | 65 × 65; approximately 20 km spacing |
 | Forecast steps | 20 × 6 hours |
 
-Training increases the prediction horizon from one to two, three and five days, checking the full five-day forecast each epoch. The report uses the selected **epoch-4** checkpoint. [Model source and input contract](https://huggingface.co/euler314/typhoon-predict/blob/main/models/trackformer_1_2_field/README.md) · [Exact architecture and provenance](https://huggingface.co/euler314/typhoon-predict/blob/main/models/trackformer_1_2_field/manifest.json).
+Training increases the prediction horizon from one to two, three and five days, checking the full five-day forecast each epoch. The report uses the selected **epoch-4** checkpoint. [Model source and input contract](models/trackformer_1_2_field/README.md) · [Exact architecture and provenance](models/trackformer_1_2_field/manifest.json).
 
 ### What “50 forecasts averaged” means
 
@@ -137,11 +128,17 @@ Routes and central pressures are averaged separately. Physical member pressure f
 - **NVIDIA GeForce RTX 3070 / CUDA:** verified execution of the completed DeepMind reference benchmark. This is hardware, not a software package.
 - **Python / PyTorch**, NumPy, SciPy, xarray, netCDF4 and Matplotlib support modelling, data handling and figures. The Chinese report uses XeLaTeX / xeCJK.
 
+## Train the released 1.2 architecture
+
+The [open training package](training/trackformer_1_2/README.md) contains the original trainer, architecture, losses, sampler, resume logic, tests, data-preparation utilities and explicit launch configuration. The **exact six derived training-array files**, original manifest, **v168 epoch-3 warm start** and selected **v173 epoch-4 full checkpoint with optimizer/RNG state** are public on [Hugging Face](https://huggingface.co/euler314/typhoon-predict/tree/main/training/trackformer_1_2). A checksum-verifying downloader works without the old Drive setup. Source and instructions are mirrored on both repositories; large binary assets are served by Hugging Face and linked from GitHub.
+
+This opens the actual released training path; it does not claim a newly reproduced training run or an untouched benchmark. The archived raw IBTrACS snapshot ID was not recorded. The report's selected epoch 4 is **not** the minimum aggregate validation-loss checkpoint: the saved history's minimum is epoch 2. See the training package for historical metadata and remaining reproducibility limits.
+
 ## Get started
 
 [Download weights and the complete pressure-map exporter](https://github.com/yu314-coder/typhoon-predict/releases/download/trackformer-1.2/trackformer_1_2_field_pressure_export_v2.tar.gz), or use this repository with the [Hugging Face weights](https://huggingface.co/euler314/typhoon-predict/resolve/main/models/trackformer_1_2_field/weights.pt). Put `weights.pt` in `models/trackformer_1_2_field/`. The inference weights and learned model equations are unchanged; the package includes the moving-core output and map renderer.
 
-Prepare a normalized causal issue packet following the [input schema](https://huggingface.co/euler314/typhoon-predict/blob/main/models/trackformer_1_2_field/README.md), then run with PyTorch and NumPy:
+Prepare a normalized causal issue packet following the [input schema](models/trackformer_1_2_field/README.md), then run with PyTorch and NumPy:
 
 ```bash
 python models/trackformer_1_2_field/predict.py causal_issue_packet.npz forecast.npz --device mps
@@ -155,7 +152,7 @@ For an immediate whole-WP and detailed-core PNG, add `--pressure-map pressure_12
 python models/trackformer_1_2_field/plot_pressure.py forecast.npz pressure_24h.png --lead 24 --interval 2
 ```
 
-Blue denotes low pressure and red high pressure. The renderer uses the actual saved moving field, coordinates and masks; it never draws a replacement vortex around a scalar pressure or observed track. See the [pressure-output schema](https://huggingface.co/euler314/typhoon-predict/blob/main/models/trackformer_1_2_field/README.md#render-a-pressure-map-directly).
+Blue denotes low pressure and red high pressure. The renderer uses the actual saved moving field, coordinates and masks; it never draws a replacement vortex around a scalar pressure or observed track. See the [pressure-output schema](models/trackformer_1_2_field/README.md#render-a-pressure-map-directly).
 
 The inference weight SHA-256 is `db49f36e85a3766defc4c172746897a1f783705d1ce8e6f9dfb8e87ae1d902cb`.
 
@@ -171,10 +168,10 @@ The archive covers a pinned Western Pacific plan: six-hour starts from 1996 onwa
 
 The auxiliary wind's averaging period and surface-wind skill are not validated. Optional pressure-derived wind/radius estimates are experimental diagnostics, not agency-equivalent forecasts. Pressure-map interpolation is not evidence of finer effective resolution. Retrospective analyses and experimental GFS live transfer must not be presented as operational validation.
 
-See [wind-estimation assumptions](https://huggingface.co/euler314/typhoon-predict/blob/main/models/trackformer_1_2_field/WIND_ESTIMATION.md), [full intensity evaluation](https://huggingface.co/euler314/typhoon-predict/blob/main/docs/intensity_benchmark.md), [evaluation limits](https://huggingface.co/euler314/typhoon-predict/blob/main/docs/trackformer_1_2_evaluation.md), and the [example archive](https://huggingface.co/euler314/typhoon-predict/blob/main/docs/showcase_archive.md). Source, normalization and checkpoint identities are recorded in the [manifest](https://huggingface.co/euler314/typhoon-predict/blob/main/models/trackformer_1_2_field/manifest.json). Older release comparisons remain in the linked technical records, not the report's two-model headline table.
+See [wind-estimation assumptions](models/trackformer_1_2_field/WIND_ESTIMATION.md), [full intensity evaluation](docs/intensity_benchmark.md), [evaluation limits](docs/trackformer_1_2_evaluation.md), and the [example archive](docs/showcase_archive.md). Source, normalization and checkpoint identities are recorded in the [manifest](models/trackformer_1_2_field/manifest.json). Older release comparisons remain in the linked technical records, not the report's two-model headline table.
 
 ## Ongoing work: Taiwan rainfall
 
 Ongoing research combines moisture, wind direction, weather outside Taiwan and terrain to study ordinary and heavy rainfall over Taiwan, with a separate observation-based evaluation. **Released 1.2 has no rainfall forecast head or humidity input.** These are research directions, not demonstrated rainfall improvements from the pressure model.
 
-Model code is in [`models/`](https://huggingface.co/euler314/typhoon-predict/tree/main/models/), methods in [`paper/`](https://huggingface.co/euler314/typhoon-predict/tree/main/paper/), protocols in [`docs/`](https://huggingface.co/euler314/typhoon-predict/tree/main/docs/), results in [`evaluation/`](https://huggingface.co/euler314/typhoon-predict/tree/main/evaluation/) and reproducible utilities in [`release_tools/`](https://huggingface.co/euler314/typhoon-predict/tree/main/release_tools/).
+Model code is in [`models/`](models/), methods in [`paper/`](paper/), protocols in [`docs/`](docs/), results in [`evaluation/`](evaluation/) and reproducible utilities in [`release_tools/`](release_tools/).

docs/repository_layout.md

@@ -17,3 +17,7 @@ The 1.1-versus-1.2 comparison arrays, TIP diagnostic, current paper, weights, mo
 ## Recovery
 
 The complete pre-cleanup repository remains in [commit 459a3d014aa4794652ceba3ecdffcde0beada2cd](https://github.com/yu314-coder/typhoon-predict/tree/459a3d014aa4794652ceba3ecdffcde0beada2cd). The [Trackformer 1.1 release](https://github.com/yu314-coder/typhoon-predict/releases/tag/trackformer-1.1) remains available. This cleanup does not rewrite Git history.
+
+## Released 1.2 training
+
+`training/trackformer_1_2/` contains the original training source, launch wrapper, requirements, historical preparation tools, configuration, hashes and public asset downloader. Large arrays and optimizer checkpoints live at the identical Hugging Face path and are referenced from GitHub.

docs/trackformer_1_2_training_data.md

@@ -57,4 +57,6 @@ With the original frozen dataset available, reproduce the small receipt without
 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.
+The exact derived arrays, original manifest, warm start and selected full training checkpoint are now publicly available in [the open training package](../training/trackformer_1_2/README.md). Original source bytes and frozen model weights are unchanged. The additive publication does not run training or modify any active trainer.
+
+The source archive includes historical ERA5 preparation utilities; its small full-field pilot is not the released six-file corpus. Use the published exact corpus to reproduce the released data boundary. No missing raw IBTrACS provenance has been invented.

training/trackformer_1_2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yu Yao-Hsing (yu314-coder)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

training/trackformer_1_2/README.md

@@ -0,0 +1,63 @@
+# TrackFormer 1.2: open training package
+
+This is the actual released pressure-field model: development **1.2.73 (v173), epoch 4**, 21,452,595 parameters. It is separate from older route-only 1.2 experiments and later rainfall models.
+
+## Published contents
+
+- `source/v173/`: original, byte-identical model, baseline architecture, archive loader, objective, curriculum, sampler, trainer, resume logic, design and original Metal tests.
+- `source/data_preparation/`: original historical ERA5 download/plan utilities and dataset contracts. The small full-field pilot described there is **not** the six-file training corpus.
+- `assets.json`: exact sizes and SHA-256 values for all six original derived archives, the original manifest, warm-start checkpoint and selected full training checkpoint.
+- `data/`: those exact public arrays, including original split plan, labels/masks and static geography. Binary files are hosted on Hugging Face at the identical path, not committed into GitHub source history.
+- `checkpoints/v168_epoch_003.pt`: the original, mandatory warm start, previously split across Drive files.
+- `checkpoints/v173_epoch_004.pt`: the selected full training checkpoint, with model, optimizer, normalization, four-epoch history and Python/NumPy/Torch CPU RNG states.
+- `config.json`, `checkpoint-history.json`, `SOURCE_MANIFEST.json`: archived recipe, exact saved loss history and source hashes.
+- `train.py`: a path-portability wrapper; it calls the unmodified original trainer with explicit paths and settings. No module import starts training.
+- Model export, physical pressure-map rendering and benchmark tools remain in the repository's `release_tools/` and `models/trackformer_1_2_field/`.
+
+Both [GitHub](https://github.com/yu314-coder/typhoon-predict/tree/main/training/trackformer_1_2) and [Hugging Face](https://huggingface.co/euler314/typhoon-predict/tree/main/training/trackformer_1_2) carry the source and instructions. Hugging Face serves the large assets (2,644,261,044 bytes in total); no Drive permission is required.
+
+## Download and verify
+
+From the repository root, after obtaining this source folder:
+
+```bash
+python training/trackformer_1_2/download_assets.py
+python training/trackformer_1_2/download_assets.py --verify-only
+python -m pip install -r training/trackformer_1_2/requirements.txt
+```
+
+The downloader uses only Python's standard library. It publishes each local file only after exact size/SHA verification and does not overwrite a differing existing file. Use `--revision <immutable-HF-commit>` from `PUBLICATION.md` to pin the upload; even the default `main` URL must match the fixed hashes. For a writable data/output directory on an external disk, copy the package there or set `--destination`; then pass its `data` and `checkpoints` paths to the launcher.
+
+## Preflight, then explicitly start training
+
+```bash
+python training/trackformer_1_2/train.py --device mps --output runs/retrain-1.2 --preflight
+python training/trackformer_1_2/train.py --device mps --output runs/retrain-1.2
+```
+
+Use `--device cuda` for NVIDIA or `--device cpu` for CPU. This wrapper explicitly sets the archived notebook/design recipe: effective batch 10, microbatch 4, workers 3, four epochs; pass flags to change execution settings deliberately. It uses FP32 even though the historical notebook's compatibility AMP positional flag was 1. The unchanged original entry point is also available:
+
+```bash
+python training/trackformer_1_2/source/v173/v173_pressure_train.py 10 3 0 \
+  --microbatch 4 --epochs 4 --device mps \
+  --manifest training/trackformer_1_2/data/manifest.json \
+  --warm-start training/trackformer_1_2/checkpoints/v168_epoch_003.pt \
+  --output runs/retrain-1.2
+```
+
+The original loader hashes all arrays, reconstructs a writable basin mmap beside the dataset, recomputes train-only normalization and enforces counts **13,949 / 1,041 / 1,195** with native-pressure subsets **800 / 100 / 100**. Allow space for that extra approximately 390 MB mmap and approximately 260 MB checkpoint files. Do not point preflight/training at an active trainer's data/output directories. The trainer uses a per-output lock; the same output resumes its `last.pt`. SIGINT/SIGTERM request a checkpoint at an optimizer boundary. Training horizons are 4/8/12/20 six-hour steps; validation always uses 20 steps. Four-step truncated backpropagation, gradient clipping, AdamW settings and all losses are in the original source.
+
+## Provenance and honest reproduction limits
+
+- Dataset manifest: `04fd0d30620137aad20173dcd59e22da2a6c20fae2f17de593e91a59517459c1`.
+- Warm start: `99ed776097e05ad6df03375465d9618741bed63a4ee57724d3ba98e295039d30`.
+- Selected full checkpoint: `f194a23d3f91ea76ad776dfad942fabd669eeae8b3fd665815463095367e9ee0`.
+- Inference-only weights: `db49f36e85a3766defc4c172746897a1f783705d1ce8e6f9dfb8e87ae1d902cb`.
+
+The selected full checkpoint is epoch **4**, used by the report; **it is not the smallest saved aggregate validation loss** (epoch 2 is 0.6939101; epoch 4 is 0.7283264). A fresh run's `best.pt` follows the original minimum-validation criterion and need not be the report's epoch-4 checkpoint. Do not conflate these choices. The supplied warm start makes the actual v173 training path runnable without reconstructing every earlier experimental model. Historical v168 optimization logs and complete original runtime package versions/accelerator RNG states are not archived here. The recipe is preserved from the original notebook/design, not a newly recovered complete original process argv. Bitwise end-to-end retraining across devices has **not** been demonstrated.
+
+The exact derived data are published; the raw IBTrACS release/download ID was not recorded in the frozen manifest. Current upstream downloads may differ and cannot be claimed byte-identical. Fitting uses 2000–2021, validation 2022–2023, original test 2024–2025, with complete storms separated. Later cache records are not fitting years. All future fields/positions are labels only. Repeatedly inspected tests/showcases are development evidence, not a fresh unused holdout. This publication does not rerun training, change released weights or modify active rainfall training.
+
+## Licenses and attribution
+
+Project source and project checkpoints retain the repository's MIT license. Upstream weather/track data retain their own terms and attributions, not the MIT software license; see `THIRD_PARTY_NOTICES.md`. Downloaded full checkpoints use Python pickle containers: load these identified, checksum-verified project artifacts only.

training/trackformer_1_2/SOURCE_MANIFEST.json

@@ -0,0 +1,178 @@
+{
+  "schema": "trackformer-1.2-open-training-source-v1",
+  "unchanged_original_sources": true,
+  "model_weights_modified": false,
+  "files": [
+    {
+      "path": "training/trackformer_1_2/LICENSE",
+      "sha256": "090a97ebbccef9de77cb3898c473f5c9ada7e140777957f1195fc6ab89b9a313",
+      "bytes": 1083
+    },
+    {
+      "path": "training/trackformer_1_2/requirements.txt",
+      "sha256": "37e15a665eff6c8ee94c47ac2da0f7c7e2d699b7e21623b0289da4cf5d3995d0",
+      "bytes": 45
+    },
+    {
+      "path": "training/trackformer_1_2/config.json",
+      "sha256": "813f5d05a3dec5ec160b4e91eb80970fb11d88416fc7709ffc9d147fc880316b",
+      "bytes": 820
+    },
+    {
+      "path": "training/trackformer_1_2/THIRD_PARTY_NOTICES.md",
+      "sha256": "f764dd203eb124fa6192edd3b7b49a7a546cd5d69d3a8a250589a14ce43e2115",
+      "bytes": 1697
+    },
+    {
+      "path": "training/trackformer_1_2/checkpoint-history.json",
+      "sha256": "8b9593a7ed58c1bd28dd27c8049c89a0c5c5644a30bfe5203a4b54c445ff2fb4",
+      "bytes": 459
+    },
+    {
+      "path": "training/trackformer_1_2/README.md",
+      "sha256": "342c43d94710355101ddc5bcad44923f47707f473eb803398f44fe2d77e8ace9",
+      "bytes": 6560
+    },
+    {
+      "path": "training/trackformer_1_2/train.py",
+      "sha256": "4502a87bfafb11667015070c6fad37b723b4a53723789febda075fba1c7770e8",
+      "bytes": 1436
+    },
+    {
+      "path": "training/trackformer_1_2/download_assets.py",
+      "sha256": "01d21d09c001394f49d807314e38b22a4a8c179783a3f22ddaa4c27e8c3f2011",
+      "bytes": 3049
+    },
+    {
+      "path": "training/trackformer_1_2/assets.json",
+      "sha256": "a59148e9ba2617599614784b47789c3654df1a7809ee039e78bcd00fe982b211",
+      "bytes": 1993
+    },
+    {
+      "path": "training/trackformer_1_2/source/v173/test_model.py",
+      "sha256": "493e0db88a098c89bb4db5e6c577fa24b4b7bcb83ce547dceac35237dbce7206",
+      "bytes": 5579
+    },
+    {
+      "path": "training/trackformer_1_2/source/v173/v165_base.py",
+      "sha256": "5c9473993a19d0fed00055494b5c1f50c1006aaf46551ff50145f67048c3374a",
+      "bytes": 39040
+    },
+    {
+      "path": "training/trackformer_1_2/source/v173/v173_pressure_train.py",
+      "sha256": "f40691cec3e787f4ac3c189f647efb0953c1eaa7e03fc86edaf4fee06990b2be",
+      "bytes": 11200
+    },
+    {
+      "path": "training/trackformer_1_2/source/v173/model.py",
+      "sha256": "5dab06c20224cf48c51302122455ee7e16948f977bf4b760fd8aff5d443ab0bc",
+      "bytes": 3428
+    },
+    {
+      "path": "training/trackformer_1_2/source/v173/DESIGN.md",
+      "sha256": "163ae39ff572f23c519d65e27ee6a8db23b47df9461670709229ccf95130049a",
+      "bytes": 3278
+    },
+    {
+      "path": "training/trackformer_1_2/source/v173/baseline_model.py",
+      "sha256": "6c05941fd93baaca04508877edc69f8f0394b70e0a64e734ef0d2c1e8832246a",
+      "bytes": 10040
+    },
+    {
+      "path": "training/trackformer_1_2/source/data_preparation/v164_prepare_data.py",
+      "sha256": "c1746e0c0f985890a0f02061a2d84b521cc7b29042c92972aa1ebab3354e4c95",
+      "bytes": 19312
+    },
+    {
+      "path": "training/trackformer_1_2/source/data_preparation/requirements.txt",
+      "sha256": "54918b8f29330299e18b8924e9cd93d05807e7f8cd99b2efd4805e9be94003c1",
+      "bytes": 55
+    },
+    {
+      "path": "training/trackformer_1_2/source/data_preparation/v164_structure_research.md",
+      "sha256": "a4b40e50b7d0d1433a162438f14ed110541702c4cec2a386959857293ea78141",
+      "bytes": 17119
+    },
+    {
+      "path": "training/trackformer_1_2/source/data_preparation/v164_download_pressure_geography.py",
+      "sha256": "b8602cd2fba131a287dc9e25781c8f037d3325fec8a23203576916c2f7d2189c",
+      "bytes": 9256
+    },
+    {
+      "path": "training/trackformer_1_2/source/data_preparation/v164_prepare_mac.py",
+      "sha256": "7e7313f865369d42f67645196b4af0e1b2b84216303f7b2b61e577d3734df79a",
+      "bytes": 1309
+    },
+    {
+      "path": "training/trackformer_1_2/source/data_preparation/v164_dataset_contract.md",
+      "sha256": "cfd838651e632aba0d2439ba202a59895bd4df22137185974df1d97f0e2525d4",
+      "bytes": 4664
+    },
+    {
+      "path": "training/trackformer_1_2/source/data_preparation/v164_global_regional_train.py",
+      "sha256": "c0808a1467695d2bc2ad8483aa4f4c6de1463628221024ac559f6204effe7978",
+      "bytes": 52581
+    },
+    {
+      "path": "training/trackformer_1_2/source/data_preparation/v164_reuse_impl.py",
+      "sha256": "2da0078d4a74faa93f8cf874e42707b01f286406f0ceaa4db1814aab0eceb7d1",
+      "bytes": 18414
+    }
+  ],
+  "assets": [
+    {
+      "path": "training/trackformer_1_2/data/manifest.json",
+      "sha256": "04fd0d30620137aad20173dcd59e22da2a6c20fae2f17de593e91a59517459c1",
+      "bytes": 814,
+      "group": "data"
+    },
+    {
+      "path": "training/trackformer_1_2/data/track_windows_v13.npz",
+      "sha256": "cb8d7291aa8140124ca522feb448a1d44124b018efc4ba1d54824b60a4f73451",
+      "bytes": 42755049,
+      "group": "data"
+    },
+    {
+      "path": "training/trackformer_1_2/data/basin_all_int8.npz",
+      "sha256": "71e5f1bb46c44e5936c506a3f8af021c1fe94c238ed030c05c66e8f342374b6d",
+      "bytes": 274115577,
+      "group": "data"
+    },
+    {
+      "path": "training/trackformer_1_2/data/basin_slp_atlas_float16.npy",
+      "sha256": "9f6a4ec7b2f6beadfa1075af9176d2a653e39a824d504d989e5e56e19c571521",
+      "bytes": 111394928,
+      "group": "data"
+    },
+    {
+      "path": "training/trackformer_1_2/data/pressure_hpa.npy",
+      "sha256": "16cc1b153aeee5eff4b67337b599892dcd86a5716554596b8031048035d247ba",
+      "bytes": 1698356128,
+      "group": "data"
+    },
+    {
+      "path": "training/trackformer_1_2/data/plan.json",
+      "sha256": "117eb291e385a326191be2f73182ed6dcbf0e9f99745780ac9e49a29def3d8da",
+      "bytes": 295005,
+      "group": "data"
+    },
+    {
+      "path": "training/trackformer_1_2/data/geography.npz",
+      "sha256": "f5471471da4a1e15f85fbfb2529065806281357c8e50cb272fcd2b02e8553b96",
+      "bytes": 2547017,
+      "group": "data"
+    },
+    {
+      "path": "training/trackformer_1_2/checkpoints/v168_epoch_003.pt",
+      "sha256": "99ed776097e05ad6df03375465d9618741bed63a4ee57724d3ba98e295039d30",
+      "bytes": 256826555,
+      "group": "checkpoints"
+    },
+    {
+      "path": "training/trackformer_1_2/checkpoints/v173_epoch_004.pt",
+      "sha256": "f194a23d3f91ea76ad776dfad942fabd669eeae8b3fd665815463095367e9ee0",
+      "bytes": 257969971,
+      "group": "checkpoints"
+    }
+  ]
+}

training/trackformer_1_2/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,9 @@
+# Data sources and attribution
+
+The MIT license covers project code and project model artifacts; it does not replace upstream data terms.
+
+- **NOAA PSL NCEP/NCAR Reanalysis 1**: basin mean sea-level pressure, 500 hPa height and winds at 850/500/200 hPa. Data provided by NOAA PSL, Boulder, Colorado, USA. https://psl.noaa.gov/data/gridded/data.ncep.reanalysis.html
+- **NOAA/NCEI IBTrACS**: derived storm observations, labels and masks; credit the original contributing meteorological agencies and NOAA/NCEI. Knapp et al. (2010), doi:10.1175/2009BAMS2755.1. https://www.ncei.noaa.gov/products/international-best-track-archive . Exact derived archive SHA is in assets.json; its original raw snapshot ID was not recorded.
+- **Copernicus Climate Change Service (C3S), ERA5, accessed through Google's ARCO-ERA5 mirror**: native mean-sea-level-pressure patches and static land fraction/elevation. Contains modified Copernicus Climate Change Service information (2026). ERA5 hourly single-level data, doi:10.24381/cds.adbb2d47, https://cds.climate.copernicus.eu/datasets/reanalysis-era5-single-levels . The current dataset lists a CC-BY licence; attribution and upstream terms apply. ECMWF or the European Commission does not endorse this model. ARCO mirror and recipes: https://github.com/google-research/arco-era5 . The mirror's code licence is separate from the underlying meteorological data licence.
+
+The published arrays are transformed subsets: quantized/coarse basin grids, float16 pressure, issue-centred patches, normalized derived track features and masks. These transformations do not create new native observational resolution. No claim of endorsement by NOAA, ECMWF, C3S or Google is made.

training/trackformer_1_2/assets.json

@@ -0,0 +1,60 @@
+{
+  "repository": "euler314/typhoon-predict",
+  "repo_type": "model",
+  "files": [
+    {
+      "path": "training/trackformer_1_2/data/manifest.json",
+      "sha256": "04fd0d30620137aad20173dcd59e22da2a6c20fae2f17de593e91a59517459c1",
+      "bytes": 814,
+      "group": "data"
+    },
+    {
+      "path": "training/trackformer_1_2/data/track_windows_v13.npz",
+      "sha256": "cb8d7291aa8140124ca522feb448a1d44124b018efc4ba1d54824b60a4f73451",
+      "bytes": 42755049,
+      "group": "data"
+    },
+    {
+      "path": "training/trackformer_1_2/data/basin_all_int8.npz",
+      "sha256": "71e5f1bb46c44e5936c506a3f8af021c1fe94c238ed030c05c66e8f342374b6d",
+      "bytes": 274115577,
+      "group": "data"
+    },
+    {
+      "path": "training/trackformer_1_2/data/basin_slp_atlas_float16.npy",
+      "sha256": "9f6a4ec7b2f6beadfa1075af9176d2a653e39a824d504d989e5e56e19c571521",
+      "bytes": 111394928,
+      "group": "data"
+    },
+    {
+      "path": "training/trackformer_1_2/data/pressure_hpa.npy",
+      "sha256": "16cc1b153aeee5eff4b67337b599892dcd86a5716554596b8031048035d247ba",
+      "bytes": 1698356128,
+      "group": "data"
+    },
+    {
+      "path": "training/trackformer_1_2/data/plan.json",
+      "sha256": "117eb291e385a326191be2f73182ed6dcbf0e9f99745780ac9e49a29def3d8da",
+      "bytes": 295005,
+      "group": "data"
+    },
+    {
+      "path": "training/trackformer_1_2/data/geography.npz",
+      "sha256": "f5471471da4a1e15f85fbfb2529065806281357c8e50cb272fcd2b02e8553b96",
+      "bytes": 2547017,
+      "group": "data"
+    },
+    {
+      "path": "training/trackformer_1_2/checkpoints/v168_epoch_003.pt",
+      "sha256": "99ed776097e05ad6df03375465d9618741bed63a4ee57724d3ba98e295039d30",
+      "bytes": 256826555,
+      "group": "checkpoints"
+    },
+    {
+      "path": "training/trackformer_1_2/checkpoints/v173_epoch_004.pt",
+      "sha256": "f194a23d3f91ea76ad776dfad942fabd669eeae8b3fd665815463095367e9ee0",
+      "bytes": 257969971,
+      "group": "checkpoints"
+    }
+  ]
+}

training/trackformer_1_2/checkpoint-history.json

@@ -0,0 +1,26 @@
+[
+  {
+    "epoch": 1,
+    "horizon": 4,
+    "train": 0.1411035786937901,
+    "validation": 0.7017406511544373
+  },
+  {
+    "epoch": 2,
+    "horizon": 8,
+    "train": 0.18676476989154306,
+    "validation": 0.6939100875934489
+  },
+  {
+    "epoch": 3,
+    "horizon": 12,
+    "train": 0.23248198316925273,
+    "validation": 0.7200751373592149
+  },
+  {
+    "epoch": 4,
+    "horizon": 20,
+    "train": 0.3557772162892601,
+    "validation": 0.7283263609942383
+  }
+]

training/trackformer_1_2/checkpoints/v168_epoch_003.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99ed776097e05ad6df03375465d9618741bed63a4ee57724d3ba98e295039d30
+size 256826555

training/trackformer_1_2/checkpoints/v173_epoch_004.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f194a23d3f91ea76ad776dfad942fabd669eeae8b3fd665815463095367e9ee0
+size 257969971

training/trackformer_1_2/config.json

@@ -0,0 +1,29 @@
+{
+  "public_version": "1.2",
+  "development_version": "1.2.73",
+  "seed": 168,
+  "optimizer": {
+    "name": "AdamW",
+    "lr": 3e-05,
+    "weight_decay": 0.01
+  },
+  "gradient_clip_norm": 1.0,
+  "epochs": 4,
+  "training_horizon_steps": [
+    4,
+    8,
+    12,
+    20
+  ],
+  "validation_horizon_steps": 20,
+  "precision": "float32",
+  "effective_batch": 10,
+  "microbatch": 4,
+  "workers": 3,
+  "checkpoint_every_windows": 50,
+  "launch_provenance": "Archived notebook/design command; complete original machine/runtime/argv not recorded in selected checkpoint",
+  "selected_epoch": 4,
+  "minimum_saved_validation_loss_epoch": 2,
+  "warm_start_sha256": "99ed776097e05ad6df03375465d9618741bed63a4ee57724d3ba98e295039d30",
+  "selected_checkpoint_sha256": "f194a23d3f91ea76ad776dfad942fabd669eeae8b3fd665815463095367e9ee0"
+}

training/trackformer_1_2/data/basin_all_int8.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71e5f1bb46c44e5936c506a3f8af021c1fe94c238ed030c05c66e8f342374b6d
+size 274115577

training/trackformer_1_2/data/basin_slp_atlas_float16.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f6a4ec7b2f6beadfa1075af9176d2a653e39a824d504d989e5e56e19c571521
+size 111394928

training/trackformer_1_2/data/geography.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5471471da4a1e15f85fbfb2529065806281357c8e50cb272fcd2b02e8553b96
+size 2547017

training/trackformer_1_2/data/manifest.json

@@ -0,0 +1 @@
+{"schema":"v164-reuse-pressure-v1","pilot":false,"future_weather_as_inputs":false,"official_forecasts_as_inputs":false,"files":{"track":{"path":"track_windows_v13.npz","sha256":"cb8d7291aa8140124ca522feb448a1d44124b018efc4ba1d54824b60a4f73451"},"basin":{"path":"basin_all_int8.npz","sha256":"71e5f1bb46c44e5936c506a3f8af021c1fe94c238ed030c05c66e8f342374b6d"},"slp":{"path":"basin_slp_atlas_float16.npy","sha256":"9f6a4ec7b2f6beadfa1075af9176d2a653e39a824d504d989e5e56e19c571521"},"pressure":{"path":"pressure_hpa.npy","sha256":"16cc1b153aeee5eff4b67337b599892dcd86a5716554596b8031048035d247ba"},"plan":{"path":"plan.json","sha256":"117eb291e385a326191be2f73182ed6dcbf0e9f99745780ac9e49a29def3d8da"},"geography":{"path":"geography.npz","sha256":"f5471471da4a1e15f85fbfb2529065806281357c8e50cb272fcd2b02e8553b96"}}}

training/trackformer_1_2/data/pressure_hpa.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16cc1b153aeee5eff4b67337b599892dcd86a5716554596b8031048035d247ba
+size 1698356128

training/trackformer_1_2/data/track_windows_v13.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb8d7291aa8140124ca522feb448a1d44124b018efc4ba1d54824b60a4f73451
+size 42755049

training/trackformer_1_2/download_assets.py

@@ -0,0 +1,77 @@
+"""Fetch exact public training inputs/checkpoints, verifying every SHA-256.
+
+Uses Python's standard library. Does not train, install packages, or use Drive.
+"""
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import os
+import urllib.parse
+import urllib.request
+
+
+def sha(path):
+    h = hashlib.sha256()
+    with path.open('rb') as f:
+        for block in iter(lambda: f.read(8 * 1024**2), b''):
+            h.update(block)
+    return h.hexdigest()
+
+
+def download(entry, root, base, prefix):
+    relative = Path(entry['path']).relative_to(prefix)
+    path = root / relative
+    if path.exists():
+        if path.stat().st_size == entry['bytes'] and sha(path) == entry['sha256']:
+            print('Verified existing', relative, flush=True)
+            return
+        raise ValueError('Existing file differs; preserve/move it before retrying: ' + str(path))
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temp = path.with_name(path.name + '.downloading')
+    url = base + urllib.parse.quote(entry['path'], safe='/')
+    print('Downloading', relative, entry['bytes'], 'bytes', flush=True)
+    try:
+        h = hashlib.sha256()
+        size = 0
+        with urllib.request.urlopen(url, timeout=120) as response, temp.open('wb') as out:
+            for block in iter(lambda: response.read(8 * 1024**2), b''):
+                out.write(block)
+                h.update(block)
+                size += len(block)
+            out.flush()
+            os.fsync(out.fileno())
+        if size != entry['bytes'] or h.hexdigest() != entry['sha256']:
+            raise ValueError('Downloaded content differs: ' + str(relative))
+        temp.replace(path)
+    except Exception:
+        if temp.is_file():
+            temp.unlink()
+        raise
+    print('Verified', relative, flush=True)
+
+
+def main():
+    here = Path(__file__).resolve().parent
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--destination', type=Path, default=here)
+    p.add_argument('--revision', default='main', help='Use the immutable HF revision in PUBLICATION.md for exact publication')
+    p.add_argument('--group', choices=['all', 'data', 'checkpoints'], default='all')
+    p.add_argument('--verify-only', action='store_true')
+    a = p.parse_args()
+    manifest = json.loads((here / 'assets.json').read_text())
+    base = 'https://huggingface.co/' + manifest['repository'] + '/resolve/' + urllib.parse.quote(a.revision, safe='') + '/'
+    for entry in manifest['files']:
+        if a.group != 'all' and entry['group'] != a.group:
+            continue
+        if a.verify_only:
+            path = a.destination / Path(entry['path']).relative_to('training/trackformer_1_2')
+            if not path.is_file() or path.stat().st_size != entry['bytes'] or sha(path) != entry['sha256']:
+                raise ValueError('Missing or different asset: ' + str(path))
+            print('Verified', path, flush=True)
+        else:
+            download(entry, a.destination, base, 'training/trackformer_1_2')
+
+
+if __name__ == '__main__':
+    main()

training/trackformer_1_2/requirements.txt

@@ -0,0 +1,3 @@
+numpy>=1.26
+torch>=2.1
+huggingface_hub>=0.24

training/trackformer_1_2/source/data_preparation/requirements.txt

@@ -0,0 +1,7 @@
+numpy>=1.26
+torch>=2.1
+xarray
+zarr
+gcsfs
+netCDF4
+scipy

training/trackformer_1_2/source/data_preparation/v164_dataset_contract.md

@@ -0,0 +1,41 @@
+# v1.2.64 Combined-Archive Training
+
+## Active Workflow
+
+The same `ai_train.ipynb` has two cells: version information, then fetching and preflight. It uses Google Drive only, installs no packages, and does not start training. The trainer remains `v164_global_regional_train.py` for command compatibility. Its active architecture is `wp-coarse8-native-pressure1-v164`, with 53,435,692 parameters. The old 31-channel global experiment and six-window pilot are not used.
+
+Run in the Colab terminal after setup reports READY:
+
+```sh
+cd /content/v164_colab_bundle
+python v164_global_regional_train.py 20 3 1
+```
+
+Numbers mean effective batch, workers, and CUDA AMP. Physical microbatch is one; workers are capped at two. Twelve epochs use rollout horizons 2, 4, 8, 12, then 20 steps. First two epochs train fields; later epochs add route and intensity objectives. Best selection starts at epoch five with the stable full-horizon objective. Validation is never training data; test is excluded from selection.
+
+## Data Coverage
+
+- Old archives supply 13,949 train, 1,041 validation, and 1,195 test windows with complete six-hour context/target weather coverage inside the Western Pacific domain.
+- Train years 2000-2021; validation 2022-2023; test 2024-2025. Whole storms and window boundaries cannot cross splits. Tip 1979 is excluded from all three.
+- Eight 2.5-degree context variables: mean sea-level pressure, 500-hPa height, and u/v winds at 850/500/200 hPa. Domain: 0-60 N, 100-180 E. These are old NCEP reanalysis fields, not high-resolution ERA5.
+- New native 0.25-degree ERA5 pressure patches provide 800/100/100 detailed windows within those splits. Each patch is 121x121 over 30 degrees, fixed at its observed issue-time center, with nine history and twenty target frames. These 1,000 windows are additional fine supervision, NOT the entire old corpus.
+- Static geographic channels: latitude, longitude, land fraction and elevation. Fine pressure is never synthesized by enlarging the old coarse map.
+- SST, ONI and fine upper-air variables are not consumed by this configuration; they are not silently substituted or claimed present.
+
+## Causality And Outputs
+
+Inputs are analyses at -48,-42,...,0 hours, static geography, observed issue-time center/intensity and past six-hour motion. Future analysis fields and best-track positions/intensities are labels only. Issue-time retrospective best-track estimates are a historical hindcast assumption, not proof of real-time operational availability. Normalization uses only the training years. No official forecasts or future weather are model inputs.
+
+The model autoregressively predicts eight basin fields and a native pressure patch when native history is available. No future recentering or route-painted vortex is used. Its track head uses generated basin pressure/winds/features. Fine data outside the parent domain receives an explicit missing-coverage mask, not extrapolated fields. Central pressure is a sampled generated field plus a separately learned subgrid correction; maximum wind is a scalar head, not a predicted 10m-wind map. No exact physical conservation is claimed.
+
+The archive-wide training processes every eligible coarse window. Only the detailed subset trains the fine branch. A case lacking native pressure history can run the coarse branch but is not represented as a genuine high-resolution pressure forecast.
+
+## Storage And Resume
+
+Drive folder: `typhoon_predict/data/v164_reuse` contains the manifest and bundle descriptor referencing existing archived data plus `data/v164_pressure_geography` parts. No large archives are duplicated in Drive. Total payload about 2.13 GB. Four independent Drive HTTP clients fetch parts concurrently. Existing verified files are reused; the manifest is published after complete-file checksums pass.
+
+Checkpoints are written directly to `MyDrive/typhoon_predict/training/v164_reuse_pressure/last.pt` and `best.pt`, with history and run manifest. Resume restores the last completed epoch, optimizer, scaler, and RNG; an interrupted epoch restarts. Architecture and dataset hashes must match. A stale lock after runtime death requires checking that no other training process is active before removing it. Pilot checkpoints are incompatible and are not auto-loaded.
+
+## Verification Limits
+
+Mac checks cover all archive hashes and split counts, real coarse and fine samples, tiny-model +120h finite rollouts, backward gradients, completed-epoch checkpoint resume, and full-width two-step MPS gradients. These are software checks, not model-skill validation. CUDA/T4 execution and a complete training run have not been tested; Colab was not accessed.

training/trackformer_1_2/source/data_preparation/v164_download_pressure_geography.py

@@ -0,0 +1,174 @@
+"""Mac-only, resumable MSLP patches and geography. Not a full trainer dataset."""
+import argparse
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor
+import hashlib
+import json
+import os
+from pathlib import Path
+import sqlite3
+import time
+
+import numpy as np
+import v164_prepare_data as prep
+
+
+def make_plan(track):
+    if prep.trainer.digest(track) != prep.TRACK_SHA:
+        raise ValueError('Unexpected track archive')
+    rng = np.random.default_rng(164)
+    with np.load(track, allow_pickle=False) as z:
+        times, ids = z['base_time'], z['storm_id'].astype(str)
+        lat, lon = z['base_lat'], z['base_lon'] % 360
+    first = {}
+    for sid, ns in zip(ids, times):
+        first[sid] = min(first.get(sid, 9999), prep.year(ns))
+    rows = []
+    for split, lo, hi, count in [('train', 2000, 2021, 800), ('validation', 2022, 2023, 100), ('test', 2024, 2025, 100)]:
+        groups = defaultdict(list)
+        for i, (sid, ns) in enumerate(zip(ids, times)):
+            ns = int(ns)
+            if not (lo <= first[sid] <= hi and lo <= prep.year(ns-8*prep.STEP)
+                    and prep.year(ns+20*prep.STEP) <= hi and ns % prep.STEP == 0
+                    and np.isfinite(lat[i]) and np.isfinite(lon[i])
+                    and 0 < lat[i] < 60 and 100 < lon[i] < 180):
+                continue
+            groups[sid].append(i)
+        for group in groups.values():
+            rng.shuffle(group)
+        storms = sorted(groups)
+        rng.shuffle(storms)
+        chosen = []
+        while len(chosen) < count:
+            before = len(chosen)
+            for sid in storms:
+                if groups[sid]:
+                    chosen.append(groups[sid].pop())
+                    if len(chosen) == count:
+                        break
+            if len(chosen) == before:
+                raise ValueError(f'Insufficient eligible {split} windows')
+        for i in chosen:
+            rows.append({'storm_id': str(ids[i]), 'issue_ns': int(times[i]), 'split': split,
+                         'center_lat': float(np.round(lat[i]*4)/4), 'center_lon': float(np.round(lon[i]*4)/4),
+                         'center_source': 'retrospective issue-time best-track observation; no future positions',
+                         'track_archive_row': int(i)})
+    plan = {'schema': 'v164-pressure-geography-v1', 'dataset_role': 'partial_inputs_not_training_ready',
+            'source': prep.SOURCE, 'track_sha256': prep.TRACK_SHA, 'rows': rows,
+            'lead_hours': list(range(-48, 121, 6)), 'shape': [len(rows), 29, 121, 121],
+            'units': 'hPa', 'resolution_degrees': .25, 'fixed_issue_time_crops': True,
+            'forecast_inputs': 'lead_hours <= 0 only', 'targets': 'lead_hours > 0 only',
+            'split_policy': 'existing 2000-2021/2022-2023/2024-2025 policy, pending separately requested changes',
+            'hindcast_not_operational_availability_claim': True}
+    plan['sha256'] = hashlib.sha256(json.dumps(plan, sort_keys=True).encode()).hexdigest()
+    return plan
+
+
+def patch_indices(row):
+    lat = row['center_lat'] + 15 - np.arange(121)*.25
+    lon = row['center_lon'] - 15 + np.arange(121)*.25
+    return np.rint((90-lat)*4).astype(int), np.rint(lon*4).astype(int) % 1440
+
+
+def patch_hash(a):
+    return hashlib.sha256(np.ascontiguousarray(a).tobytes()).hexdigest()
+
+
+def run(root, track, workers, max_frames=None):
+    root.mkdir(parents=True, exist_ok=True)
+    fd = os.open(root/'download.lock', os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+    os.write(fd, str(os.getpid()).encode())
+    os.close(fd)
+    db = None
+    try:
+        plan = make_plan(track)
+        path = root/'plan.json'
+        if path.exists() and json.loads(path.read_text()) != plan:
+            raise ValueError('Existing download plan differs; refusing overwrite')
+        prep.trainer.atomic_json(path, plan)
+        shape = tuple(plan['shape'])
+        output = root/'pressure_hpa.npy'
+        a = np.lib.format.open_memmap(output, mode='r+' if output.exists() else 'w+', dtype='float32', shape=shape)
+        if a.shape != shape or a.dtype != np.float32:
+            raise ValueError('Existing array shape/dtype differs')
+        indices = [patch_indices(r) for r in plan['rows']]
+        requests = defaultdict(list)
+        for i, row in enumerate(plan['rows']):
+            for j in range(29):
+                requests[row['issue_ns'] + (j-8)*prep.STEP].append((i, j))
+        db = sqlite3.connect(root/'progress.sqlite')
+        db.execute('CREATE TABLE IF NOT EXISTS patches (i INTEGER, j INTEGER, sha TEXT, PRIMARY KEY(i,j))')
+        verified = set()
+        for i, j, sha in db.execute('SELECT i,j,sha FROM patches'):
+            if patch_hash(a[i,j]) == sha:
+                verified.add((i,j))
+        pending = [(ns, slots) for ns, slots in sorted(requests.items()) if any(s not in verified for s in slots)]
+        print(json.dumps({'windows': len(plan['rows']), 'pressure_gib': a.nbytes/1024**3,
+                          'unique_times': len(requests), 'remaining_times': len(pending),
+                          'reused_verified_patches': len(verified), 'workers': workers}), flush=True)
+        source = prep.Era5Source()
+        geography = root/'geography.npz'
+        if not geography.exists():
+            ns = plan['rows'][0]['issue_ns']
+            land = source.read('land_sea_mask', ns)
+            height = source.read('geopotential_at_surface', ns)/9.80665
+            if not np.isfinite(land).all() or not np.isfinite(height).all():
+                raise ValueError('Invalid geography')
+            with (root/'geography.pending').open('wb') as f:
+                np.savez_compressed(f, latitude=source.lat, longitude=source.lon,
+                                    land_fraction=land, elevation_m=height)
+            (root/'geography.pending').replace(geography)
+        with np.load(geography, allow_pickle=False) as z:
+            if z['land_fraction'].shape != (721,1440) or z['elevation_m'].shape != (721,1440):
+                raise ValueError('Geography grid mismatch')
+        prep.trainer.atomic_json(root/'geography_manifest.json', {'sha256': prep.trainer.digest(geography),
+            'source': prep.SOURCE, 'size': geography.stat().st_size, 'units': {'elevation_m': 'm', 'land_fraction': '1'}})
+        def fetch(item):
+            ns, slots = item
+            pressure = source.read('mean_sea_level_pressure', ns)/100
+            if not np.isfinite(pressure).all() or pressure.min() < 800 or pressure.max() > 1120:
+                raise ValueError(f'Invalid MSLP at {ns}')
+            return ns, [(i,j,pressure[indices[i][0][:,None],indices[i][1][None,:]]) for i,j in slots if (i,j) not in verified]
+        started = time.monotonic()
+        initial = len(requests)-len(pending)
+        selected = pending if max_frames is None else pending[:max_frames]
+        # Process bounded groups: completed patches are committed before requesting more.
+        done = 0
+        with ThreadPoolExecutor(max_workers=workers) as pool:
+            for offset in range(0, len(selected), workers):
+                for ns, patches in pool.map(fetch, selected[offset:offset+workers]):
+                    for i,j,values in patches:
+                        a[i,j] = values
+                    a.flush()
+                    for i,j,_ in patches:
+                        db.execute('INSERT OR REPLACE INTO patches VALUES (?,?,?)', (i,j,patch_hash(a[i,j])))
+                        verified.add((i,j))
+                    db.commit()
+                    done += 1
+                    elapsed = time.monotonic()-started
+                    status = {'completed_times': initial+done, 'total_times': len(requests),
+                              'verified_patches': len(verified), 'total_patches': shape[0]*shape[1],
+                              'elapsed_s_this_run': round(elapsed,1),
+                              'eta_s': round((len(pending)-done)*elapsed/done),
+                              'last_time': str(np.datetime64(ns,'ns')), 'status': 'downloading'}
+                    prep.trainer.atomic_json(root/'progress.json', status)
+                    print(json.dumps(status), flush=True)
+        if len(verified) == shape[0]*shape[1]:
+            prep.trainer.atomic_json(root/'completion.json', {'status': 'pressure_and_geography_complete',
+                'training_ready': False, 'plan_sha256': plan['sha256'],
+                'pressure_sha256': prep.trainer.digest(output), 'geography_sha256': prep.trainer.digest(geography)})
+            print('Pressure and geography verified complete. Other training inputs still required.', flush=True)
+    finally:
+        if db is not None:
+            db.close()
+        (root/'download.lock').unlink(missing_ok=True)
+
+
+if __name__ == '__main__':
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--output', type=Path, default=Path('/Volumes/D/typhoon_predict/data/v164_pressure_geography'))
+    p.add_argument('--track', type=Path, default=Path('/Volumes/D/typhoon_predict/track_build/track_windows_v13.npz'))
+    p.add_argument('--workers', type=int, choices=range(1,9), default=4)
+    p.add_argument('--max-frames', type=int)
+    args = p.parse_args()
+    run(args.output, args.track, args.workers, args.max_frames)

training/trackformer_1_2/source/data_preparation/v164_global_regional_train.py

@@ -0,0 +1,845 @@
+#!/usr/bin/env python3
+"""v1.2.64 Western Pacific coarse-context/native-pressure forecaster.
+
+Run: python v164_global_regional_train.py 10 3 1
+Uses verified old coarse archives plus new native 0.25-degree pressure patches.
+Predicts eight coarse fields and one fine pressure field, not 31 fine variables.
+The legacy 31-channel definitions below are not the active CLI architecture.
+No route-centered vortex is painted. This is not a numerical conservation solver.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import random
+import socket
+import time
+from contextlib import nullcontext
+
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import functional as F
+from torch.utils.checkpoint import checkpoint
+from torch.utils.data import Dataset, DataLoader
+
+VERSION = "1.2.64"
+ARCHITECTURE = "global-regional-field-first-v1"
+ROOT = Path(__file__).resolve().parent
+LEVELS = [850, 700, 500, 300, 200]
+CHANNELS = ["mslp", "surface_pressure", "u10", "v10", "t2m", "sst"] + [
+    f"{v}{p}" for p in LEVELS for v in ("u", "v", "temperature", "humidity", "geopotential")]
+UNITS = ["hPa", "hPa", "m/s", "m/s", "K", "K"] + [
+    unit for _ in LEVELS for unit in ("m/s", "m/s", "K", "kg/kg", "m2/s2")]
+HISTORY = 9
+LEADS = 20
+HOUR = 3_600_000_000_000
+
+
+def digest(path):
+    h = hashlib.sha256()
+    with Path(path).open("rb") as f:
+        for block in iter(lambda: f.read(8 * 1024**2), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def atomic_json(path, data):
+    path = Path(path)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(json.dumps(data, indent=2, allow_nan=False) + "\n")
+    tmp.replace(path)
+
+
+def atomic_checkpoint(path, data):
+    path = Path(path)
+    tmp = path.with_suffix(".tmp")
+    with tmp.open("wb") as f:
+        torch.save(data, f)
+        f.flush()
+        os.fsync(f.fileno())
+    tmp.replace(path)
+
+
+def device_for(name):
+    if name == "auto":
+        name = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
+    if name == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("CUDA unavailable in this Python. Install a CUDA PyTorch wheel before training.")
+    if name == "mps" and not torch.backends.mps.is_available():
+        raise RuntimeError("MPS requested but unavailable")
+    return torch.device(name)
+
+
+class Block(nn.Module):
+    def __init__(self, width, periodic=False):
+        super().__init__()
+        self.periodic = periodic
+        self.depthwise = nn.Conv2d(width, width, 5, groups=width)
+        self.net = nn.Sequential(nn.GroupNorm(8, width), nn.Conv2d(width, width * 4, 1),
+                                 nn.GELU(), nn.Conv2d(width * 4, width, 1))
+        self.scale = nn.Parameter(torch.full((1, width, 1, 1), 0.01))
+
+    def forward(self, x):
+        padded = F.pad(x, (2, 2, 0, 0), mode="circular" if self.periodic else "replicate")
+        padded = F.pad(padded, (0, 0, 2, 2), mode="replicate")
+        return x + self.scale * self.net(self.depthwise(padded))
+
+
+class FieldOperator(nn.Module):
+    def __init__(self, channels, base, periodic, attention_layers=0, tiny=False):
+        super().__init__()
+        widths = [base, base * 2, base * 4, base * 6]
+        self.stem = nn.Conv2d(channels * 3 + 4, base, 3, padding=1)
+        depths = [1, 1, 1, 1] if tiny else [2, 3, 5, 6]
+        self.enc = nn.ModuleList([nn.Sequential(*[Block(w, periodic) for _ in range(n)]) for w, n in zip(widths, depths)])
+        self.down = nn.ModuleList([nn.Conv2d(a, b, 3, stride=2, padding=1) for a, b in zip(widths, widths[1:])])
+        self.attention = nn.ModuleList([nn.TransformerEncoderLayer(widths[-1], 8,
+                                      dim_feedforward=widths[-1] * 4, batch_first=True,
+                                      dropout=0.0, norm_first=True) for _ in range(attention_layers)])
+        self.up = nn.ModuleList([nn.Conv2d(widths[i + 1], widths[i], 1) for i in (2, 1, 0)])
+        self.dec = nn.ModuleList([nn.Sequential(Block(widths[i], periodic), Block(widths[i], periodic)) for i in (2, 1, 0)])
+        self.out = nn.Conv2d(base, channels, 1)
+        self.object_features = nn.Conv2d(base, 32, 1)
+        self.checkpointing = True
+        nn.init.normal_(self.out.weight, std=1e-3)
+        nn.init.zeros_(self.out.bias)
+
+    def run(self, module, value):
+        return checkpoint(module, value, use_reentrant=False) if self.training and self.checkpointing else module(value)
+
+    def forward(self, state, context, mask, static):
+        x = self.stem(torch.cat([state, context, mask, static], 1))
+        skips = []
+        for i in range(4):
+            x = self.run(self.enc[i], x)
+            skips.append(x)
+            if i < 3:
+                x = self.down[i](x)
+        if self.attention:
+            shape = x.shape
+            tokens = x.flatten(2).transpose(1, 2)
+            for layer in self.attention:
+                tokens = self.run(layer, tokens)
+            x = tokens.transpose(1, 2).reshape(shape)
+        for up, dec, skip in zip(self.up, self.dec, reversed(skips[:-1])):
+            x = self.run(dec, F.interpolate(up(x), size=skip.shape[-2:], mode="bilinear", align_corners=False) + skip)
+        # A learned field tendency, with no fixed per-cell hPa cap or route warp.
+        return state + self.out(x), self.object_features(x)
+
+
+class GlobalRegionalForecaster(nn.Module):
+    def __init__(self, global_lat, global_lon, regional_lat, regional_lon, mean, std, tiny=False):
+        super().__init__()
+        c = len(CHANNELS)
+        self.register_buffer("mean", torch.tensor(mean, dtype=torch.float32).view(1, c, 1, 1))
+        self.register_buffer("std", torch.tensor(std, dtype=torch.float32).view(1, c, 1, 1))
+        self.register_buffer("regional_lat", torch.tensor(regional_lat, dtype=torch.float32))
+        self.register_buffer("regional_lon", torch.tensor(regional_lon, dtype=torch.float32))
+        self.global_time = nn.Conv2d(c * HISTORY, c, 1)
+        self.regional_time = nn.Conv2d(c * HISTORY, c, 1)
+        self.global_operator = FieldOperator(c, 8 if tiny else 80, True, 1 if tiny else 3, tiny)
+        self.regional_operator = FieldOperator(c, 8 if tiny else 88, False, 0, tiny)
+        self.parent_fusion = nn.Conv2d(c * 2, c, 1)
+        self.object_score = nn.Conv2d(32 + 3, 1, 1)
+        self.intensity = nn.Sequential(nn.Linear(32 + 3, 64), nn.GELU(), nn.Linear(64, 2))
+        y, x = np.meshgrid(regional_lat, regional_lon, indexing="ij")
+        grid = np.stack([2 * (x - global_lon[0]) / (global_lon[-1] - global_lon[0]) - 1,
+                         2 * (y - global_lat[0]) / (global_lat[-1] - global_lat[0]) - 1], -1)
+        self.register_buffer("parent_grid", torch.tensor(grid, dtype=torch.float32)[None])
+        self.register_buffer("yy", torch.tensor(y, dtype=torch.float32)[None])
+        self.register_buffer("xx", torch.tensor(x, dtype=torch.float32)[None])
+
+    def initial(self, inputs):
+        expected = {"global_history", "regional_history", "global_mask", "regional_mask",
+                    "global_static", "regional_static", "center", "motion"}
+        if set(inputs) != expected:
+            raise ValueError("Forward inputs must contain only the declared causal input keys")
+        gh, rh = inputs["global_history"], inputs["regional_history"]
+        return {"g": gh[:, -1], "r": rh[:, -1],
+                "gc": self.global_time(gh.flatten(1, 2)), "rc": self.regional_time(rh.flatten(1, 2)),
+                "gm": inputs["global_mask"], "rm": inputs["regional_mask"],
+                "gs": inputs["global_static"], "rs": inputs["regional_static"],
+                "center": inputs["center"], "motion": inputs["motion"]}
+
+    def step(self, state):
+        g, _ = self.global_operator(state["g"], state["gc"], state["gm"], state["gs"])
+        parent = F.grid_sample(g, self.parent_grid.expand(len(g), -1, -1, -1), align_corners=True)
+        context = self.parent_fusion(torch.cat([state["rc"], parent], 1))
+        r, features = self.regional_operator(state["r"], context, state["rm"], state["rs"])
+        physical = r.float() * self.std + self.mean
+        pressure = physical[:, 0]
+        anomaly = pressure - F.avg_pool2d(F.pad(pressure[:, None], (4, 4, 4, 4), mode="replicate"), 9, stride=1)[:, 0]
+        idx_u, idx_v = CHANNELS.index("u850"), CHANNELS.index("v850")
+        u, v = physical[:, idx_u], physical[:, idx_v]
+        evidence = torch.cat([features.float(), anomaly[:, None] / 10, u[:, None] / 30, v[:, None] / 30], 1)
+        score = self.object_score(evidence)[:, 0] - anomaly / 10
+        lat0, lon0 = state["center"][:, 0, None, None], state["center"][:, 1, None, None]
+        prior_lat = lat0 + state["motion"][:, 1, None, None] / 111.2
+        prior_lon = lon0 + state["motion"][:, 0, None, None] / (111.2 * lat0.deg2rad().cos().clamp_min(.2))
+        distance2 = ((self.yy - prior_lat) * 111.2).square() + ((self.xx - prior_lon) * 111.2 * lat0.deg2rad().cos()).square()
+        score = score - distance2 / (2 * 600**2)
+        # Select one spatial mode, then refine locally; never average distinct lows.
+        peak = score.flatten(1).argmax(1)
+        h, w = pressure.shape[-2:]
+        iy = torch.arange(h, device=r.device)[None, :, None]
+        ix = torch.arange(w, device=r.device)[None, None, :]
+        local = ((iy - (peak // w)[:, None, None]).abs() <= 2) & ((ix - (peak % w)[:, None, None]).abs() <= 2)
+        pdf = torch.softmax(score.masked_fill(~local, -1e9).flatten(1), 1).reshape_as(score)
+        center = torch.stack([(pdf * self.yy).sum((1, 2)), (pdf * self.xx).sum((1, 2))], 1)
+        pooled = (evidence * pdf[:, None]).sum((2, 3))
+        intensity = self.intensity(pooled)
+        grid_pressure = (pressure * pdf).sum((1, 2))
+        central_pressure = grid_pressure - F.softplus(intensity[:, 0]) * 5
+        surface_speed = torch.sqrt(physical[:, 2].square() + physical[:, 3].square() + 1e-6)
+        vmax = (surface_speed * pdf).sum((1, 2)) * 1.943844 + F.softplus(intensity[:, 1]) * 5
+        mean_lat = (center[:, 0] + state["center"][:, 0]) / 2
+        motion = torch.stack([(center[:, 1] - state["center"][:, 1]) * 111.2 * mean_lat.deg2rad().cos(),
+                              (center[:, 0] - state["center"][:, 0]) * 111.2], 1)
+        next_state = dict(state, g=g, r=r, center=center, motion=motion)
+        return next_state, {"global": g, "regional": r, "center": center, "pressure": central_pressure,
+                            "vmax": vmax, "grid_pressure": grid_pressure, "association": pdf}
+
+    def forward(self, inputs, steps=20):
+        if not 1 <= steps <= LEADS:
+            raise ValueError("steps must be 1..20")
+        state = self.initial(inputs)
+        outputs = []
+        for _ in range(steps):
+            state, out = self.step(state)
+            outputs.append(out)
+        return {k: torch.stack([o[k] for o in outputs], 1) for k in outputs[0]}
+
+
+def require_full_dataset(m, times=None, rows=None):
+    if m.get('dataset_role') != 'full_training' or m.get('synthetic', False):
+        raise ValueError('FULL DATA REQUIRED: pilot, synthetic or unclassified datasets cannot be used by the training CLI. Prepare the full 2000-2025 dataset on the Mac first.')
+    if times is not None:
+        expected = np.arange(np.datetime64('2000-01-01', 'ns').astype('int64'),
+                             np.datetime64('2026-01-01', 'ns').astype('int64'), 6*HOUR, dtype='int64')
+        if not np.array_equal(times, expected):
+            raise ValueError('Full dataset must contain every six-hour field from 2000 through 2025; partial coverage is not full training')
+    if rows is not None:
+        for split, years in [('train', range(2000, 2022)), ('validation', range(2022, 2024)), ('test', range(2024, 2026))]:
+            covered = {int(np.datetime64(int(times[r['issue_index']]), 'ns').astype('datetime64[Y]').astype(int))+1970
+                       for r in rows if r['split'] == split}
+            if covered != set(years):
+                raise ValueError(f'Full dataset lacks sample coverage in {split}: {sorted(set(years)-covered)}')
+
+
+def load_manifest(path, verify=True, smoke=False, require_full=False):
+    path = Path(path)
+    if not path.is_file():
+        raise FileNotFoundError(f"V164 DATA NOT READY: {path}. Requires native global <=1-degree and regional <=0.25-degree multilevel fields. The v163 2.5-degree archive cannot substitute. See v164_dataset_contract.md.")
+    m = json.loads(path.read_text())
+    if require_full:
+        require_full_dataset(m)
+    if m.get("schema") != "v164-atmosphere-v1" or m.get("channels") != CHANNELS or m.get("units") != UNITS:
+        raise ValueError("Dataset schema/channel order/physical units do not match v164")
+    if m.get("future_weather_as_inputs") is not False or m.get("official_forecasts_as_inputs") is not False:
+        raise ValueError("Dataset must explicitly disable future weather and official forecast inputs")
+    if not smoke and m.get("synthetic", False):
+        raise ValueError("Synthetic data is only permitted by the smoke-test API")
+    for key in ("global", "regional", "global_static", "regional_static", "time", "samples"):
+        item = m["files"][key]
+        p = (path.parent / item["path"]).resolve()
+        if not p.is_relative_to(path.parent.resolve()) or not p.is_file():
+            raise ValueError(f"Missing or outside-dataset file: {key}")
+        if verify and digest(p) != item["sha256"]:
+            raise ValueError(f"Dataset checksum mismatch: {key}")
+        item["resolved"] = str(p)
+    times = np.load(m["files"]["time"]["resolved"], mmap_mode="r")
+    if times.dtype != np.dtype("int64") or np.any(np.diff(times) <= 0) or np.any(times % (6 * HOUR)):
+        raise ValueError("Time must be increasing int64 UTC nanoseconds aligned to six hours")
+    if m["normalization"]["fit_split"] != "train" or m["normalization"]["end_year"] > 2021:
+        raise ValueError("Normalization must be fitted exclusively to training years <=2021")
+    mean, std = np.array(m["normalization"]["mean"]), np.array(m["normalization"]["std"])
+    if mean.shape != (len(CHANNELS),) or std.shape != mean.shape or not np.isfinite(mean).all() or not np.isfinite(std).all() or (std <= 0).any():
+        raise ValueError("Invalid training normalization")
+    for region, max_step in (("global", 1), ("regional", .25)):
+        lat, lon = np.array(m[region + "_lat"]), np.array(m[region + "_lon"])
+        if min(len(lat), len(lon)) < 2 or np.any(np.diff(lat) >= 0) or np.any(np.diff(lon) <= 0):
+            raise ValueError("Coordinates must be north-to-south, west-to-east")
+        if not np.allclose(np.diff(lat), lat[1]-lat[0], atol=1e-5) or not np.allclose(np.diff(lon), lon[1]-lon[0], atol=1e-5):
+            raise ValueError("This operator requires regular latitude/longitude grids")
+        if not smoke and (np.max(-np.diff(lat)) > max_step + 1e-5 or np.max(np.diff(lon)) > max_step + 1e-5):
+            raise ValueError(f"{region} resolution too coarse")
+        if region == "global" and not smoke and (lat[0] < 89 or lat[-1] > -89 or lon[0] != 0 or lon[-1] < 359):
+            raise ValueError("Global parent must cover the globe without duplicated longitude seam")
+        array = np.load(m["files"][region]["resolved"], mmap_mode="r")
+        static = np.load(m["files"][region + "_static"]["resolved"], mmap_mode="r")
+        if array.shape != (len(times), len(CHANNELS), len(lat), len(lon)) or static.shape != (4, len(lat), len(lon)):
+            raise ValueError(f"{region} field/static shape mismatch")
+        if not np.isfinite(static).all():
+            raise ValueError("Non-finite static geography")
+    if not (min(m["global_lat"]) <= min(m["regional_lat"]) <= max(m["regional_lat"]) <= max(m["global_lat"]) and
+            min(m["global_lon"]) <= min(m["regional_lon"]) <= max(m["regional_lon"]) <= max(m["global_lon"])):
+        raise ValueError("Regional grid lies outside global parent coverage")
+    rows = [json.loads(line) for line in Path(m["files"]["samples"]["resolved"]).read_text().splitlines() if line.strip()]
+    membership = {}
+    for row in rows:
+        i = row["issue_index"]
+        if i < HISTORY - 1 or i + LEADS >= len(times):
+            raise ValueError("Sample lacks full causal history or target coverage")
+        if np.any(np.diff(times[i-8:i+21]) != 6 * HOUR):
+            raise ValueError("Sample crosses a gap in causal history or future target coverage")
+        year = int(np.datetime64(int(times[i]), "ns").astype("datetime64[Y]").astype(int)) + 1970
+        valid_years = {"train": (2000, 2021), "validation": (2022, 2023), "test": (2024, 2025)}
+        low, high = valid_years[row["split"]]
+        first_year = int(np.datetime64(int(times[i-8]), "ns").astype("datetime64[Y]").astype(int)) + 1970
+        last_year = int(np.datetime64(int(times[i+20]), "ns").astype("datetime64[Y]").astype(int)) + 1970
+        if not smoke and not (low <= first_year <= year <= last_year <= high):
+            raise ValueError("Sample violates fixed chronological split")
+        storm = row.get("storm_id")
+        if storm:
+            if "1979" in storm or storm.upper() == "TIP":
+                raise ValueError("Tip is excluded from training, validation and test")
+            if storm in membership and membership[storm] != row["split"]:
+                raise ValueError("Storm crosses dataset splits")
+            membership[storm] = row["split"]
+            if "center" not in row or "target_centers" not in row:
+                raise ValueError("Storm samples require observed center and masked target centers")
+            centers = np.asarray(row["target_centers"])
+            route_mask = np.asarray(row.get("route_mask", [1] * LEADS))
+            if centers.shape != (LEADS, 2) or route_mask.shape != (LEADS,) or not np.isfinite(centers).all():
+                raise ValueError("Invalid storm target coordinates/mask")
+        for field in ("target_pressure_hpa", "target_vmax_kt", "pressure_mask", "vmax_mask"):
+            values = np.asarray(row.get(field, [0] * LEADS))
+            if values.shape != (LEADS,) or not np.isfinite(values).all():
+                raise ValueError(f"Invalid target field: {field}")
+        for field in ("route_mask", "pressure_mask", "vmax_mask"):
+            values = np.asarray(row.get(field, [0] * LEADS))
+            if not np.isin(values, [0, 1]).all():
+                raise ValueError("Target masks must be binary")
+        center = np.asarray(row.get("center", [20, 140]))
+        motion = np.asarray(row.get("motion_km_per_6h", [0, 0]))
+        if center.shape != (2,) or motion.shape != (2,) or not np.isfinite([center, motion]).all():
+            raise ValueError("Invalid causal center or motion")
+        if not (min(m["regional_lat"]) <= center[0] <= max(m["regional_lat"]) and min(m["regional_lon"]) <= center[1] <= max(m["regional_lon"])):
+            raise ValueError("Issue center outside regional domain")
+    if not smoke and not any(not r.get("storm_id") for r in rows if r["split"] == "train"):
+        raise ValueError("Field pretraining requires non-storm atmospheric samples")
+    if require_full:
+        require_full_dataset(m, times, rows)
+    m["rows"] = rows
+    m["identity"] = digest(path)
+    return m
+
+
+class AtmosphereDataset(Dataset):
+    def __init__(self, manifest, split, training=False):
+        self.m, self.training = manifest, training
+        self.rows = [r for r in manifest["rows"] if r["split"] == split]
+        self.arrays = None
+
+    def __len__(self):
+        return len(self.rows)
+
+    def __getitem__(self, index):
+        if self.arrays is None:
+            self.arrays = {k: np.load(self.m["files"][k]["resolved"], mmap_mode="r") for k in ("global", "regional", "global_static", "regional_static")}
+        row = self.rows[index]
+        i = row["issue_index"]
+        mean = np.array(self.m["normalization"]["mean"], dtype="float32")[:, None, None]
+        std = np.array(self.m["normalization"]["std"], dtype="float32")[:, None, None]
+        inputs, targets = {}, {}
+        drop_sst = self.training and np.random.random() < .15
+        for name in ("global", "regional"):
+            history = np.array(self.arrays[name][i - 8:i + 1], dtype="float32")
+            available = np.isfinite(history)
+            # SST can be masked; all atmospheric predictor channels are required.
+            if not available[:, [k for k in range(len(CHANNELS)) if k != 5]].all():
+                raise ValueError(f"Missing required atmospheric inputs at sample {i}")
+            if drop_sst:
+                available[:, 5] = False
+            history = np.where(available, (history - mean) / std, 0)
+            inputs[name + "_history"] = torch.from_numpy(history)
+            inputs[name + "_mask"] = torch.from_numpy(available.all(0).astype("float32"))
+            inputs[name + "_static"] = torch.from_numpy(np.array(self.arrays[name + "_static"], dtype="float32"))
+            future = np.array(self.arrays[name][i + 1:i + 21], dtype="float32")
+            mask = np.isfinite(future)
+            if not mask[:, [k for k in range(len(CHANNELS)) if k != 5]].all():
+                raise ValueError(f"Missing required atmospheric verification fields at sample {i}")
+            targets[name] = torch.from_numpy(np.where(mask, (future - mean) / std, 0))
+            targets[name + "_mask"] = torch.from_numpy(mask.astype("float32"))
+        inputs["center"] = torch.tensor(row.get("center", [20, 140]), dtype=torch.float32)
+        inputs["motion"] = torch.tensor(row.get("motion_km_per_6h", [0, 0]), dtype=torch.float32)
+        storm = bool(row.get("storm_id"))
+        targets["center"] = torch.tensor(row.get("target_centers", [[0, 0]] * 20), dtype=torch.float32)
+        targets["pressure"] = torch.tensor(row.get("target_pressure_hpa", [0] * 20), dtype=torch.float32)
+        targets["vmax"] = torch.tensor(row.get("target_vmax_kt", [0] * 20), dtype=torch.float32)
+        targets["storm_mask"] = torch.tensor(row.get("route_mask", [float(storm)] * 20), dtype=torch.float32)
+        targets["pressure_mask"] = torch.tensor(row.get("pressure_mask", [0] * 20), dtype=torch.float32)
+        targets["vmax_mask"] = torch.tensor(row.get("vmax_mask", [0] * 20), dtype=torch.float32)
+        return inputs, targets
+
+
+def masked_mean(value, mask):
+    return (value * mask).sum() / mask.expand_as(value).sum().clamp_min(1)
+
+
+def objective(output, target, step, manifest, joint):
+    terms = {}
+    for region in ("global", "regional"):
+        p, t = output[region].float(), target[region][:, step]
+        mask = target[region + "_mask"][:, step]
+        lat = torch.tensor(manifest[region + "_lat"], device=p.device, dtype=torch.float32).deg2rad().cos()[None, None, :, None]
+        if region == "regional" and "regional_lat_weight" in target:
+            lat = target["regional_lat_weight"][:, step]
+        terms[region] = masked_mean(F.smooth_l1_loss(p, t, reduction="none"), mask * lat)
+        dx = (p[..., 1:] - p[..., :-1]) - (t[..., 1:] - t[..., :-1])
+        dy = (p[..., 1:, :] - p[..., :-1, :]) - (t[..., 1:, :] - t[..., :-1, :])
+        terms[region + "_gradient"] = .5 * (masked_mean(dx.abs(), mask[..., 1:] * mask[..., :-1]) + masked_mean(dy.abs(), mask[..., 1:, :] * mask[..., :-1, :]))
+    delta = output["center"] - target["center"][:, step]
+    scale = torch.stack([torch.ones_like(delta[:, 0]), target["center"][:, step, 0].deg2rad().cos()], 1) * 111.2 / 100
+    terms["route"] = masked_mean(F.smooth_l1_loss(delta * scale, torch.zeros_like(delta), reduction="none"), target["storm_mask"][:, step, None])
+    terms["pressure"] = masked_mean((output["pressure"] - target["pressure"][:, step]).abs() / 20, target["pressure_mask"][:, step])
+    terms["vmax"] = masked_mean((output["vmax"] - target["vmax"][:, step]).abs() / 30, target["vmax_mask"][:, step])
+    value = terms["global"] + terms["regional"] + .2 * (terms["global_gradient"] + terms["regional_gradient"])
+    if joint:
+        value = value + .2 * terms["route"] + .1 * (terms["pressure"] + terms["vmax"])
+    return value, terms
+
+
+def make_model(m, tiny=False):
+    return GlobalRegionalForecaster(*(m[k] for k in ("global_lat", "global_lon", "regional_lat", "regional_lon")),
+                                    m["normalization"]["mean"], m["normalization"]["std"], tiny)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("batch", type=int, nargs="?", default=10, help="Effective examples per optimizer update; physical microbatch is 1")
+    parser.add_argument("workers", type=int, nargs="?", default=3)
+    parser.add_argument("amp", type=int, nargs="?", default=1, choices=[0, 1])
+    persistent = Path("/content/drive/MyDrive/typhoon_predict") if Path("/content").is_dir() else ROOT
+    default_manifest = persistent / "data/v164/manifest.json"
+    parser.add_argument("--manifest", type=Path, default=Path(os.getenv("V164_MANIFEST", default_manifest)))
+    parser.add_argument("--output", type=Path, default=os.getenv("V164_OUTPUT_DIR"))
+    parser.add_argument("--epochs", type=int, default=12)
+    parser.add_argument("--device", default="auto", choices=["auto", "cuda", "mps", "cpu"])
+    parser.add_argument("--preflight", action="store_true")
+    parser.add_argument("--model-count", action="store_true")
+    args = parser.parse_args()
+    if args.batch < 1 or args.workers < 0 or args.epochs < 1:
+        parser.error("batch/epochs must be positive; workers must be nonnegative")
+    if args.model_count:
+        m = {"global_lat": np.linspace(90, -90, 181), "global_lon": np.arange(360),
+             "regional_lat": np.linspace(60, 0, 241), "regional_lon": np.linspace(100, 180, 321),
+             "normalization": {"mean": [0] * len(CHANNELS), "std": [1] * len(CHANNELS)}}
+        model = make_model(m)
+        print(json.dumps({"version": VERSION, "architecture": ARCHITECTURE, "parameters": sum(p.numel() for p in model.parameters()), "channels": len(CHANNELS)}))
+        return
+    m = load_manifest(args.manifest, require_full=True)
+    if args.output is None:
+        args.output = persistent / "training/v164"
+    print(json.dumps({"version": VERSION, "dataset_role": m.get("dataset_role", "full"),
+                      "pilot_only": False, "samples": len(m["rows"]), "output": str(args.output)}), flush=True)
+    if args.preflight:
+        for split in ("train", "validation", "test"):
+            dataset = AtmosphereDataset(m, split)
+            if not len(dataset):
+                raise ValueError(f"Empty {split} split")
+            dataset[0]
+        print("PASS dataset integrity and first-sample checks. No training started.")
+        return
+    if Path("/content").is_dir() and not args.output.resolve().is_relative_to(Path("/content/drive/MyDrive/typhoon_predict")):
+        raise ValueError("Colab outputs must persist in MyDrive/typhoon_predict")
+    if Path("/content").is_dir() and not Path("/content/drive/MyDrive").is_dir():
+        raise RuntimeError("Mount Drive before training; refusing temporary checkpoints")
+    device = device_for(args.device)
+    random.seed(164); np.random.seed(164); torch.manual_seed(164)
+    model = make_model(m).to(device)
+    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=.01)
+    scaler = torch.amp.GradScaler("cuda", enabled=device.type == "cuda" and bool(args.amp))
+    args.output.mkdir(parents=True, exist_ok=True)
+    lock = args.output / "training.lock"
+    try:
+        fd = os.open(lock, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+    except FileExistsError as exc:
+        raise RuntimeError(f"Output locked: {lock}. Verify no other runtime is training before removing a stale lock.") from exc
+    os.write(fd, json.dumps({"pid": os.getpid(), "host": socket.gethostname()}).encode()); os.close(fd)
+    try:
+        train(model, optimizer, scaler, m, args, device)
+    finally:
+        lock.unlink(missing_ok=True)
+
+
+def train(model, optimizer, scaler, m, args, device):
+    last, best = args.output / "last.pt", args.output / "best.pt"
+    start, history, best_value = 1, [], float("inf")
+    if last.exists():
+        saved = torch.load(last, map_location="cpu", weights_only=False)
+        if saved["architecture"] != ARCHITECTURE or saved["dataset_sha256"] != m["identity"]:
+            raise ValueError("Resume architecture/dataset mismatch")
+        model.load_state_dict(saved["model"]); optimizer.load_state_dict(saved["optimizer"]); scaler.load_state_dict(saved["scaler"])
+        start, history, best_value = saved["epoch"] + 1, saved["history"], saved["best_value"]
+        random.setstate(saved["python_rng"]); np.random.set_state(saved["numpy_rng"]); torch.set_rng_state(saved["torch_rng"])
+        if device.type == "cuda" and saved.get("cuda_rng") is not None:
+            torch.cuda.set_rng_state_all(saved["cuda_rng"])
+    atomic_json(args.output / "manifest.json", {"version": VERSION, "architecture": ARCHITECTURE,
+                "parameters": sum(p.numel() for p in model.parameters()), "dataset_sha256": m["identity"],
+                "script_sha256": digest(__file__), "future_weather_as_inputs": False,
+                "official_forecasts_as_inputs": False, "ensemble": False,
+                "resume_policy": "last completed epoch with optimizer/scaler/RNG",
+                "physical_microbatch": 1, "effective_batch": args.batch})
+    workers = min(args.workers, max(0, (os.cpu_count() or 1) - 1), 2)
+    for epoch in range(start, args.epochs + 1):
+        horizon = [2, 4, 8, 12, 20][min(epoch - 1, 4)]
+        joint = epoch > 2
+        epoch_start = time.time()
+        metrics = {}
+        for split in ("train", "validation"):
+            training = split == "train"
+            model.train(training)
+            dataset = AtmosphereDataset(m, split, training)
+            if not len(dataset):
+                raise ValueError(f"Empty {split} split")
+            loader = DataLoader(dataset, batch_size=1, shuffle=training, num_workers=workers,
+                                **({"prefetch_factor": 1} if workers else {}))
+            optimizer.zero_grad(set_to_none=True)
+            sums = []
+            for index, (inputs, targets) in enumerate(loader, 1):
+                inputs = {k: v.to(device) for k, v in inputs.items()}
+                steps = horizon if training else 20
+                loss_block, total = 0, 0.0
+                with torch.set_grad_enabled(training):
+                    state = model.initial(inputs)
+                    for step in range(steps):
+                        with torch.autocast(device_type="cuda", dtype=torch.float16) if scaler.is_enabled() else nullcontext():
+                            state, out = model.step(state)
+                        # Transfer one target frame at a time to bound VRAM.
+                        frame = {k: v[:, step:step+1].to(device) for k, v in targets.items()}
+                        loss, _ = objective(out, frame, 0, m, joint)
+                        if not torch.isfinite(loss):
+                            raise RuntimeError(f"Non-finite loss epoch={epoch} sample={index} step={step}; checkpoint not advanced")
+                        total += float(loss.detach()) / steps
+                        loss_block = loss_block + loss / (steps * args.batch)
+                        if training and ((step + 1) % 2 == 0 or step + 1 == steps):
+                            scaler.scale(loss_block).backward()
+                            state = {k: v.detach() for k, v in state.items()}
+                            loss_block = 0
+                    if training and (index % args.batch == 0 or index == len(loader)):
+                        scaler.unscale_(optimizer)
+                        remainder = index % args.batch
+                        if index == len(loader) and remainder:
+                            for p in model.parameters():
+                                if p.grad is not None:
+                                    p.grad.mul_(args.batch / remainder)
+                        norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+                        if not torch.isfinite(norm):
+                            raise RuntimeError("Non-finite gradients; checkpoint not advanced. Retry last epoch with AMP=0.")
+                        scaler.step(optimizer); scaler.update(); optimizer.zero_grad(set_to_none=True)
+                sums.append(total)
+                if index == 1 or index % 10 == 0:
+                    print(f"{split} epoch={epoch}/{args.epochs} sample={index}/{len(loader)} horizon={steps} loss={total:.5f} elapsed_s={time.time()-epoch_start:.0f}", flush=True)
+            metrics[split] = float(np.mean(sums))
+        # Selection only after reaching the full horizon, on a stable joint objective.
+        promote = epoch >= 5 and metrics["validation"] < best_value
+        if promote:
+            best_value = metrics["validation"]
+        history.append({"epoch": epoch, "horizon": horizon, "joint": joint, **metrics})
+        payload = {"version": VERSION, "architecture": ARCHITECTURE, "dataset_sha256": m["identity"],
+                   "data_contract": {k: m[k] for k in ("channels", "units", "global_lat", "global_lon", "regional_lat", "regional_lon", "normalization")},
+                   "epoch": epoch, "model": model.state_dict(), "optimizer": optimizer.state_dict(),
+                   "scaler": scaler.state_dict(), "history": history, "best_value": best_value,
+                   "python_rng": random.getstate(), "numpy_rng": np.random.get_state(), "torch_rng": torch.get_rng_state(),
+                   "cuda_rng": torch.cuda.get_rng_state_all() if device.type == "cuda" else None}
+        atomic_checkpoint(last, payload)
+        if promote:
+            atomic_checkpoint(best, payload)
+        atomic_json(args.output / "history.json", history)
+        print(f"Saved completed epoch {epoch}: {last}; promoted_best={promote}", flush=True)
+    print("Training completed. Checkpoints and history are persistent. Test set was not used for selection.", flush=True)
+
+
+# BEGIN REUSE IMPLEMENTATION
+"""Embedded in the standalone v164 trainer: coarse archive plus native MSLP patches."""
+REUSE_ARCH = 'wp-coarse8-native-pressure1-v164'
+REUSE_CHANNELS = ['mslp', 'hgt500', 'uwnd850', 'vwnd850', 'uwnd500', 'vwnd500', 'uwnd200', 'vwnd200']
+
+
+def load_reuse(path):
+    path = Path(path)
+    if not path.is_file():
+        raise FileNotFoundError('Combined dataset missing. Run the updated Drive setup cell first: '+str(path))
+    m = json.loads(path.read_text())
+    if m.get('schema') != 'v164-reuse-pressure-v1' or m.get('pilot', True):
+        raise ValueError('Combined non-pilot archive required; no pilot fallback')
+    for name, entry in m['files'].items():
+        p = path.parent/entry['path']
+        print('Checking dataset file:', name, flush=True)
+        if digest(p) != entry['sha256']:
+            raise ValueError('Dataset checksum mismatch: '+name)
+        entry['resolved'] = str(p)
+    with np.load(m['files']['basin']['resolved'], allow_pickle=False) as z:
+        if z['channels'].tolist() != REUSE_CHANNELS[1:]:
+            raise ValueError('Coarse channel order mismatch')
+        times, lat, lon = z['time'], z['lat'], z['lon']
+        q = z['q']
+        scale, offset = z['scale'], z['offset']
+    if q.shape != (len(times),7,25,33) or not np.all(np.diff(times) == 6*HOUR):
+        raise ValueError('Coarse grid/time mismatch')
+    qpath = path.parent/'basin_q_verified.npy'
+    # Refresh the compact worker mmap from the checksum-verified source every preflight.
+    temporary = qpath.with_suffix('.pending.npy')
+    np.save(temporary, q)
+    os.replace(temporary, qpath)
+    slp = np.load(m['files']['slp']['resolved'], mmap_mode='r')
+    if slp.shape != (len(times),25,33) or not np.isfinite(slp).all():
+        raise ValueError('Coarse pressure coverage invalid')
+    with np.load(m['files']['track']['resolved'], allow_pickle=False) as z:
+        track = {k:z[k] for k in ['base_time','storm_id','base_lat','base_lon','target','target_mask']}
+        issue_intensity = z['track'][:,-1,4:6]*z['track_std'][4:6]+z['track_mean'][4:6]
+    plan = json.loads(Path(m['files']['plan']['resolved']).read_text())
+    if len(plan['rows']) != 1000 or plan['shape'] != [1000,29,121,121] or plan['lead_hours'] != list(range(-48,121,6)):
+        raise ValueError('Expected the verified 1000-window native pressure package, not the six-sample pilot')
+    pressure = np.load(m['files']['pressure']['resolved'], mmap_mode='r')
+    if pressure.shape != (1000,29,121,121):
+        raise ValueError('Native pressure shape mismatch')
+    patches = {}
+    for pi,row in enumerate(plan['rows']):
+        ti = row['track_archive_row']
+        if int(track['base_time'][ti]) != row['issue_ns'] or str(track['storm_id'][ti]) != row['storm_id']:
+            raise ValueError('Native patch/track identity mismatch')
+        patches[ti] = pi
+    first_year = {}
+    years = track['base_time'].astype('datetime64[ns]').astype('datetime64[Y]').astype(int)+1970
+    for sid,y in zip(track['storm_id'],years):
+        first_year[str(sid)] = min(first_year.get(str(sid),9999),int(y))
+    lookup = {(str(s),int(t)):i for i,(s,t) in enumerate(zip(track['storm_id'],track['base_time']))}
+    rows = []
+    for i,ns in enumerate(track['base_time']):
+        sid = str(track['storm_id'][i])
+        y = first_year[sid]
+        split = 'train' if 2000 <= y <= 2021 else 'validation' if 2022 <= y <= 2023 else 'test' if 2024 <= y <= 2025 else None
+        if split is None:
+            continue
+        low,high = {'train':(2000,2021),'validation':(2022,2023),'test':(2024,2025)}[split]
+        bounds = np.array([ns-48*HOUR,ns+120*HOUR],dtype='int64').astype('datetime64[ns]').astype('datetime64[Y]').astype(int)+1970
+        ai = int(np.searchsorted(times,ns))
+        center = [float(track['base_lat'][i]),float(track['base_lon'][i])%360]
+        if bounds[0] < low or bounds[1] > high or ai < 8 or ai+20 >= len(times) or times[ai] != ns:
+            continue
+        if not np.isfinite(center).all() or not (0 < center[0] < 60 and 100 < center[1] < 180):
+            continue
+        previous = lookup.get((sid,int(ns-6*HOUR)))
+        motion = [0.,0.]
+        if previous is not None:
+            old = [float(track['base_lat'][previous]),float(track['base_lon'][previous])%360]
+            if np.isfinite(old).all():
+                motion = [(center[1]-old[1])*111.2*np.cos(np.deg2rad(center[0])),(center[0]-old[0])*111.2]
+        future = [lookup.get((sid,int(ns+j*6*HOUR))) for j in range(1,21)]
+        target_centers = [[float(track['base_lat'][j]),float(track['base_lon'][j])%360] if j is not None else [0.,0.] for j in future]
+        rm = [float(j is not None and np.isfinite(target_centers[k]).all()) for k,j in enumerate(future)]
+        target_centers = np.nan_to_num(target_centers).tolist()
+        wind,p = track['target'][i,:,2],track['target'][i,:,3]
+        wm = track['target_mask'][i,:,2].astype(bool)&np.isfinite(wind)&(wind>=0)&(wind<250)
+        pm = track['target_mask'][i,:,3].astype(bool)&np.isfinite(p)&(p>800)&(p<1100)
+        pi = patches.get(i,-1)
+        if pi >= 0 and plan['rows'][pi]['split'] != split:
+            raise ValueError('Patch split mismatch')
+        issue = issue_intensity[i]
+        iv = [bool(np.isfinite(issue[0]) and 0<=issue[0]<250),bool(np.isfinite(issue[1]) and 800<issue[1]<1100)]
+        rows.append({'split':split,'storm_id':sid,'atlas':ai,'patch':pi,'center':center,'motion':motion,
+                     'issue_intensity':[float(issue[k]) if iv[k] else 0. for k in range(2)],'issue_mask':iv,
+                     'target_centers':target_centers,'route_mask':rm,
+                     'pressure':np.where(pm,p,0).tolist(),'pressure_mask':pm.tolist(),
+                     'vmax':np.where(wm,wind,0).tolist(),'vmax_mask':wm.tolist()})
+    counts = {s:sum(r['split']==s for r in rows) for s in ['train','validation','test']}
+    patch_counts = {s:sum(r['split']==s and r['patch']>=0 for r in rows) for s in counts}
+    if counts['train'] < 10000 or patch_counts != {'train':800,'validation':100,'test':100}:
+        raise ValueError(f'Incomplete combined coverage: {counts}, native patches {patch_counts}')
+    train_times = np.flatnonzero((times.astype('datetime64[ns]').astype('datetime64[Y]').astype(int)+1970>=2000)&
+                                (times.astype('datetime64[ns]').astype('datetime64[Y]').astype(int)+1970<=2021))
+    sums,squares = np.zeros(8),np.zeros(8)
+    n = 0
+    for start in range(0,len(train_times),256):
+        ii = train_times[start:start+256]
+        b = np.concatenate([np.asarray(slp[ii],dtype='float32')[:,None],q[ii].astype('float32')*scale[None,:,None,None]+offset[None,:,None,None]],1).astype('float64')
+        if not np.isfinite(b).all():
+            raise ValueError('Nonfinite coarse training fields')
+        sums += b.sum((0,2,3)); squares += (b*b).sum((0,2,3)); n += len(ii)*25*33
+    mean = sums/n
+    std = np.maximum(np.sqrt(np.maximum(squares/n-mean*mean,0)),1e-4)
+    m.update(rows=rows, plan=plan, qpath=str(qpath), scale=scale.tolist(), offset=offset.tolist(),
+             channels=REUSE_CHANNELS,units=['hPa','m','m/s','m/s','m/s','m/s','m/s','m/s'],
+             global_lat=lat.tolist(),global_lon=lon.tolist(),regional_lat=list(np.linspace(15,-15,121)),
+             regional_lon=list(np.linspace(-15,15,121)),normalization={'mean':mean.tolist(),'std':std.tolist(),'fit_split':'train','end_year':2021},
+             identity=digest(path),counts=counts,patch_counts=patch_counts)
+    print(json.dumps({'all_archive_windows':counts,'native_pressure_windows':patch_counts,'architecture':REUSE_ARCH}),flush=True)
+    return m
+
+
+class ReuseDataset(Dataset):
+    def __init__(self,m,split,training=False):
+        self.m = m
+        self.rows = [r for r in m['rows'] if r['split']==split]
+        self.arrays = None
+
+    def __len__(self):
+        return len(self.rows)
+
+    def __getitem__(self,i):
+        m,row = self.m,self.rows[i]
+        if self.arrays is None:
+            self.arrays = {k:np.load(m['files'][k]['resolved'],mmap_mode='r') for k in ['slp','pressure']}
+            self.arrays['q'] = np.load(m['qpath'],mmap_mode='r')
+            with np.load(m['files']['geography']['resolved'],allow_pickle=False) as geo:
+                self.arrays['land'] = geo['land_fraction']
+                self.arrays['height'] = geo['elevation_m']/8000
+        ai = row['atlas']
+        ii = slice(ai-8,ai+21)
+        coarse = np.concatenate([np.array(self.arrays['slp'][ii],dtype='float32')[:,None],
+              np.array(self.arrays['q'][ii],dtype='float32')*np.array(m['scale'],dtype='float32')[None,:,None,None]+np.array(m['offset'],dtype='float32')[None,:,None,None]],1)
+        mean,std = np.array(m['normalization']['mean'],dtype='float32'),np.array(m['normalization']['std'],dtype='float32')
+        coarse = (coarse-mean[None,:,None,None])/std[None,:,None,None]
+        pi = row['patch']
+        anchor = m['plan']['rows'][pi] if pi>=0 else {'center_lat':round(row['center'][0]*4)/4,'center_lon':round(row['center'][1]*4)/4}
+        lat = anchor['center_lat']+np.linspace(15,-15,121,dtype='float32')
+        lon = anchor['center_lon']+np.linspace(-15,15,121,dtype='float32')
+        yy,xx = np.meshgrid(lat,lon,indexing='ij')
+        y = np.rint((90-yy)*4).astype(int); x = np.rint(xx*4).astype(int)%1440
+        rs = np.stack([yy/90,xx/180-1,self.arrays['land'][y,x],self.arrays['height'][y,x]]).astype('float32')
+        cy,cx = np.meshgrid(m['global_lat'],m['global_lon'],indexing='ij')
+        iy = np.rint((90-cy)*4).astype(int); ix = np.rint(cx*4).astype(int)%1440
+        gs = np.stack([cy/90,cx/180-1,self.arrays['land'][iy,ix],self.arrays['height'][iy,ix]]).astype('float32')
+        detail = np.zeros((29,1,121,121),dtype='float32')
+        if pi>=0:
+            detail[:,0] = (np.array(self.arrays['pressure'][pi],dtype='float32')-mean[0])/std[0]
+            if not np.isfinite(detail).all():
+                raise ValueError('Native pressure contains nonfinite fields')
+        inputs = {'global_history':coarse[:9], 'regional_history':detail[:9],
+                  'global_static':gs,'regional_static':rs,'detail_available':np.array([pi>=0],dtype='float32'),
+                  'center':np.array(row['center'],dtype='float32'),'motion':np.array(row['motion'],dtype='float32'),
+                  'issue_intensity':np.array(row['issue_intensity'],dtype='float32'),'issue_mask':np.array(row['issue_mask'],dtype='float32')}
+        targets = {'global':coarse[9:],'global_mask':np.ones_like(coarse[9:]),
+                   'regional_lat_weight':np.broadcast_to(np.cos(np.deg2rad(lat))[None,None,:,None],(20,1,121,1)).astype('float32'),
+                   'regional':detail[9:],'regional_mask':np.full_like(detail[9:],float(pi>=0)),
+                   'center':np.array(row['target_centers'],dtype='float32'),
+                   'storm_mask':np.array(row['route_mask'],dtype='float32')}
+        for k in ['pressure','pressure_mask','vmax','vmax_mask']:
+            targets[k] = np.array(row[k],dtype='float32')
+        return {k:torch.from_numpy(v.copy()) for k,v in inputs.items()},{k:torch.from_numpy(v.copy()) for k,v in targets.items()}
+
+
+class ReuseForecaster(nn.Module):
+    def __init__(self,m,tiny=False):
+        super().__init__()
+        self.global_time = nn.Conv2d(8*9,8,1)
+        self.regional_time = nn.Conv2d(9,1,1)
+        self.global_operator = FieldOperator(8,8 if tiny else 80,False,1 if tiny else 3,tiny)
+        self.regional_operator = FieldOperator(1,8 if tiny else 88,False,0,tiny)
+        self.parent_fusion = nn.Conv2d(1+8+1,1,1)
+        self.object_score = nn.Conv2d(32+3,1,1)
+        self.intensity = nn.Sequential(nn.Linear(32+3+4,64),nn.GELU(),nn.Linear(64,2))
+        self.register_buffer('mean',torch.tensor(m['normalization']['mean'],dtype=torch.float32)[None,:,None,None])
+        self.register_buffer('std',torch.tensor(m['normalization']['std'],dtype=torch.float32)[None,:,None,None])
+        yy,xx = np.meshgrid(m['global_lat'],m['global_lon'],indexing='ij')
+        self.register_buffer('yy',torch.tensor(yy,dtype=torch.float32)[None])
+        self.register_buffer('xx',torch.tensor(xx,dtype=torch.float32)[None])
+
+    def initial(self,inputs):
+        required = {'global_history','regional_history','global_static','regional_static','detail_available','center','motion','issue_intensity','issue_mask'}
+        if set(inputs)!=required:
+            raise ValueError('Only declared causal inputs are allowed')
+        gh,rh = inputs['global_history'],inputs['regional_history']
+        rs = inputs['regional_static']
+        yy,xx = rs[:,0]*90,(rs[:,1]+1)*180
+        grid = torch.stack([(xx-100)/40-1,1-yy/30],-1)
+        return {'g':gh[:,-1],'r':rh[:,-1],'gc':self.global_time(gh.flatten(1,2)),
+                'rc':self.regional_time(rh.flatten(1,2)),'gs':inputs['global_static'],'rs':rs,
+                'grid':grid,'available':inputs['detail_available'],'center':inputs['center'],
+                'motion':inputs['motion'],'issue':inputs['issue_intensity'],'issue_mask':inputs['issue_mask']}
+
+    def step(self,s):
+        g,features = self.global_operator(s['g'],s['gc'],torch.ones_like(s['g']),s['gs'])
+        valid = (s['grid'].abs()<=1).all(-1)[:,None].to(g.dtype)
+        parent = F.grid_sample(g,s['grid'],align_corners=True,padding_mode='zeros')*valid
+        r = s['r']
+        if bool(s['available'].any()):
+            context = self.parent_fusion(torch.cat([s['rc'],parent,valid],1))
+            r,_ = self.regional_operator(r,context,torch.ones_like(r),s['rs'])
+        physical = g.float()*self.std+self.mean
+        p = physical[:,0]
+        anomaly = p-F.avg_pool2d(F.pad(p[:,None],(2,2,2,2),mode='replicate'),5,1)[:,0]
+        evidence = torch.cat([features.float(),anomaly[:,None]/10,physical[:,2:4]/30],1)
+        lat0,lon0 = s['center'][:,0,None,None],s['center'][:,1,None,None]
+        plat = lat0+s['motion'][:,1,None,None]/111.2
+        plon = lon0+s['motion'][:,0,None,None]/(111.2*lat0.deg2rad().cos().clamp_min(.2))
+        d2 = ((self.yy-plat)*111.2).square()+((self.xx-plon)*111.2*lat0.deg2rad().cos()).square()
+        score = self.object_score(evidence)[:,0]-anomaly/10-d2/(2*600**2)
+        peak = score.flatten(1).argmax(1)
+        iy,ix = torch.arange(25,device=g.device)[None,:,None],torch.arange(33,device=g.device)[None,None,:]
+        local = ((iy-(peak//33)[:,None,None]).abs()<=1)&((ix-(peak%33)[:,None,None]).abs()<=1)
+        pdf = torch.softmax(score.masked_fill(~local,-1e9).flatten(1),1).reshape_as(score)
+        center = torch.stack([(pdf*self.yy).sum((1,2)),(pdf*self.xx).sum((1,2))],1)
+        pooled = (evidence*pdf[:,None]).sum((2,3))
+        scalar = torch.cat([s['issue']/torch.tensor([100.,1000.],device=g.device),s['issue_mask']],1)
+        intensity = self.intensity(torch.cat([pooled,scalar],1))
+        grid_p = (p*pdf).sum((1,2))
+        dy,dx = s['rs'][:,0]*90,(s['rs'][:,1]+1)*180
+        sample = torch.stack([2*(center[:,1]-dx[:,0,0])/30-1,2*(dy[:,0,0]-center[:,0])/30-1],-1)[:,None,None]
+        inside = (sample.abs()<=1).all((1,2,3)) & (s['available'][:,0]>0)
+        detailed_p = F.grid_sample(r.float()*self.std[:,:1]+self.mean[:,:1],sample,align_corners=True)[:,0,0,0]
+        grid_p = torch.where(inside,detailed_p,grid_p)
+        pressure = grid_p-F.softplus(intensity[:,0])*5
+        vmax = s['issue'][:,0]*s['issue_mask'][:,0]+intensity[:,1]*10
+        meanlat = (center[:,0]+s['center'][:,0])/2
+        motion = torch.stack([(center[:,1]-s['center'][:,1])*111.2*meanlat.deg2rad().cos(),(center[:,0]-s['center'][:,0])*111.2],1)
+        return dict(s,g=g,r=r,center=center,motion=motion),{'global':g,'regional':r,'center':center,'pressure':pressure,'vmax':vmax,'grid_pressure':grid_p}
+
+    def forward(self,inputs,steps=20):
+        s = self.initial(inputs)
+        out = []
+        for _ in range(steps):
+            s,o = self.step(s); out.append(o)
+        return {k:torch.stack([o[k] for o in out],1) for k in out[0]}
+
+
+def reuse_main():
+    global ARCHITECTURE, AtmosphereDataset
+    ARCHITECTURE,AtmosphereDataset = REUSE_ARCH,ReuseDataset
+    p = argparse.ArgumentParser(description='v1.2.64 coarse weather + native pressure training; no pilot fallback')
+    p.add_argument('batch',type=int,nargs='?',default=10)
+    p.add_argument('workers',type=int,nargs='?',default=3)
+    p.add_argument('amp',type=int,nargs='?',default=1,choices=[0,1])
+    p.add_argument('--manifest',type=Path,default=ROOT/'data/v164_reuse/manifest.json')
+    persistent = Path('/content/drive/MyDrive/typhoon_predict') if Path('/content').is_dir() else ROOT
+    p.add_argument('--output',type=Path,default=persistent/'training/v164_reuse_pressure')
+    p.add_argument('--epochs',type=int,default=12)
+    p.add_argument('--device',default='auto',choices=['auto','cpu','mps','cuda'])
+    p.add_argument('--preflight',action='store_true')
+    args = p.parse_args()
+    if args.batch<1 or args.workers<0 or args.epochs<1:
+        p.error('Invalid batch/workers/epochs')
+    m = load_reuse(args.manifest)
+    for split in ['train','validation','test']:
+        d = ReuseDataset(m,split)
+        d[0]
+        d[next(i for i,r in enumerate(d.rows) if r['patch']>=0)]
+    if args.preflight:
+        print('PASS combined non-pilot archives and native pressure data. No training started.',flush=True)
+        return
+    if Path('/content').is_dir() and not args.output.resolve().is_relative_to(persistent.resolve()):
+        raise ValueError('Colab checkpoints must persist in typhoon_predict on Drive')
+    device = device_for(args.device)
+    random.seed(164); np.random.seed(164); torch.manual_seed(164)
+    model = ReuseForecaster(m).to(device)
+    print(json.dumps({'version':VERSION,'architecture':REUSE_ARCH,'parameters':sum(x.numel() for x in model.parameters()),'device':str(device),'windows':m['counts'],'native_windows':m['patch_counts'],'output':str(args.output)}),flush=True)
+    optimizer = torch.optim.AdamW(model.parameters(),lr=1e-4,weight_decay=.01)
+    scaler = torch.amp.GradScaler('cuda',enabled=device.type=='cuda' and bool(args.amp))
+    args.output.mkdir(parents=True,exist_ok=True)
+    lock = args.output/'training.lock'
+    fd = os.open(lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY)
+    os.write(fd,json.dumps({'pid':os.getpid(),'host':socket.gethostname()}).encode()); os.close(fd)
+    try:
+        train(model,optimizer,scaler,m,args,device)
+    finally:
+        lock.unlink(missing_ok=True)
+
+if __name__ == "__main__":
+    reuse_main()

training/trackformer_1_2/source/data_preparation/v164_prepare_data.py

@@ -0,0 +1,348 @@
+"""Prepare a resumable, explicitly labelled v164 data pilot from public ERA5.
+
+This downloads native fields. It does not upsample the old coarse archive,
+start training, or put verification labels into model inputs.
+"""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import shutil
+import time
+
+import numpy as np
+import v164_global_regional_train as trainer
+
+SOURCE = 'https://storage.googleapis.com/gcp-public-data-arco-era5/ar/full_37-1h-0p25deg-chunk-1.zarr-v3'
+TRACK_SHA = 'cb8d7291aa8140124ca522feb448a1d44124b018efc4ba1d54824b60a4f73451'
+SURFACE = ['mean_sea_level_pressure', 'surface_pressure', '10m_u_component_of_wind',
+           '10m_v_component_of_wind', '2m_temperature', 'sea_surface_temperature']
+UPPER = ['u_component_of_wind', 'v_component_of_wind', 'temperature', 'specific_humidity', 'geopotential']
+STEP = 6 * trainer.HOUR
+
+
+def year(ns):
+    return int(np.datetime64(int(ns), 'ns').astype('datetime64[Y]').astype(int)) + 1970
+
+
+def build_plan(track_path, counts=(3, 1, 1), oversample=1):
+    if trainer.digest(track_path) != TRACK_SHA:
+        raise ValueError('Shared track archive checksum mismatch')
+    with np.load(track_path, allow_pickle=False) as z:
+        tracks = {k: z[k] for k in ('storm_id', 'base_time', 'base_lat', 'base_lon', 'n_leads', 'target', 'target_mask')}
+        issue_intensity = z['track'][:, -1, 4:6]*z['track_std'][4:6] + z['track_mean'][4:6]
+    sid, times = tracks['storm_id'], tracks['base_time']
+    first_year = {}
+    for storm, ns in zip(sid, times):
+        first_year[str(storm)] = min(first_year.get(str(storm), 9999), year(ns))
+    lookup = {(str(s), int(t)): i for i, (s, t) in enumerate(zip(sid, times))}
+    rows = []
+    rng = np.random.default_rng(164)
+    for split, bounds, count in zip(('train', 'validation', 'test'), ((2000, 2021), (2022, 2023), (2024, 2025)), counts):
+        candidates = {}
+        for i, (storm, ns) in enumerate(zip(sid, times)):
+            storm, ns = str(storm), int(ns)
+            lat, lon = float(tracks['base_lat'][i]), float(tracks['base_lon'][i]) % 360
+            if not (bounds[0] <= first_year[storm] <= bounds[1] and bounds[0] <= year(ns-8*STEP)
+                    and year(ns+20*STEP) <= bounds[1] and ns % STEP == 0 and tracks['n_leads'][i] >= 20
+                    and issue_intensity[i, 0] >= 90 and 850 < issue_intensity[i, 1] <= 960
+                    and 0 < lat < 40 and 100 < lon < 180 and '1979' not in storm and storm.upper() != 'TIP'):
+                continue
+            future = [lookup.get((storm, ns + lead*STEP)) for lead in range(1, 21)]
+            if sum(j is not None for j in future) < 16:
+                continue
+            candidates.setdefault(storm, []).append((i, future))
+        storms = sorted(candidates)
+        if len(storms) < count:
+            raise ValueError(f'Not enough eligible {split} storms: {len(storms)} < {count}')
+        for storm in rng.choice(storms, size=min(len(storms), count*oversample), replace=False):
+            choices = candidates[storm]
+            i, future = min(choices, key=lambda item: float(issue_intensity[item[0], 1]))
+            p, vmax = tracks['target'][i, :, 3], tracks['target'][i, :, 2]
+            pm = tracks['target_mask'][i, :, 3] & np.isfinite(p) & (p > 800) & (p < 1100)
+            vm = tracks['target_mask'][i, :, 2] & np.isfinite(vmax) & (vmax >= 0) & (vmax < 250)
+            rows.append({'issue_ns': int(times[i]), 'split': split, 'storm_id': str(storm),
+                         'verification_issue_center': [float(tracks['base_lat'][i]), float(tracks['base_lon'][i]) % 360],
+                         'target_centers': [[float(tracks['base_lat'][j]), float(tracks['base_lon'][j]) % 360]
+                                            if j is not None else [0., 0.] for j in future],
+                         'route_mask': [int(j is not None) for j in future],
+                         'target_pressure_hpa': np.where(pm, p, 0).tolist(), 'pressure_mask': pm.astype(int).tolist(),
+                         'target_vmax_kt': np.where(vm, vmax, 0).tolist(), 'vmax_mask': vm.astype(int).tolist()})
+    # An unconditional atmospheric sample, not a claim that no cyclone exists.
+    rows.append({'issue_ns': int(np.datetime64('2021-01-15T00', 'ns').astype('int64')), 'split': 'train',
+                 'storm_id': None, 'sample_kind': 'unconditional_atmosphere'})
+    stamps = sorted({row['issue_ns'] + i*STEP for row in rows for i in range(-8, 21)})
+    indices = {t: i for i, t in enumerate(stamps)}
+    for row in rows:
+        row['issue_index'] = indices[row['issue_ns']]
+    result = {'schema': 'v164-preparation-plan-v1', 'dataset_role': 'pipeline_pilot_not_full_training',
+              'source': SOURCE, 'track_sha256': TRACK_SHA, 'rows': rows, 'time': stamps,
+              'estimated_field_bytes': len(stamps)*31*(181*360+241*321)*4,
+              'network_warning': 'ARCO upper-air chunks contain all 37 levels and the globe; transfer can greatly exceed saved size.',
+              'sampling': 'mature intense issue-time storms for association testing; not representative benchmark sampling',
+              'counts': list(counts)}
+    result['plan_sha256'] = hashlib.sha256(json.dumps(result, sort_keys=True).encode()).hexdigest()
+    return result
+
+
+def resolve_associations(plan, source):
+    selected, rejected = [], []
+    for split, required in zip(('train', 'validation', 'test'), plan['counts']):
+        accepted = 0
+        for row in plan['rows']:
+            if row['split'] != split or not row.get('storm_id'):
+                continue
+            print('Checking issue-time analysis association:', split, row['storm_id'], flush=True)
+            pressure = source.domains(source.read('mean_sea_level_pressure', row['issue_ns'])/100)[1]
+            center = analysis_center(pressure[None], source.rl, source.ro)
+            truth = np.asarray(row['verification_issue_center'])
+            distance = float(np.linalg.norm((center-truth)*[111.2, 111.2*np.cos(np.deg2rad(truth[0]))]))
+            if distance > 400:
+                rejected.append({'storm_id': row['storm_id'], 'issue_ns': row['issue_ns'], 'distance_km': distance})
+                continue
+            selected.append(dict(row))
+            accepted += 1
+            if accepted == required:
+                break
+        if accepted < required:
+            raise ValueError(f'Insufficient unambiguous issue-time associations for {split}; no dataset was published')
+    selected.extend(dict(r) for r in plan['rows'] if not r.get('storm_id'))
+    times = sorted({r['issue_ns']+i*STEP for r in selected for i in range(-8, 21)})
+    lookup = {t: i for i, t in enumerate(times)}
+    for row in selected:
+        row['issue_index'] = lookup[row['issue_ns']]
+    result = dict(plan, rows=selected, time=times, rejected_issue_associations=rejected,
+                  estimated_field_bytes=len(times)*31*(181*360+241*321)*4)
+    result.pop('plan_sha256', None)
+    result['plan_sha256'] = hashlib.sha256(json.dumps(result, sort_keys=True).encode()).hexdigest()
+    return result
+
+
+class Era5Source:
+    def __init__(self):
+        import xarray as xr
+        self.ds = xr.open_zarr(SOURCE, consolidated=True, chunks=None)
+        missing = set(SURFACE + UPPER + ['land_sea_mask', 'geopotential_at_surface']) - set(self.ds)
+        if missing:
+            raise ValueError(f'ERA5 missing variables: {sorted(missing)}')
+        if not set(trainer.LEVELS).issubset(set(self.ds.level.values.tolist())):
+            raise ValueError('ERA5 does not supply all required pressure levels')
+        self.lat, self.lon = self.ds.latitude.values, self.ds.longitude.values
+        if not np.allclose(self.lat, np.linspace(90, -90, 721)) or not np.allclose(self.lon, np.arange(1440)*.25):
+            raise ValueError('Unexpected ERA5 native grid; no implicit regridding')
+        self.gl, self.go = self.lat[::4], self.lon[::4]
+        self.ys = np.flatnonzero((self.lat >= 0) & (self.lat <= 60))
+        self.xs = np.flatnonzero((self.lon >= 100) & (self.lon <= 180))
+        self.rl, self.ro = self.lat[self.ys], self.lon[self.xs]
+
+    def read(self, name, ns, levels=None):
+        date = np.datetime64(int(ns), 'ns')
+        stop = np.datetime64(self.ds.attrs['valid_time_stop'])
+        if date > stop or date < np.datetime64(self.ds.attrs['valid_time_start']):
+            raise ValueError(f'{date} outside final ERA5 availability; no ERA5T substitution')
+        a = self.ds[name].sel(time=date)
+        if levels is not None:
+            a = a.sel(level=list(levels)).transpose('level', 'latitude', 'longitude')
+        else:
+            a = a.transpose('latitude', 'longitude')
+        for attempt in range(3):
+            try:
+                return np.asarray(a.values, dtype='float32')
+            except (OSError, TimeoutError, ConnectionError):
+                if attempt == 2:
+                    raise
+                time.sleep(2**attempt)
+
+    def domains(self, a):
+        return a[..., ::4, ::4], a[..., self.ys[:, None], self.xs[None, :]]
+
+    def frame(self, ns):
+        out = {name: np.empty((31, len(lat), len(lon)), dtype='float32')
+               for name, lat, lon in [('global', self.gl, self.go), ('regional', self.rl, self.ro)]}
+        for i, name in enumerate(SURFACE):
+            print('  reading', name, flush=True)
+            a = self.read(name, ns)
+            if i < 2:
+                a = a / 100.0
+            if i == 5:
+                a = np.where((a >= 260) & (a <= 330), a, np.nan)
+            for domain, values in zip(out, self.domains(a)):
+                out[domain][i] = values
+        for j, name in enumerate(UPPER):
+            print('  reading', name, 'levels', trainer.LEVELS, flush=True)
+            a = self.read(name, ns, trainer.LEVELS)
+            for domain, values in zip(out, self.domains(a)):
+                for level in range(5):
+                    out[domain][6+level*5+j] = values[level]
+        for name, values in out.items():
+            validate_frame(values, name)
+        return out
+
+    def static(self, ns):
+        land = np.clip(self.read('land_sea_mask', ns), 0, 1)
+        altitude = self.read('geopotential_at_surface', ns)/9.80665
+        result = {}
+        for i, (name, lat, lon) in enumerate([('global', self.gl, self.go), ('regional', self.rl, self.ro)]):
+            yy, xx = np.meshgrid(lat, lon, indexing='ij')
+            result[name] = np.stack([yy/90, xx/180-1, self.domains(land)[i], self.domains(altitude)[i]/8000]).astype('float32')
+        return result
+
+
+def validate_frame(a, name):
+    if not np.isfinite(a[[i for i in range(31) if i != 5]]).all():
+        raise ValueError(f'Nonfinite {name} atmospheric field; refusing zero-fill')
+    if not (800 < a[0].min() <= a[0].max() < 1120):
+        raise ValueError(f'{name} MSLP range/unit failure')
+    if not (150 < a[4].min() <= a[4].max() < 350):
+        raise ValueError(f'{name} temperature range/unit failure')
+
+
+def analysis_center(field, lat, lon, previous=None):
+    pressure = field[0].copy()
+    yy, xx = np.meshgrid(lat, lon, indexing='ij')
+    allowed = (yy > 0) & (yy < 40)
+    if previous is not None:
+        distance = ((yy-previous[0])*111.2)**2 + ((xx-previous[1])*111.2*np.cos(np.deg2rad(previous[0])))**2
+        allowed &= distance < 600**2
+    index = np.argmin(np.where(allowed, pressure, np.inf))
+    return np.array([yy.flat[index], xx.flat[index]], dtype='float32')
+
+
+def materialize(plan, root, source, max_gb=4, smoke=False):
+    root = Path(root)
+    root.mkdir(parents=True, exist_ok=True)
+    plan_path, progress_path = root/'preparation_plan.json', root/'preparation_progress.json'
+    if plan_path.exists() and json.loads(plan_path.read_text())['plan_sha256'] != plan['plan_sha256']:
+        raise ValueError('Existing preparation uses a different plan; choose a separate dataset directory')
+    needed = plan['estimated_field_bytes']
+    if needed > max_gb*1e9:
+        raise ValueError(f'Plan needs {needed/1e9:.2f} GB; exceeds explicit {max_gb} GB limit')
+    existing = sum(p.stat().st_size for p in root.glob('*.npy'))
+    if shutil.disk_usage(root).free < max(0, needed-existing) + (128 if smoke else 512)*1024**2:
+        raise OSError('Insufficient storage for data and safety margin')
+    trainer.atomic_json(plan_path, plan)
+    progress = json.loads(progress_path.read_text()) if progress_path.exists() else {'frames': {}}
+    if (root/'manifest.json').exists():
+        trainer.load_manifest(root/'manifest.json', smoke=smoke)
+        print('Prepared dataset already verified.', flush=True)
+        return
+    arrays = {}
+    for name, lat, lon in [('global', source.gl, source.go), ('regional', source.rl, source.ro)]:
+        p = root/(name+'.npy')
+        shape = (len(plan['time']), 31, len(lat), len(lon))
+        arrays[name] = np.lib.format.open_memmap(p, mode='r+' if p.exists() else 'w+', dtype='float32', shape=shape)
+        if arrays[name].shape != shape:
+            raise ValueError('Partial data shape mismatch')
+    for i, ns in enumerate(plan['time']):
+        key = str(ns)
+        def frame_digest():
+            h = hashlib.sha256()
+            for a in arrays.values():
+                h.update(np.ascontiguousarray(a[i]).tobytes())
+            return h.hexdigest()
+        if key in progress['frames'] and frame_digest() == progress['frames'][key]:
+            continue
+        print(f'ERA5 frame {i+1}/{len(plan["time"])}: {np.datetime64(ns, "ns")} (31 channels)', flush=True)
+        frame = source.frame(ns)
+        for name, a in arrays.items():
+            a[i] = frame[name]
+            a.flush()
+        progress['frames'][key] = frame_digest()
+        progress.update(completed=len(progress['frames']), total=len(plan['time']), last_completed_utc=str(np.datetime64(ns, 'ns')))
+        trainer.atomic_json(progress_path, progress)
+    np.save(root/'time.npy', np.asarray(plan['time'], dtype='int64'))
+    for name, a in source.static(plan['time'][0]).items():
+        np.save(root/(name+'_static.npy'), a)
+    sums, squares, counts = np.zeros(31), np.zeros(31), np.zeros(31)
+    for i, ns in enumerate(plan['time']):
+        if not 2000 <= year(ns) <= 2021:
+            continue
+        for a in arrays.values():
+            values = np.asarray(a[i], dtype='float64').reshape(31, -1)
+            sums += np.nansum(values, axis=1)
+            squares += np.nansum(values**2, axis=1)
+            counts += np.isfinite(values).sum(axis=1)
+    if (counts == 0).any():
+        raise ValueError('Missing training-only normalization data')
+    mean = sums/counts
+    std = np.maximum(np.sqrt(np.maximum(squares/counts-mean**2, 0)), 1e-6)
+    rows = []
+    for original in plan['rows']:
+        row = dict(original)
+        i = row['issue_index']
+        # Association is derived solely from issue/past ERA5, never best-track coordinates.
+        center = analysis_center(arrays['regional'][i], source.rl, source.ro)
+        past = analysis_center(arrays['regional'][i-1], source.rl, source.ro, center)
+        row['center'] = center.tolist()
+        row['motion_km_per_6h'] = [float((center[1]-past[1])*111.2*np.cos(np.deg2rad(center[0]))), float((center[0]-past[0])*111.2)]
+        truth = row.pop('verification_issue_center', None)
+        if truth is not None:
+            dist = np.linalg.norm((center-np.array(truth))*[111.2, 111.2*np.cos(np.deg2rad(truth[0]))])
+            row['issue_association_error_km'] = float(dist)
+            if dist > 400:
+                row['route_mask'] = row['pressure_mask'] = row['vmax_mask'] = [0]*20
+        rows.append(row)
+    (root/'samples.jsonl').write_text(''.join(json.dumps(row)+'\n' for row in rows))
+    m = {'schema': 'v164-atmosphere-v1', 'synthetic': bool(smoke), 'dataset_role': plan['dataset_role'],
+         'channels': trainer.CHANNELS, 'units': trainer.UNITS,
+         'global_lat': source.gl.tolist(), 'global_lon': source.go.tolist(),
+         'regional_lat': source.rl.tolist(), 'regional_lon': source.ro.tolist(),
+         'normalization': {'fit_split': 'train', 'end_year': 2021, 'mean': mean.tolist(), 'std': std.tolist()},
+         'future_weather_as_inputs': False, 'official_forecasts_as_inputs': False,
+         'inputs_are_analysis_valid_time_hindcasts_not_operational_release_time': True,
+         'source': SOURCE, 'track_archive_sha256': plan['track_sha256'], 'files': {}}
+    for name in ('global', 'regional', 'global_static', 'regional_static', 'time', 'samples'):
+        p = root/(name+('.jsonl' if name == 'samples' else '.npy'))
+        m['files'][name] = {'path': p.name, 'sha256': trainer.digest(p)}
+    for split in ('train', 'validation', 'test'):
+        if not any(row['split'] == split and any(row.get('route_mask', [])) for row in rows):
+            raise ValueError(f'No valid analysis-associated storm labels in {split}. Pilot is insufficient; do not train it.')
+    # Validate a temporary manifest before publishing the ready marker.
+    candidate = root/'manifest.pending.json'
+    trainer.atomic_json(candidate, m)
+    trainer.load_manifest(candidate, smoke=smoke)
+    candidate.replace(root/'manifest.json')
+    print('PILOT DATA READY. This is not the full training corpus or evidence of forecast skill.', flush=True)
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--track', type=Path, required=True)
+    p.add_argument('--output', type=Path, required=True)
+    p.add_argument('--prepare', action='store_true')
+    p.add_argument('--max-gb', type=float, default=4)
+    p.add_argument('--cases', type=int, nargs=3, default=[3, 1, 1], metavar=('TRAIN', 'VAL', 'TEST'))
+    args = p.parse_args()
+    if min(args.cases) < 1:
+        p.error('Each split needs at least one case')
+    plan = build_plan(args.track, args.cases, oversample=4 if args.prepare else 1)
+    if args.prepare:
+        args.output.mkdir(parents=True, exist_ok=True)
+        lock = args.output/'preparation.lock'
+        fd = os.open(lock, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+        os.close(fd)
+        try:
+            source = Era5Source()
+            previous = args.output/'preparation_plan.json'
+            if previous.exists():
+                plan = json.loads(previous.read_text())
+                if plan['track_sha256'] != TRACK_SHA or plan['counts'] != args.cases or plan['source'] != SOURCE:
+                    raise ValueError('Existing preparation configuration differs; choose a new output directory')
+                saved_hash = plan['plan_sha256']
+                payload = {k: v for k, v in plan.items() if k != 'plan_sha256'}
+                if hashlib.sha256(json.dumps(payload, sort_keys=True).encode()).hexdigest() != saved_hash:
+                    raise ValueError('Existing preparation plan checksum mismatch')
+            else:
+                plan = resolve_associations(plan, source)
+            print(json.dumps({k: v for k, v in plan.items() if k not in ('rows', 'time')}, indent=2), flush=True)
+            materialize(plan, args.output, source, args.max_gb)
+        finally:
+            lock.unlink(missing_ok=True)
+    else:
+        print(json.dumps({k: v for k, v in plan.items() if k not in ('rows', 'time')}, indent=2), flush=True)
+        print('Plan only. Add --prepare to download. No training is started.', flush=True)
+
+
+if __name__ == '__main__':
+    main()

training/trackformer_1_2/source/data_preparation/v164_prepare_mac.py

@@ -0,0 +1,36 @@
+"""Mac data preparation with three concurrent source-variable reads.
+
+Uses the same plan, fields, validation and resume records as the serial preparer.
+This utility is not called by the Drive-only Colab notebook.
+"""
+from concurrent.futures import ThreadPoolExecutor
+
+import v164_prepare_data as prep
+
+
+class ConcurrentEra5Source(prep.Era5Source):
+    _pending = None
+
+    def read(self, name, ns, levels=None):
+        key = (name, int(ns), tuple(levels) if levels is not None else None)
+        if self._pending is not None and key in self._pending:
+            return self._pending.pop(key).result()
+        return super().read(name, ns, levels)
+
+    def frame(self, ns):
+        jobs = [(name, None) for name in prep.SURFACE]
+        jobs += [(name, tuple(prep.trainer.LEVELS)) for name in prep.UPPER]
+        with ThreadPoolExecutor(max_workers=3) as pool:
+            self._pending = {(name, int(ns), levels): pool.submit(super().read, name, ns, levels)
+                             for name, levels in jobs}
+            try:
+                return super().frame(ns)
+            finally:
+                for future in self._pending.values():
+                    future.cancel()
+                self._pending = None
+
+
+if __name__ == '__main__':
+    prep.Era5Source = ConcurrentEra5Source
+    prep.main()

training/trackformer_1_2/source/data_preparation/v164_reuse_impl.py

@@ -0,0 +1,283 @@
+"""Embedded in the standalone v164 trainer: coarse archive plus native MSLP patches."""
+REUSE_ARCH = 'wp-coarse8-native-pressure1-v164'
+REUSE_CHANNELS = ['mslp', 'hgt500', 'uwnd850', 'vwnd850', 'uwnd500', 'vwnd500', 'uwnd200', 'vwnd200']
+
+
+def load_reuse(path):
+    path = Path(path)
+    if not path.is_file():
+        raise FileNotFoundError('Combined dataset missing. Run the updated Drive setup cell first: '+str(path))
+    m = json.loads(path.read_text())
+    if m.get('schema') != 'v164-reuse-pressure-v1' or m.get('pilot', True):
+        raise ValueError('Combined non-pilot archive required; no pilot fallback')
+    for name, entry in m['files'].items():
+        p = path.parent/entry['path']
+        print('Checking dataset file:', name, flush=True)
+        if digest(p) != entry['sha256']:
+            raise ValueError('Dataset checksum mismatch: '+name)
+        entry['resolved'] = str(p)
+    with np.load(m['files']['basin']['resolved'], allow_pickle=False) as z:
+        if z['channels'].tolist() != REUSE_CHANNELS[1:]:
+            raise ValueError('Coarse channel order mismatch')
+        times, lat, lon = z['time'], z['lat'], z['lon']
+        q = z['q']
+        scale, offset = z['scale'], z['offset']
+    if q.shape != (len(times),7,25,33) or not np.all(np.diff(times) == 6*HOUR):
+        raise ValueError('Coarse grid/time mismatch')
+    qpath = path.parent/'basin_q_verified.npy'
+    # Refresh the compact worker mmap from the checksum-verified source every preflight.
+    temporary = qpath.with_suffix('.pending.npy')
+    np.save(temporary, q)
+    os.replace(temporary, qpath)
+    slp = np.load(m['files']['slp']['resolved'], mmap_mode='r')
+    if slp.shape != (len(times),25,33) or not np.isfinite(slp).all():
+        raise ValueError('Coarse pressure coverage invalid')
+    with np.load(m['files']['track']['resolved'], allow_pickle=False) as z:
+        track = {k:z[k] for k in ['base_time','storm_id','base_lat','base_lon','target','target_mask']}
+        issue_intensity = z['track'][:,-1,4:6]*z['track_std'][4:6]+z['track_mean'][4:6]
+    plan = json.loads(Path(m['files']['plan']['resolved']).read_text())
+    if len(plan['rows']) != 1000 or plan['shape'] != [1000,29,121,121] or plan['lead_hours'] != list(range(-48,121,6)):
+        raise ValueError('Expected the verified 1000-window native pressure package, not the six-sample pilot')
+    pressure = np.load(m['files']['pressure']['resolved'], mmap_mode='r')
+    if pressure.shape != (1000,29,121,121):
+        raise ValueError('Native pressure shape mismatch')
+    patches = {}
+    for pi,row in enumerate(plan['rows']):
+        ti = row['track_archive_row']
+        if int(track['base_time'][ti]) != row['issue_ns'] or str(track['storm_id'][ti]) != row['storm_id']:
+            raise ValueError('Native patch/track identity mismatch')
+        patches[ti] = pi
+    first_year = {}
+    years = track['base_time'].astype('datetime64[ns]').astype('datetime64[Y]').astype(int)+1970
+    for sid,y in zip(track['storm_id'],years):
+        first_year[str(sid)] = min(first_year.get(str(sid),9999),int(y))
+    lookup = {(str(s),int(t)):i for i,(s,t) in enumerate(zip(track['storm_id'],track['base_time']))}
+    rows = []
+    for i,ns in enumerate(track['base_time']):
+        sid = str(track['storm_id'][i])
+        y = first_year[sid]
+        split = 'train' if 2000 <= y <= 2021 else 'validation' if 2022 <= y <= 2023 else 'test' if 2024 <= y <= 2025 else None
+        if split is None:
+            continue
+        low,high = {'train':(2000,2021),'validation':(2022,2023),'test':(2024,2025)}[split]
+        bounds = np.array([ns-48*HOUR,ns+120*HOUR],dtype='int64').astype('datetime64[ns]').astype('datetime64[Y]').astype(int)+1970
+        ai = int(np.searchsorted(times,ns))
+        center = [float(track['base_lat'][i]),float(track['base_lon'][i])%360]
+        if bounds[0] < low or bounds[1] > high or ai < 8 or ai+20 >= len(times) or times[ai] != ns:
+            continue
+        if not np.isfinite(center).all() or not (0 < center[0] < 60 and 100 < center[1] < 180):
+            continue
+        previous = lookup.get((sid,int(ns-6*HOUR)))
+        motion = [0.,0.]
+        if previous is not None:
+            old = [float(track['base_lat'][previous]),float(track['base_lon'][previous])%360]
+            if np.isfinite(old).all():
+                motion = [(center[1]-old[1])*111.2*np.cos(np.deg2rad(center[0])),(center[0]-old[0])*111.2]
+        future = [lookup.get((sid,int(ns+j*6*HOUR))) for j in range(1,21)]
+        target_centers = [[float(track['base_lat'][j]),float(track['base_lon'][j])%360] if j is not None else [0.,0.] for j in future]
+        rm = [float(j is not None and np.isfinite(target_centers[k]).all()) for k,j in enumerate(future)]
+        target_centers = np.nan_to_num(target_centers).tolist()
+        wind,p = track['target'][i,:,2],track['target'][i,:,3]
+        wm = track['target_mask'][i,:,2].astype(bool)&np.isfinite(wind)&(wind>=0)&(wind<250)
+        pm = track['target_mask'][i,:,3].astype(bool)&np.isfinite(p)&(p>800)&(p<1100)
+        pi = patches.get(i,-1)
+        if pi >= 0 and plan['rows'][pi]['split'] != split:
+            raise ValueError('Patch split mismatch')
+        issue = issue_intensity[i]
+        iv = [bool(np.isfinite(issue[0]) and 0<=issue[0]<250),bool(np.isfinite(issue[1]) and 800<issue[1]<1100)]
+        rows.append({'split':split,'storm_id':sid,'atlas':ai,'patch':pi,'center':center,'motion':motion,
+                     'issue_intensity':[float(issue[k]) if iv[k] else 0. for k in range(2)],'issue_mask':iv,
+                     'target_centers':target_centers,'route_mask':rm,
+                     'pressure':np.where(pm,p,0).tolist(),'pressure_mask':pm.tolist(),
+                     'vmax':np.where(wm,wind,0).tolist(),'vmax_mask':wm.tolist()})
+    counts = {s:sum(r['split']==s for r in rows) for s in ['train','validation','test']}
+    patch_counts = {s:sum(r['split']==s and r['patch']>=0 for r in rows) for s in counts}
+    if counts['train'] < 10000 or patch_counts != {'train':800,'validation':100,'test':100}:
+        raise ValueError(f'Incomplete combined coverage: {counts}, native patches {patch_counts}')
+    train_times = np.flatnonzero((times.astype('datetime64[ns]').astype('datetime64[Y]').astype(int)+1970>=2000)&
+                                (times.astype('datetime64[ns]').astype('datetime64[Y]').astype(int)+1970<=2021))
+    sums,squares = np.zeros(8),np.zeros(8)
+    n = 0
+    for start in range(0,len(train_times),256):
+        ii = train_times[start:start+256]
+        b = np.concatenate([np.asarray(slp[ii],dtype='float32')[:,None],q[ii].astype('float32')*scale[None,:,None,None]+offset[None,:,None,None]],1).astype('float64')
+        if not np.isfinite(b).all():
+            raise ValueError('Nonfinite coarse training fields')
+        sums += b.sum((0,2,3)); squares += (b*b).sum((0,2,3)); n += len(ii)*25*33
+    mean = sums/n
+    std = np.maximum(np.sqrt(np.maximum(squares/n-mean*mean,0)),1e-4)
+    m.update(rows=rows, plan=plan, qpath=str(qpath), scale=scale.tolist(), offset=offset.tolist(),
+             channels=REUSE_CHANNELS,units=['hPa','m','m/s','m/s','m/s','m/s','m/s','m/s'],
+             global_lat=lat.tolist(),global_lon=lon.tolist(),regional_lat=list(np.linspace(15,-15,121)),
+             regional_lon=list(np.linspace(-15,15,121)),normalization={'mean':mean.tolist(),'std':std.tolist(),'fit_split':'train','end_year':2021},
+             identity=digest(path),counts=counts,patch_counts=patch_counts)
+    print(json.dumps({'all_archive_windows':counts,'native_pressure_windows':patch_counts,'architecture':REUSE_ARCH}),flush=True)
+    return m
+
+
+class ReuseDataset(Dataset):
+    def __init__(self,m,split,training=False):
+        self.m = m
+        self.rows = [r for r in m['rows'] if r['split']==split]
+        self.arrays = None
+
+    def __len__(self):
+        return len(self.rows)
+
+    def __getitem__(self,i):
+        m,row = self.m,self.rows[i]
+        if self.arrays is None:
+            self.arrays = {k:np.load(m['files'][k]['resolved'],mmap_mode='r') for k in ['slp','pressure']}
+            self.arrays['q'] = np.load(m['qpath'],mmap_mode='r')
+            with np.load(m['files']['geography']['resolved'],allow_pickle=False) as geo:
+                self.arrays['land'] = geo['land_fraction']
+                self.arrays['height'] = geo['elevation_m']/8000
+        ai = row['atlas']
+        ii = slice(ai-8,ai+21)
+        coarse = np.concatenate([np.array(self.arrays['slp'][ii],dtype='float32')[:,None],
+              np.array(self.arrays['q'][ii],dtype='float32')*np.array(m['scale'],dtype='float32')[None,:,None,None]+np.array(m['offset'],dtype='float32')[None,:,None,None]],1)
+        mean,std = np.array(m['normalization']['mean'],dtype='float32'),np.array(m['normalization']['std'],dtype='float32')
+        coarse = (coarse-mean[None,:,None,None])/std[None,:,None,None]
+        pi = row['patch']
+        anchor = m['plan']['rows'][pi] if pi>=0 else {'center_lat':round(row['center'][0]*4)/4,'center_lon':round(row['center'][1]*4)/4}
+        lat = anchor['center_lat']+np.linspace(15,-15,121,dtype='float32')
+        lon = anchor['center_lon']+np.linspace(-15,15,121,dtype='float32')
+        yy,xx = np.meshgrid(lat,lon,indexing='ij')
+        y = np.rint((90-yy)*4).astype(int); x = np.rint(xx*4).astype(int)%1440
+        rs = np.stack([yy/90,xx/180-1,self.arrays['land'][y,x],self.arrays['height'][y,x]]).astype('float32')
+        cy,cx = np.meshgrid(m['global_lat'],m['global_lon'],indexing='ij')
+        iy = np.rint((90-cy)*4).astype(int); ix = np.rint(cx*4).astype(int)%1440
+        gs = np.stack([cy/90,cx/180-1,self.arrays['land'][iy,ix],self.arrays['height'][iy,ix]]).astype('float32')
+        detail = np.zeros((29,1,121,121),dtype='float32')
+        if pi>=0:
+            detail[:,0] = (np.array(self.arrays['pressure'][pi],dtype='float32')-mean[0])/std[0]
+            if not np.isfinite(detail).all():
+                raise ValueError('Native pressure contains nonfinite fields')
+        inputs = {'global_history':coarse[:9], 'regional_history':detail[:9],
+                  'global_static':gs,'regional_static':rs,'detail_available':np.array([pi>=0],dtype='float32'),
+                  'center':np.array(row['center'],dtype='float32'),'motion':np.array(row['motion'],dtype='float32'),
+                  'issue_intensity':np.array(row['issue_intensity'],dtype='float32'),'issue_mask':np.array(row['issue_mask'],dtype='float32')}
+        targets = {'global':coarse[9:],'global_mask':np.ones_like(coarse[9:]),
+                   'regional_lat_weight':np.broadcast_to(np.cos(np.deg2rad(lat))[None,None,:,None],(20,1,121,1)).astype('float32'),
+                   'regional':detail[9:],'regional_mask':np.full_like(detail[9:],float(pi>=0)),
+                   'center':np.array(row['target_centers'],dtype='float32'),
+                   'storm_mask':np.array(row['route_mask'],dtype='float32')}
+        for k in ['pressure','pressure_mask','vmax','vmax_mask']:
+            targets[k] = np.array(row[k],dtype='float32')
+        return {k:torch.from_numpy(v.copy()) for k,v in inputs.items()},{k:torch.from_numpy(v.copy()) for k,v in targets.items()}
+
+
+class ReuseForecaster(nn.Module):
+    def __init__(self,m,tiny=False):
+        super().__init__()
+        self.global_time = nn.Conv2d(8*9,8,1)
+        self.regional_time = nn.Conv2d(9,1,1)
+        self.global_operator = FieldOperator(8,8 if tiny else 80,False,1 if tiny else 3,tiny)
+        self.regional_operator = FieldOperator(1,8 if tiny else 88,False,0,tiny)
+        self.parent_fusion = nn.Conv2d(1+8+1,1,1)
+        self.object_score = nn.Conv2d(32+3,1,1)
+        self.intensity = nn.Sequential(nn.Linear(32+3+4,64),nn.GELU(),nn.Linear(64,2))
+        self.register_buffer('mean',torch.tensor(m['normalization']['mean'],dtype=torch.float32)[None,:,None,None])
+        self.register_buffer('std',torch.tensor(m['normalization']['std'],dtype=torch.float32)[None,:,None,None])
+        yy,xx = np.meshgrid(m['global_lat'],m['global_lon'],indexing='ij')
+        self.register_buffer('yy',torch.tensor(yy,dtype=torch.float32)[None])
+        self.register_buffer('xx',torch.tensor(xx,dtype=torch.float32)[None])
+
+    def initial(self,inputs):
+        required = {'global_history','regional_history','global_static','regional_static','detail_available','center','motion','issue_intensity','issue_mask'}
+        if set(inputs)!=required:
+            raise ValueError('Only declared causal inputs are allowed')
+        gh,rh = inputs['global_history'],inputs['regional_history']
+        rs = inputs['regional_static']
+        yy,xx = rs[:,0]*90,(rs[:,1]+1)*180
+        grid = torch.stack([(xx-100)/40-1,1-yy/30],-1)
+        return {'g':gh[:,-1],'r':rh[:,-1],'gc':self.global_time(gh.flatten(1,2)),
+                'rc':self.regional_time(rh.flatten(1,2)),'gs':inputs['global_static'],'rs':rs,
+                'grid':grid,'available':inputs['detail_available'],'center':inputs['center'],
+                'motion':inputs['motion'],'issue':inputs['issue_intensity'],'issue_mask':inputs['issue_mask']}
+
+    def step(self,s):
+        g,features = self.global_operator(s['g'],s['gc'],torch.ones_like(s['g']),s['gs'])
+        valid = (s['grid'].abs()<=1).all(-1)[:,None].to(g.dtype)
+        parent = F.grid_sample(g,s['grid'],align_corners=True,padding_mode='zeros')*valid
+        r = s['r']
+        if bool(s['available'].any()):
+            context = self.parent_fusion(torch.cat([s['rc'],parent,valid],1))
+            r,_ = self.regional_operator(r,context,torch.ones_like(r),s['rs'])
+        physical = g.float()*self.std+self.mean
+        p = physical[:,0]
+        anomaly = p-F.avg_pool2d(F.pad(p[:,None],(2,2,2,2),mode='replicate'),5,1)[:,0]
+        evidence = torch.cat([features.float(),anomaly[:,None]/10,physical[:,2:4]/30],1)
+        lat0,lon0 = s['center'][:,0,None,None],s['center'][:,1,None,None]
+        plat = lat0+s['motion'][:,1,None,None]/111.2
+        plon = lon0+s['motion'][:,0,None,None]/(111.2*lat0.deg2rad().cos().clamp_min(.2))
+        d2 = ((self.yy-plat)*111.2).square()+((self.xx-plon)*111.2*lat0.deg2rad().cos()).square()
+        score = self.object_score(evidence)[:,0]-anomaly/10-d2/(2*600**2)
+        peak = score.flatten(1).argmax(1)
+        iy,ix = torch.arange(25,device=g.device)[None,:,None],torch.arange(33,device=g.device)[None,None,:]
+        local = ((iy-(peak//33)[:,None,None]).abs()<=1)&((ix-(peak%33)[:,None,None]).abs()<=1)
+        pdf = torch.softmax(score.masked_fill(~local,-1e9).flatten(1),1).reshape_as(score)
+        center = torch.stack([(pdf*self.yy).sum((1,2)),(pdf*self.xx).sum((1,2))],1)
+        pooled = (evidence*pdf[:,None]).sum((2,3))
+        scalar = torch.cat([s['issue']/torch.tensor([100.,1000.],device=g.device),s['issue_mask']],1)
+        intensity = self.intensity(torch.cat([pooled,scalar],1))
+        grid_p = (p*pdf).sum((1,2))
+        dy,dx = s['rs'][:,0]*90,(s['rs'][:,1]+1)*180
+        sample = torch.stack([2*(center[:,1]-dx[:,0,0])/30-1,2*(dy[:,0,0]-center[:,0])/30-1],-1)[:,None,None]
+        inside = (sample.abs()<=1).all((1,2,3)) & (s['available'][:,0]>0)
+        detailed_p = F.grid_sample(r.float()*self.std[:,:1]+self.mean[:,:1],sample,align_corners=True)[:,0,0,0]
+        grid_p = torch.where(inside,detailed_p,grid_p)
+        pressure = grid_p-F.softplus(intensity[:,0])*5
+        vmax = s['issue'][:,0]*s['issue_mask'][:,0]+intensity[:,1]*10
+        meanlat = (center[:,0]+s['center'][:,0])/2
+        motion = torch.stack([(center[:,1]-s['center'][:,1])*111.2*meanlat.deg2rad().cos(),(center[:,0]-s['center'][:,0])*111.2],1)
+        return dict(s,g=g,r=r,center=center,motion=motion),{'global':g,'regional':r,'center':center,'pressure':pressure,'vmax':vmax,'grid_pressure':grid_p}
+
+    def forward(self,inputs,steps=20):
+        s = self.initial(inputs)
+        out = []
+        for _ in range(steps):
+            s,o = self.step(s); out.append(o)
+        return {k:torch.stack([o[k] for o in out],1) for k in out[0]}
+
+
+def reuse_main():
+    global ARCHITECTURE, AtmosphereDataset
+    ARCHITECTURE,AtmosphereDataset = REUSE_ARCH,ReuseDataset
+    p = argparse.ArgumentParser(description='v1.2.64 coarse weather + native pressure training; no pilot fallback')
+    p.add_argument('batch',type=int,nargs='?',default=10)
+    p.add_argument('workers',type=int,nargs='?',default=3)
+    p.add_argument('amp',type=int,nargs='?',default=1,choices=[0,1])
+    p.add_argument('--manifest',type=Path,default=ROOT/'data/v164_reuse/manifest.json')
+    persistent = Path('/content/drive/MyDrive/typhoon_predict') if Path('/content').is_dir() else ROOT
+    p.add_argument('--output',type=Path,default=persistent/'training/v164_reuse_pressure')
+    p.add_argument('--epochs',type=int,default=12)
+    p.add_argument('--device',default='auto',choices=['auto','cpu','mps','cuda'])
+    p.add_argument('--preflight',action='store_true')
+    args = p.parse_args()
+    if args.batch<1 or args.workers<0 or args.epochs<1:
+        p.error('Invalid batch/workers/epochs')
+    m = load_reuse(args.manifest)
+    for split in ['train','validation','test']:
+        d = ReuseDataset(m,split)
+        d[0]
+        d[next(i for i,r in enumerate(d.rows) if r['patch']>=0)]
+    if args.preflight:
+        print('PASS combined non-pilot archives and native pressure data. No training started.',flush=True)
+        return
+    if Path('/content').is_dir() and not args.output.resolve().is_relative_to(persistent.resolve()):
+        raise ValueError('Colab checkpoints must persist in typhoon_predict on Drive')
+    device = device_for(args.device)
+    random.seed(164); np.random.seed(164); torch.manual_seed(164)
+    model = ReuseForecaster(m).to(device)
+    print(json.dumps({'version':VERSION,'architecture':REUSE_ARCH,'parameters':sum(x.numel() for x in model.parameters()),'device':str(device),'windows':m['counts'],'native_windows':m['patch_counts'],'output':str(args.output)}),flush=True)
+    optimizer = torch.optim.AdamW(model.parameters(),lr=1e-4,weight_decay=.01)
+    scaler = torch.amp.GradScaler('cuda',enabled=device.type=='cuda' and bool(args.amp))
+    args.output.mkdir(parents=True,exist_ok=True)
+    lock = args.output/'training.lock'
+    fd = os.open(lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY)
+    os.write(fd,json.dumps({'pid':os.getpid(),'host':socket.gethostname()}).encode()); os.close(fd)
+    try:
+        train(model,optimizer,scaler,m,args,device)
+    finally:
+        lock.unlink(missing_ok=True)

training/trackformer_1_2/source/data_preparation/v164_structure_research.md

@@ -0,0 +1,142 @@
+# TrackFormer v1.2.64: field-first atmosphere and cyclone redesign
+
+Date: 2026-09-13. Status: investigated proposal, NOT a trained or validated v164 model.
+No Colab interaction and no training were performed. Diagnostics ran on this Mac's MPS GPU.
+
+## Decision
+
+Change the state representation, atmospheric training coverage, and field/track contract before scaling the current architecture. Do not merely widen v163, remove its tracker, or add more geometric route losses.
+
+The recommended v164 prototype is a global-to-regional, multi-variable atmospheric predictor with a storm-object decoder tied to its generated fields. It must genuinely forecast pressure, not move or paint a pressure template onto a separately predicted route. A stochastic residual extension should follow a verified deterministic baseline, not obscure an input bug.
+
+## What the Tip investigation actually established
+
+Case: 1979-10-12 00 UTC, nine analyses from t-48 through t0, 20 six-hour forecast steps. Checkpoint metadata says epoch 7. The model has **27,179,604 parameters**, despite the `20m` configuration/file label.
+
+Evidence files:
+
+- `diagnostics/v164_tip_audit/report.json`: actual baseline and two controlled inference ablations.
+- `diagnostics/v164_tip_audit/baseline.npz`: unmodified checkpoint tensor outputs.
+- `diagnostics/v164_tip_audit/grib_verification.json`: issue-time channel checks against original NOAA CFSR GRIB.
+- `audit_tip_v163_for_v164.py`: repeatable local diagnostic, with labels excluded from forward inputs.
+
+### Confirmed data/display problems
+
+1. The demo plotted six-hour truth movements as if they were cumulative displacements. All 20 corrected coordinates now match the archived time-tagged realized route within 0.0001 degrees. The true +120 location is 21.5 N, 128.1 E, not approximately 17 N, 138 E. This was a renderer defect, not proof that the training labels were wrong: training already accumulates the step targets.
+2. The forecast renderer used predicted latitude to convert eastward displacement, whereas model field sampling uses an issue-latitude tangent plane. The renderer now uses the model's transform. The training step-coordinate versus fixed-grid geometry remains an architectural consistency issue to remove in v164 using one tested spherical coordinate API.
+3. The displayed v1.1 and v1.2.26 legacy routes match exactly at every lead. The v1.2.26 renderer imports a legacy v62 artifact, not a freshly identified v1.2.26 checkpoint. They are not two independently verified model replays. A provenance warning was added; this audit does not certify their independent skill or modify the global benchmark.
+4. Tip has no SST patch in this demo, so it receives zeros. The training loader filters on `sst_ok`; it does not train this exact missing-data condition. This is a confirmed train/inference contract gap. Its causal contribution requires a matched-source SST replay, not an invented warm ocean patch.
+
+### Checks that passed
+
+- All forward inputs are finite. Weather ranges are plausible: pressure about 972-1031 hPa over history; height about 5116-5922 gpm; winds in m/s. There is no demonstrated Pa/hPa or height/geopotential factor error.
+- The nine weather timestamps stop exactly at the issue time.
+- All eight issue-time map channels were checked against the original GRIB analysis. Pressure differs by at most 0.000059 hPa after float conversion; height and wind differences are zero on the sampled native grid. GRIB time is the requested issue and lead is zero. Older snapshots were timestamp-checked, not all independently re-decoded here.
+- The issue-pressure mask is zero. The grid-pressure fallback therefore follows the training behavior. Missing pressure is not evidence of an incorrectly supplied 870-hPa observation.
+- ONI is intentionally masked in both training and this replay until release-dated vintages exist. An empty ONI dictionary is not an accidental missing feature for this checkpoint.
+
+### Measured model failure
+
+These are forecast-structure diagnostics, not future-field accuracy scores. Core minimum means the lowest grid value within 500 km of the predicted center; the ring is 500-1000 km. That region contains only about 9-13 native grid points in the core.
+
+| Lead | Whole-grid minimum, hPa | Core minimum, hPa | Ring mean minus core minimum, hPa |
+| --- | ---: | ---: | ---: |
+| 0 | 980.425 | 980.425 | 24.993 |
+| 24 | 983.234 | 983.234 | 20.906 |
+| 48 | 987.474 | 987.474 | 16.002 |
+| 72 | 992.260 | 994.568 | 9.411 |
+| 120 | 999.023 | 1008.427 | 2.562 |
+
+The generated route ends near 34.30 N, 139.66 E. The scalar central-pressure head says 992.23 hPa, but the field near that route has no comparably deep resolved low. Some difference between a subgrid scalar and coarse reanalysis is legitimate; the combination of lost core contrast, weakening gradients, and diverging route/field location is the issue.
+
+After correcting the displayed truth and projection, descriptive Tip mean geodesic route error is **677.7 km**, with mean heading error **54.6 degrees**. The stored DeepMind route has 140.1 km mean error on those leads, but uses a different analysis pipeline and this historical case is not established as held out for its pretrained weights. Do not call that a controlled generalization benchmark.
+
+Controlled MPS ablations (same checkpoint/inputs, local-distance approximation for this diagnostic):
+
+| Variant | Mean route error, km | Interpretation |
+| --- | ---: | --- |
+| Original model | 678.1 | Baseline |
+| Learned acceleration forced to zero | 694.9 | Does not repair the failure |
+| Field-tracker correction disabled | 1106.4 | Tracker helps on this case |
+
+The baseline mean tracker correction is about 21.3 km per step. These interventions do NOT isolate every possible cause, but disprove the easy claim that deleting the tracker or acceleration is the demonstrated solution. They are diagnostics, not new tuned models.
+
+### What remains unproved
+
+- A future, matched-source Tip atmospheric verification sequence was not evaluated here; no whole-map Tip MAE claim is made. Some real weakening is expected, so simply requiring a deep low forever would be wrong.
+- CFSR versus the training analysis source is a distribution shift. Finite/range checks do not eliminate it; compare source-matched replays and normalized distributions on many storms.
+- This one storm cannot prove overfitting, an optimal parameter count, or guaranteed improvements from any proposed architecture.
+
+## Why another v163-style network is unlikely to address the main issue
+
+The actual code uses a 25 x 33, 2.5-degree grid with eight variables: MSLP, height at 500 hPa, and winds at 850/500/200 hPa. A multi-scale encoder cannot recover missing fine-scale or thermodynamic information from that grid. The 0.5-degree source already has a relatively weak resolved low (minimum 976.435 hPa); sampling to 2.5 degrees weakens it further to 980.425 hPa. These are grid values, not observed cyclone central pressure.
+
+It predicts bounded pointwise state increments on a fixed regional grid without a global boundary forecast. The two pressure update branches permit at most about 3.52 hPa per six-hour step at a cell (0.50 times the checkpoint pressure standard deviation). This is a potential translation/gradient limitation, not proof that saturation is the observed cause.
+
+It lacks a prognostic humidity/temperature column and evolving ocean coupling. The current physics loss matches derivatives, vorticity, divergence and shear against targets; it is not a numerical conservation-law solver. Increasing that weight cannot supply missing thermodynamics or guarantee physical pressure evolution.
+
+The scalar intensity head, route proposal and field tracker can disagree. Numerous route losses coexist with comparatively small field objectives. Their numerical weights alone do not establish gradient dominance: measure shared-layer gradient norms and conflict before reweighting.
+
+Training uses storm windows that have 120-hour targets and valid SST. That removes many partial lifecycle samples and does not teach general atmospheric evolution from every available analysis time. Parameter scaling leaves these problems intact.
+
+## Proposed architecture and data contract
+
+### 1. Atmospheric state, not pressure-only images
+
+Use a real global 1-degree parent state and a genuine 0.25-degree western-Pacific regional state with a surrounding halo. Start with MSLP, surface pressure, 10-m winds, 2-m temperature, SST, and u/v/T/q/geopotential at 850, 700, 500, 300 and 200 hPa. Include land fraction, orography, solar geometry, availability and age channels. Add ocean heat-content/mixed-layer information only when a causal, consistently covered archive exists.
+
+Use physical units and one canonical regridding/normalization implementation for training, replay and benchmarking. A larger interpolated copy of the current 2.5-degree labels is NOT a high-resolution dataset. Reanalysis does not fully resolve the eye even at 0.25 degrees; retain a separately identified observation-scale intensity output.
+
+Train from 2000 onward on all eligible atmospheric timestamps, including non-storm periods, with predeclared storm-disjoint/year splits. Older years can supplement training only when sources and masks are consistent, and Tip remains excluded. No future reanalysis, best-track values or operational forecast product may enter a rollout input. A global parent generated internally from t0 is a prediction, not a future observation.
+
+### 2. Global-to-regional atmospheric dynamics backbone
+
+Use a spherical multi-resolution graph or spherical neural-operator backbone for the global state, with vertically coupled tokens. It forecasts evolving ridges, troughs and steering winds, not just a global pooled context vector. A regional windowed-attention/ConvNeXt operator consumes the parent forecast, its own prior predicted fields, and lateral boundary state at each step. Decode all atmospheric variables jointly.
+
+Start with supervised six-hour state evolution and multi-step training. A differentiable transport operator can be tested for prognostic quantities with a learned physical-process residual, but do not treat MSLP as a passive scalar or claim conservation from a simple image warp. If implementing a full dynamics solver, use an established tested solver rather than an unverified hand-written approximation.
+
+Do not require a moving cyclone crop for the first prototype: a fixed regional field avoids using true future centers to choose inputs and avoids route-driven template placement. Predicted-center local attention is allowed, but cannot move the output field to force agreement.
+
+### 3. One coupled storm-object and field representation
+
+Maintain a persistent storm-identity token initialized from the observed issue-time storm. Cross-attend to generated pressure, vorticity, wind and warm-core features. Forecast a spatial association distribution over the generated field, retaining multiple candidate lows where necessary. The final route is a subgrid center associated with a generated meteorological object, not an independent trajectory plus a pasted low.
+
+Use a motion prior only as a soft association aid. Avoid a global minimum tracker, and avoid an expectation between two distinct lows. Model cyclone existence, weakening, transition and association confidence explicitly; do not force a tropical vortex to survive after genuine dissipation.
+
+The pressure field remains the atmospheric decoder's raw output. Grid-scale pressure, observation-scale central pressure, and maximum surface wind have different contracts. Train the subgrid intensity decoder against available observations and calibrate its relation to the resolved vortex. Do not force central pressure to equal a coarse cell or claim a head offset creates a resolved eye.
+
+### 4. Conditional probabilistic extension, after the deterministic baseline
+
+Add a spatially coherent stochastic residual to the atmospheric evolution, shared across variables and time, using a conditional flow or FGN-style formulation. Each ensemble member must contain its own full field, storm association, track and intensity. The purpose is to represent uncertain storm positions without averaging several locations into a diffuse low.
+
+Keep the deterministic baseline for ablation. Score members/distributions properly; never choose the best-looking member against future truth. In the demo distinguish a fixed-seed member from the ensemble mean. A smooth ensemble-mean field is not itself proof of a bad probabilistic forecast.
+
+### 5. Training stages and sizes
+
+1. Pretrain atmospheric next-state prediction on non-storm and storm times, then train genuinely free-running 48/120-hour rollouts with predicted lateral boundaries.
+2. Add the storm-object and intensity decoders and joint training. Use field accuracy/structure and storm association losses with logged gradient scales, not ten overlapping route terms by default.
+3. Add stochastic evolution only if deterministic members lose structure under uncertainty, and evaluate calibration as well as sharpness.
+
+Initial trainable target: **40-60M total**, for example a roughly 25-30M global core plus 15-25M regional/object components. These are architecture budgets, not measured parameter counts or confirmed T4 fits. Test the same architecture at approximately 25M, 50M and 100M under matched data/optimization before attributing gains to size. A large global dataset can require substantially more training than previous storm-only runs.
+
+Practical alternative: freeze an existing pretrained global weather backbone and train only the regional/object refinement. This may be the fastest skillful system, but label it a hybrid and disclose its pretrained-data coverage, license and full parameter count. Do not present its accuracy as a standalone TrackFormer win over that same parent. No parent product or remote service should be silently introduced.
+
+## Promotion gates before calling v164 better
+
+- Shared input tests: exact timestamps, field units, channel order, coordinate round trip, longitude wrapping, missingness, normalization and source checksums. Delete future-label tensors from the forward interface and verify predictions are unchanged when verification labels are shuffled.
+- Missing SST: either fetch a verified causal patch or use a masked encoder trained with modality dropout. No unmasked all-zero fallback on an always-present training feature.
+- Genuine field skill: matched-grid area-weighted MSLP MAE/RMSE plus anomaly and gradient error, spectral diagnostics, cyclone-centered pressure contrast and radial profiles, low-center displacement, and co-location with vorticity/winds. Evaluate core and background separately.
+- Route: per-step direction, turning/recurvature timing, cross-track and along-track error, and full-path mean distance. Do not substitute a single terminal-distance score or optimize only appearance.
+- Intensity: separate observed central-pressure/wind errors from gridded MSLP error; keep wind averaging conventions explicit.
+- Multi-storm free rollouts: tropical, recurving, landfalling and dissipating cases; report failure rate and confidence. A persistence baseline must be included.
+- Frozen validation selection, storm-clustered bootstrap uncertainty, and a new untouched test cohort. Tip is now a development diagnostic due repeated inspection; it cannot remain an untouched test merely because it is excluded from gradient training. The repeatedly used 270 cases likewise require an independent final test.
+- Gates must not be tuned to force the DeepMind ranking. Compare the same initialization/verification sources and disclose pretrained train/test overlap where known.
+
+## Research basis and limits
+
+- [GraphCast](https://arxiv.org/abs/2212.12794): useful basis for multi-scale global atmospheric forecasting rather than a storm-only latent backbone.
+- [WeatherNext Cyclones, official explanation](https://deepmind.google/blog/weathernext-ai-model-achieves-breakthrough-in-forecasting-cyclones/): combines global atmospheric prediction with cyclone observations and coherent ensembles. Its reported Mini performance also shows that resolution alone is not a sufficient explanation for our failure. Adopting the design principles does not reproduce its skill or training corpus.
+- [StormCast](https://arxiv.org/abs/2408.10958): supports conditioning regional probabilistic evolution on synoptic variables and evaluating realistic spectra. Its short-range kilometer-scale experiments are not proof of 120-hour western-Pacific cyclone skill.
+- [NeuralGCM](https://www.nature.com/articles/s41586-024-07744-y): supports investigating tested hybrid dynamics and learned physics, not adding an arbitrary pressure-balance penalty and calling it physically guaranteed.
+
+Bottom line: the defensible v164 change is stronger atmospheric evolution plus a genuinely coupled storm representation, with verified data and evaluation contracts. Tip supports investigating this direction; it does not prove that more parameters or a particular new block will win.

training/trackformer_1_2/source/v173/DESIGN.md

@@ -0,0 +1,52 @@
+# v1.2.73: controlled moving-core improvement
+
+Baseline: v168 E3, SHA256
+99ed776097e05ad6df03375465d9618741bed63a4ee57724d3ba98e295039d30.
+The baseline is frozen as an archived reference, not frozen during v173 training.
+
+The 21,452,595-parameter model transfers every baseline parameter. A two-scale
+environment encoder pools physical state, recurrent memory and geographic
+features. Two transformer blocks exchange regional context; cross attention
+returns a correction to the environmental recurrent state. A zero-initialized
+output makes the initial forecast equal the baseline. The moving core continues
+to evolve pressure through relative transport and learned tendencies.
+
+Both objectives matter: spatial pressure evolution and derived storm numbers.
+The existing area-weighted atmospheric, outer-core pressure/gradient, track,
+central-pressure and auxiliary wind losses remain. New masked losses supervise
+six-hour pressure change and displacement against corresponding label changes.
+Future fields and best tracks enter only the objective. Validation always uses
+120 hours; training horizons are 24, 48, 72 then 120 hours. Best selection uses
+validation, never Tip or the displayed benchmark storms.
+
+The route is a pressure association within the moving core; central pressure is
+sampled from that same field at that location. Maximum wind remains an auxiliary
+scalar estimate: MSLP alone does not uniquely determine surface wind. The fixed
+regional rendering is a resampled composite; the core is authoritative for the
+extracted central pressure. Display +0 from the initialized core, and distinguish
+it from raw input analysis. Do not connect raw +0 to conditioned +6.
+
+Deliberately retained limitations: the v168 initialization includes a 100 km
+Gaussian correction using issue-time observed pressure. It is a reconstruction,
+not resolved truth. Fine inner geometry is underdetermined with only 800 native
+training windows. Replacing the initializer, tracker, transport and backbone all
+at once would destroy the controlled baseline. Learned initialization and a
+probabilistic ensemble are later separate ablations, not implemented claims.
+
+Only the verified full existing corpus is accepted: 13949/1041/1195 windows and
+800/100/100 native windows. No new weather downloads. Tip is excluded, and its
+repeatedly inspected forecasts are development diagnostics. Region is Western
+Pacific, not a global weather model. Report native/coarse cases separately and
+validate on untouched storms before calling this an improvement.
+
+Mac Metal tests passed: baseline equivalence before optimization, coarse/native
+four-step finite backward with attention gradients, field-to-pressure equality,
+120h finite rollout, label invariance, rejected future inputs, missing intensity,
+optimizer resume and full sampler coverage. CUDA/T4 and skill remain unverified.
+
+Training command after the existing notebook's setup cell:
+`python v173_pressure_train.py 10 3 1 --microbatch 4`
+The final positional flag is accepted for compatibility; dynamics use FP32.
+Increase physical microbatch only after measuring throughput and memory. Effective
+batch alone does not increase GPU memory. Checkpoints and train.log persist to
+MyDrive/typhoon_predict/training/v173; restarting resumes last.pt.

training/trackformer_1_2/source/v173/baseline_model.py

@@ -0,0 +1,158 @@
+"""Observation-initialized moving pressure state; no independent pressure head."""
+from pathlib import Path
+import sys
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import v165_base as base
+
+VERSION = '1.2.68'
+ARCHITECTURE = 'moving-pressure-core-v168-prototype'
+
+
+def weighted(value, mask):
+    return (value * mask).sum() / mask.expand_as(value).sum().clamp_min(1)
+
+
+class CoreForecaster(base.TransportForecaster):
+    def __init__(self, manifest, tiny=False):
+        super().__init__(manifest, tiny)
+        del self.fine, self.fine_memory, self.wind
+        self.core_net = base.EvolutionNet(1 + 8 + 32 + 4, 3, 8 if tiny else 64, tiny)
+        self.core_memory = base.RecurrentFeatures(9)
+        self.motion_net = nn.Sequential(nn.Linear(32 + 8 + 4, 64), nn.GELU(), nn.Linear(64, 3))
+        nn.init.zeros_(self.motion_net[-1].weight)
+        nn.init.zeros_(self.motion_net[-1].bias)
+        # 20 km internal grid is a reconstruction, not new resolved observations.
+        yy, xx = torch.meshgrid(torch.linspace(640, -640, 65), torch.linspace(-640, 640, 65), indexing='ij')
+        self.register_buffer('east', xx[None])
+        self.register_buffer('north', yy[None])
+        radius = (xx.square() + yy.square()).sqrt()
+        self.register_buffer('taper', ((640-radius)/160).clamp(0, 1)[None, None])
+
+    def coordinates(self, center):
+        lat = center[:, 0, None, None] + self.north / 111.2
+        lon = center[:, 1, None, None] + self.east / (111.2 * center[:, 0, None, None].deg2rad().cos().clamp_min(.2))
+        return lat, lon
+
+    def basin_grid(self, lat, lon):
+        return torch.stack([(lon-100)/40-1, 1-lat/30], -1)
+
+    def core_grid(self, lat, lon, origin):
+        east = (lon-origin[:, 1, None, None])*111.2*origin[:, 0, None, None].deg2rad().cos().clamp_min(.2)
+        north = (lat-origin[:, 0, None, None])*111.2
+        return torch.stack([east/640, -north/640], -1)
+
+    def initial(self, inputs):
+        required = {'global_history','regional_history','global_static','regional_static','detail_available','center','motion','issue_intensity','issue_mask'}
+        if set(inputs) != required:
+            raise ValueError('Only declared past and issue-time inputs are allowed')
+        history = inputs['global_history']
+        lat, lon = self.coordinates(inputs['center'])
+        grid = self.basin_grid(lat, lon)
+        regional = inputs['regional_static']
+        rlat, rlon = regional[:, 0]*90, (regional[:, 1]+1)*180
+        native_grid = torch.stack([2*(lon-rlon[:, :1, :1])/(rlon[:, :1, -1:]-rlon[:, :1, :1])-1,
+                                   2*(lat-rlat[:, :1, :1])/(rlat[:, -1:, :1]-rlat[:, :1, :1])-1], -1)
+        parent = base.sample_field(history[:, -1, :1], grid)
+        available = inputs['detail_available'][:, :, None, None].bool()
+        past = []
+        for i in range(9):
+            coarse = base.sample_field(history[:, i, :1], grid)
+            native = base.sample_field(inputs['regional_history'][:, i], native_grid)
+            past.append(torch.where(available, native, coarse))
+        core = past[-1]
+        observed = (inputs['issue_intensity'][:, 1] - self.mean[0, 0, 0, 0]) / self.std[0, 0, 0, 0]
+        # Only initialization uses an explicit compact core prior. Subsequent
+        # changes are learned field tendencies, not repeated scalar insertion.
+        radius2 = self.east.square() + self.north.square()
+        prior = torch.exp(-radius2/(2*100**2))[:, None] * self.taper
+        difference = observed-core[:, 0, 32, 32]
+        core = core + difference[:, None, None, None]*prior*inputs['issue_mask'][:, 1, None, None, None]
+        return dict(g=history[:, -1], gh=self.coarse_memory.encode(history.flatten(1, 2)),
+                    core=core, ch=self.core_memory.encode(torch.cat(past, 1)),
+                    anomaly=core-parent, origin=inputs['center'], center=inputs['center'], motion=inputs['motion'],
+                    vmax=inputs['issue_intensity'][:, 0], gs=inputs['global_static'], rs=regional,
+                    issue=inputs['issue_intensity'], issue_mask=inputs['issue_mask'])
+
+    def step(self, s):
+        delta, features = self.coarse(torch.cat([s['g'], s['gh'], s['gs']], 1))
+        velocity = self.steering(s['g']) + 15*torch.tanh(delta[:, 8:])
+        departure = base.departure_grid(s['g'], velocity, self.lat, 2.5)
+        g = base.sample_field(s['g'], departure) + .2*torch.tanh(delta[:, :8])
+        gh = self.coarse_memory(base.sample_field(s['gh'], departure), features)
+        at = self.basin_grid(s['center'][:, 0, None, None], s['center'][:, 1, None, None])
+        local = base.sample_field(torch.cat([gh, g], 1), at)[:, :, 0, 0]
+        conditioning = torch.cat([s['motion']/100, s['issue_mask']], 1)
+        tendencies = self.motion_net(torch.cat([local, conditioning], 1))
+        flow = base.sample_field(velocity, at)[:, :, 0, 0]
+        motion = .7*flow*21.6 + .3*s['motion'] + 100*torch.tanh(tendencies[:, :2])
+        origin = s['center'] + torch.stack([motion[:, 1]/111.2,
+                    motion[:, 0]/(111.2*s['center'][:, 0].deg2rad().cos().clamp_min(.2))], 1)
+        lat, lon = self.coordinates(origin)
+        grid = self.basin_grid(lat, lon)
+        environment = base.sample_field(g, grid)
+        static = base.sample_field(s['gs'], grid)
+        # Translate the moving frame without resampling away bulk storm motion.
+        old_lat, old_lon = self.coordinates(s['origin'])
+        old_grid = self.basin_grid(old_lat, old_lon)
+        old_environment = base.sample_field(s['g'], old_grid)
+        rd, rf = self.core_net(torch.cat([s['core'], old_environment, s['ch'], static], 1))
+        local_flow = base.sample_field(velocity, grid) + 5*torch.tanh(rd[:, 1:])
+        relative = local_flow - (motion/21.6)[:, :, None, None]
+        shift = (s['center']-s['origin'])
+        source_lat = old_lat + shift[:, 0, None, None] - relative[:, 1]*21.6/111.2
+        source_lon = old_lon + shift[:, 1, None, None] - relative[:, 0]*21.6/(111.2*old_lat.deg2rad().cos().clamp_min(.2))
+        dep = self.core_grid(source_lat, source_lon, s['origin'])
+        anomaly = base.sample_field(s['anomaly'], dep, 'zeros') + .1*rd[:, :1]
+        core = environment[:, :1] + anomaly*self.taper
+        ch = self.core_memory(base.sample_field(s['ch'], dep, 'zeros'), rf)
+        physical = core*self.std[:, :1]+self.mean[:, :1]
+        # Field-based association, constrained to this storm's local neighborhood.
+        score = -physical[:, 0]/2 - (self.east.square()+self.north.square())/(2*180**2)
+        score = score.masked_fill((self.east.square()+self.north.square()) > 300**2, -1e9)
+        pdf = score.flatten(1).softmax(1).reshape_as(score)
+        center = torch.stack([(pdf*lat).sum((1,2)), (pdf*lon).sum((1,2))], 1)
+        cg = self.core_grid(center[:, 0, None, None], center[:, 1, None, None], origin)
+        pressure = base.sample_field(physical, cg)[:, 0, 0, 0]
+        rlat, rlon = s['rs'][:, 0]*90, (s['rs'][:, 1]+1)*180
+        rg = self.basin_grid(rlat, rlon)
+        sampling = self.core_grid(rlat, rlon, origin)
+        reconstructed = base.sample_field(g[:, :1], rg) + base.sample_field(anomaly*self.taper, sampling, 'zeros')
+        # Resolved basin output remains at source resolution; reconstruction has
+        # separate provenance and is never relabeled as raw coarse analysis.
+        vmax = (s['vmax']+5*tendencies[:, 2]).clamp_min(0)
+        valid = (grid.abs()<=1).all(-1)[:, None]
+        out = dict(global_=g, regional=reconstructed, regional_valid=(rg.abs()<=1).all(-1)[:,None],
+                   core=core, core_lat=lat, core_lon=lon, core_valid=valid,
+                   center=center, pressure=pressure, grid_pressure=pressure, vmax=vmax,
+                   track_valid=(center[:,0]>0)&(center[:,0]<60)&(center[:,1]>100)&(center[:,1]<180),
+                   native_route=torch.ones_like(pressure,dtype=torch.bool),
+                   pressure_tendency=pressure-base.sample_field(s['core']*self.std[:,:1]+self.mean[:,:1],
+                       self.core_grid(s['center'][:,0,None,None],s['center'][:,1,None,None],s['origin']))[:,0,0,0])
+        out['global']=out.pop('global_')
+        return dict(s,g=g,gh=gh,core=core,ch=ch,anomaly=anomaly,origin=origin,center=center,motion=motion,vmax=vmax), out
+
+
+def objective(out, target, inputs, manifest):
+    terms={}
+    area=inputs['global_static'][:,:1].mul(90).deg2rad().cos().clamp_min(0)
+    terms['environment']=weighted(F.smooth_l1_loss(out['global'],target['global'],reduction='none'),area*target['global_mask'])
+    # Reanalysis does not resolve the observed central pressure. Exclude the
+    # inner 150 km from absolute reconstruction targets instead of erasing it.
+    lat,lon=inputs['regional_static'][:,0]*90,(inputs['regional_static'][:,1]+1)*180
+    ct=target['center']
+    d2=((lat-ct[:,0,None,None])*111.2).square()+((lon-ct[:,1,None,None])*111.2*ct[:,0,None,None].deg2rad().cos()).square()
+    mask=target['regional_mask']*out['regional_valid']*(d2>=150**2)[:,None]
+    terms['regional']=weighted(F.smooth_l1_loss(out['regional'],target['regional'],reduction='none'),mask)
+    for axis in (-2,-1):
+        pred=out['regional'].diff(dim=axis);truth=target['regional'].diff(dim=axis)
+        w=mask.narrow(axis,0,pred.shape[axis])*mask.narrow(axis,1,pred.shape[axis])
+        terms['regional']=terms['regional']+.2*weighted((pred-truth).abs(),w)
+    displacement=(out['center']-ct)*torch.stack([torch.full_like(ct[:,0],111.2),111.2*ct[:,0].deg2rad().cos()],1)
+    terms['route']=weighted(F.smooth_l1_loss(displacement/100,torch.zeros_like(displacement),reduction='none'),target['storm_mask'][:,None])
+    terms['pressure']=weighted(F.smooth_l1_loss(out['pressure']/20,target['pressure']/20,reduction='none'),target['pressure_mask'])
+    terms['wind']=weighted(F.smooth_l1_loss(out['vmax']/30,target['vmax']/30,reduction='none'),target['vmax_mask'])
+    return terms['environment']+terms['regional']+.2*terms['route']+.5*terms['pressure']+.05*terms['wind'],terms

training/trackformer_1_2/source/v173/model.py

@@ -0,0 +1,74 @@
+"""v173: moving pressure core with multiscale environmental attention.
+
+The public track and central pressure are extracted from the evolving core.
+Wind is an auxiliary scalar estimate, not a resolved wind field.
+"""
+import torch
+from torch import nn
+from torch.nn import functional as F
+from baseline_model import CoreForecaster as Baseline, objective as baseline_loss, weighted, base
+
+VERSION = '1.2.73'
+ARCHITECTURE = 'v173-moving-core-multiscale-attention'
+
+
+class EnvironmentalAttention(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.project = nn.Conv2d(44, 64, 1)
+        layer = nn.TransformerEncoderLayer(64, 4, 128, dropout=0., batch_first=True,
+                                           norm_first=True)
+        self.encoder = nn.TransformerEncoder(layer, 2, enable_nested_tensor=False)
+        self.query = nn.Linear(32, 64)
+        self.cross = nn.MultiheadAttention(64, 4, dropout=0., batch_first=True)
+        self.output = nn.Linear(64, 32)
+        nn.init.zeros_(self.output.weight)
+        nn.init.zeros_(self.output.bias)
+
+    def forward(self, state):
+        h, w = state['gh'].shape[-2:]
+        features = self.project(torch.cat([state['g'], state['gh'], state['gs']], 1))
+        tokens = torch.cat([F.avg_pool2d(features, kernel_size=size, stride=size,
+                                       ceil_mode=True).flatten(2)
+                            for size in (3, 5)], 2).transpose(1, 2)
+        tokens = self.encoder(tokens)
+        queries = self.query(state['gh'].flatten(2).transpose(1, 2))
+        context, _ = self.cross(queries, tokens, tokens, need_weights=False)
+        return self.output(context).transpose(1, 2).reshape(-1, 32, h, w)
+
+
+class CoreForecaster(Baseline):
+    def __init__(self, manifest, tiny=False):
+        super().__init__(manifest, tiny)
+        # Meshgrid views overlap on CPU; checkpoint loading requires owned storage.
+        self.east = self.east.clone()
+        self.north = self.north.clone()
+        self.context = EnvironmentalAttention()
+
+    def step(self, state):
+        conditioned = dict(state, gh=state['gh'] + self.context(state))
+        next_state, out = super().step(conditioned)
+        out['previous_center'] = state['center']
+        out['previous_pressure'] = out['pressure'] - out['pressure_tendency']
+        return next_state, out
+
+
+def objective(out, target, inputs, manifest):
+    loss, terms = baseline_loss(out, target, inputs, manifest)
+    if 'previous_pressure' in target:
+        mask = target['pressure_mask'] * target['previous_pressure_mask']
+        true_delta = target['pressure'] - target['previous_pressure']
+        terms['pressure_change'] = weighted(F.smooth_l1_loss(
+            out['pressure_tendency']/10, true_delta/10, reduction='none'), mask)
+        loss = loss + .25 * terms['pressure_change']
+    if 'previous_center' in target:
+        center = target['center']
+        scale = torch.stack([torch.full_like(center[:, 0], 111.2),
+                             111.2*center[:, 0].deg2rad().cos()], 1)
+        predicted = (out['center']-out['previous_center'])*scale
+        truth = (center-target['previous_center'])*scale
+        mask = target['storm_mask']*target['previous_storm_mask']
+        terms['motion_change'] = weighted(F.smooth_l1_loss(
+            predicted/100, truth/100, reduction='none'), mask[:, None])
+        loss = loss + .1 * terms['motion_change']
+    return loss, terms

training/trackformer_1_2/source/v173/test_model.py

@@ -0,0 +1,90 @@
+"""Real-data Metal preflight, pressure coupling, gradients and resume."""
+from pathlib import Path
+import tempfile
+import torch
+from model import CoreForecaster, objective, base
+from v173_pressure_train import save, restore, warm_start, batches
+from baseline_model import CoreForecaster as Baseline
+
+
+def main():
+    root=Path(__file__).resolve().parents[1]
+    torch.set_num_threads(4);torch.manual_seed(168)
+    base.EvolutionNet.block=lambda self,module,x:module(x)
+    m=base.load_reuse(root/'data/v164_reuse/manifest.json')
+    assert m['counts']==dict(train=13949,validation=1041,test=1195)
+    assert not any('1979275N06159'==r['storm_id'] for r in m['rows'])
+    model=CoreForecaster(m).to('mps');warm_start(model,root/'v168/runs/mac/epoch_003.pt',m)
+    reference=Baseline(m).to('mps')
+    reference.load_state_dict(torch.load(root/'v168/runs/mac/epoch_003.pt',map_location='cpu',weights_only=False)['model'])
+    reference.eval();model.eval()
+    optimizer=torch.optim.AdamW(model.parameters(),lr=3e-5,weight_decay=.01)
+    data=base.ReuseDataset(m,'train')
+    choices=[next(i for i,r in enumerate(data.rows) if r['patch']<0 and r['issue_mask'][1]),
+             next(i for i,r in enumerate(data.rows) if r['patch']>=0 and r['issue_mask'][1])]
+    for index in choices:
+        x,y=data[index];x={k:v[None].to('mps') for k,v in x.items()}
+        if index==choices[0]:
+            with torch.no_grad():
+                expected=reference(x,1);actual=model(x,1)
+                for key in expected: assert torch.allclose(actual[key],expected[key],atol=1e-5,rtol=1e-5), key
+            print('PASS zero-correction warm start equals v168 E3 field and route',flush=True)
+        model.train()
+        optimizer.zero_grad(set_to_none=True);state=model.initial(x)
+        initial_p=state['core'][:,0,32,32]*model.std[0,0,0,0]+model.mean[0,0,0,0]
+        assert torch.allclose(initial_p,x['issue_intensity'][:,1],atol=1e-3)
+        total=0
+        for lead in range(4):
+            state,out=model.step(state)
+            target={k:v[lead:lead+1].to('mps') for k,v in y.items()}
+            target['previous_pressure']=y['pressure'][lead-1:lead].to('mps') if lead else x['issue_intensity'][:,1]
+            target['previous_pressure_mask']=y['pressure_mask'][lead-1:lead].to('mps') if lead else x['issue_mask'][:,1]
+            target['previous_center']=y['center'][lead-1:lead].to('mps') if lead else x['center']
+            target['previous_storm_mask']=y['storm_mask'][lead-1:lead].to('mps') if lead else torch.ones_like(target['storm_mask'])
+            loss,_=objective(out,target,x,m);total=total+loss/4
+            assert all(bool(torch.isfinite(v).all()) for v in out.values())
+            grid=model.core_grid(out['center'][:,0,None,None],out['center'][:,1,None,None],state['origin'])
+            field_pressure=base.sample_field(out['core']*model.std[:,:1]+model.mean[:,:1],grid)[:,0,0,0]
+            assert torch.equal(field_pressure,out['pressure'])
+        total.backward()
+        assert all(bool(torch.isfinite(p.grad).all()) for p in model.parameters() if p.grad is not None)
+        for layer in [model.core_net.out,model.coarse.out,model.motion_net[-1]]:
+            assert layer.weight.grad is not None and layer.weight.grad.abs().sum()>0
+        assert model.context.output.weight.grad.abs().sum()>0
+        torch.nn.utils.clip_grad_norm_(model.parameters(),1.);optimizer.step()
+        print('PASS real 4-step backward, anchored pressure and field-derived output; native=',bool(x['detail_available'].item()),flush=True)
+    model.eval()
+    with torch.no_grad():
+        out=model(x,20)
+        assert all(bool(torch.isfinite(v).all()) for v in out.values())
+        first=model(x,1)
+        altered={k:v.clone() for k,v in target.items()};altered['center']+=10
+        objective({k:v[:,0] for k,v in first.items()},altered,x,m)
+        again=model(x,1)
+        assert all(torch.equal(first[k],again[k]) for k in first)
+        try:model.initial(dict(x,future_pressure=target['regional']))
+        except ValueError:pass
+        else:raise AssertionError('Future input accepted')
+        missing={k:v.clone() for k,v in x.items()};missing['issue_mask'].zero_();missing['issue_intensity'].zero_()
+        absent=model(missing,1)
+        assert all(bool(torch.isfinite(v).all()) for v in absent.values())
+    print('PASS 120h rollout, label invariance, missing intensity and future-input rejection',flush=True)
+    with tempfile.TemporaryDirectory(dir=root/'v173') as tmp:
+        path=Path(tmp)/'resume.pt';save(path,model,optimizer,m,0,[],100.,dict(window=1,totals=[[1.,1],[1.,1]],batch=10))
+        def update():
+            model.train();optimizer.zero_grad(set_to_none=True)
+            o=model(x,1);loss,_=objective({k:v[:,0] for k,v in o.items()},target,x,m)
+            loss.backward();torch.nn.utils.clip_grad_norm_(model.parameters(),1.);optimizer.step()
+            return model.core_net.out.weight.detach().clone()
+        expected=update();payload=restore(path,model,optimizer,m);actual=update()
+        assert torch.allclose(expected,actual,atol=1e-6,rtol=1e-5)
+        assert payload['progress']['window']==1
+    indices=base.training_indices(data.rows,1)
+    grouped=list(batches(indices,data.rows,10,2))
+    assert sorted(i for group,_ in grouped for part in group for i in part)==sorted(indices)
+    assert set(indices)==set(range(len(data)))
+    print('PASS checkpoint optimizer resume and full dataset coverage',flush=True)
+    print('parameters=',sum(p.numel() for p in model.parameters()),flush=True)
+
+
+if __name__=='__main__':main()

training/trackformer_1_2/source/v173/v165_base.py

@@ -0,0 +1,657 @@
+#!/usr/bin/env python3
+"""Standalone v1.2.65. Existing full archives; no web downloads or pilot fallback."""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import random
+import socket
+import time
+from contextlib import nullcontext
+
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import functional as F
+from torch.utils.checkpoint import checkpoint
+from torch.utils.data import Dataset, DataLoader
+
+ROOT = Path(__file__).resolve().parent
+HOUR = 3_600_000_000_000
+
+def digest(path):
+    h = hashlib.sha256()
+    with Path(path).open("rb") as f:
+        for block in iter(lambda: f.read(8 * 1024**2), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def atomic_json(path, data):
+    path = Path(path)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(json.dumps(data, indent=2, allow_nan=False) + "\n")
+    tmp.replace(path)
+
+
+def atomic_checkpoint(path, data):
+    path = Path(path)
+    tmp = path.with_suffix(".tmp")
+    with tmp.open("wb") as f:
+        torch.save(data, f)
+        f.flush()
+        os.fsync(f.fileno())
+    tmp.replace(path)
+
+
+def device_for(name):
+    if name == "auto":
+        name = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
+    if name == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("CUDA unavailable in this Python. Install a CUDA PyTorch wheel before training.")
+    if name == "mps" and not torch.backends.mps.is_available():
+        raise RuntimeError("MPS requested but unavailable")
+    return torch.device(name)
+
+
+"""Embedded in the standalone v164 trainer: coarse archive plus native MSLP patches."""
+REUSE_ARCH = 'wp-coarse8-native-pressure1-v164'
+REUSE_CHANNELS = ['mslp', 'hgt500', 'uwnd850', 'vwnd850', 'uwnd500', 'vwnd500', 'uwnd200', 'vwnd200']
+
+
+def load_reuse(path):
+    path = Path(path)
+    if not path.is_file():
+        raise FileNotFoundError('Combined dataset missing. Run the updated Drive setup cell first: '+str(path))
+    m = json.loads(path.read_text())
+    if m.get('schema') != 'v164-reuse-pressure-v1' or m.get('pilot', True):
+        raise ValueError('Combined non-pilot archive required; no pilot fallback')
+    for name, entry in m['files'].items():
+        p = path.parent/entry['path']
+        print('Checking dataset file:', name, flush=True)
+        if digest(p) != entry['sha256']:
+            raise ValueError('Dataset checksum mismatch: '+name)
+        entry['resolved'] = str(p)
+    with np.load(m['files']['basin']['resolved'], allow_pickle=False) as z:
+        if z['channels'].tolist() != REUSE_CHANNELS[1:]:
+            raise ValueError('Coarse channel order mismatch')
+        times, lat, lon = z['time'], z['lat'], z['lon']
+        q = z['q']
+        scale, offset = z['scale'], z['offset']
+    if q.shape != (len(times),7,25,33) or not np.all(np.diff(times) == 6*HOUR):
+        raise ValueError('Coarse grid/time mismatch')
+    qpath = path.parent/'basin_q_verified.npy'
+    # Refresh the compact worker mmap from the checksum-verified source every preflight.
+    temporary = qpath.with_suffix('.pending.npy')
+    np.save(temporary, q)
+    os.replace(temporary, qpath)
+    slp = np.load(m['files']['slp']['resolved'], mmap_mode='r')
+    if slp.shape != (len(times),25,33) or not np.isfinite(slp).all():
+        raise ValueError('Coarse pressure coverage invalid')
+    with np.load(m['files']['track']['resolved'], allow_pickle=False) as z:
+        track = {k:z[k] for k in ['base_time','storm_id','base_lat','base_lon','target','target_mask']}
+        issue_intensity = z['track'][:,-1,4:6]*z['track_std'][4:6]+z['track_mean'][4:6]
+    plan = json.loads(Path(m['files']['plan']['resolved']).read_text())
+    if len(plan['rows']) != 1000 or plan['shape'] != [1000,29,121,121] or plan['lead_hours'] != list(range(-48,121,6)):
+        raise ValueError('Expected the verified 1000-window native pressure package, not the six-sample pilot')
+    pressure = np.load(m['files']['pressure']['resolved'], mmap_mode='r')
+    if pressure.shape != (1000,29,121,121):
+        raise ValueError('Native pressure shape mismatch')
+    patches = {}
+    for pi,row in enumerate(plan['rows']):
+        ti = row['track_archive_row']
+        if int(track['base_time'][ti]) != row['issue_ns'] or str(track['storm_id'][ti]) != row['storm_id']:
+            raise ValueError('Native patch/track identity mismatch')
+        patches[ti] = pi
+    first_year = {}
+    years = track['base_time'].astype('datetime64[ns]').astype('datetime64[Y]').astype(int)+1970
+    for sid,y in zip(track['storm_id'],years):
+        first_year[str(sid)] = min(first_year.get(str(sid),9999),int(y))
+    lookup = {(str(s),int(t)):i for i,(s,t) in enumerate(zip(track['storm_id'],track['base_time']))}
+    rows = []
+    for i,ns in enumerate(track['base_time']):
+        sid = str(track['storm_id'][i])
+        y = first_year[sid]
+        split = 'train' if 2000 <= y <= 2021 else 'validation' if 2022 <= y <= 2023 else 'test' if 2024 <= y <= 2025 else None
+        if split is None:
+            continue
+        low,high = {'train':(2000,2021),'validation':(2022,2023),'test':(2024,2025)}[split]
+        bounds = np.array([ns-48*HOUR,ns+120*HOUR],dtype='int64').astype('datetime64[ns]').astype('datetime64[Y]').astype(int)+1970
+        ai = int(np.searchsorted(times,ns))
+        center = [float(track['base_lat'][i]),float(track['base_lon'][i])%360]
+        if bounds[0] < low or bounds[1] > high or ai < 8 or ai+20 >= len(times) or times[ai] != ns:
+            continue
+        if not np.isfinite(center).all() or not (0 < center[0] < 60 and 100 < center[1] < 180):
+            continue
+        previous = lookup.get((sid,int(ns-6*HOUR)))
+        motion = [0.,0.]
+        if previous is not None:
+            old = [float(track['base_lat'][previous]),float(track['base_lon'][previous])%360]
+            if np.isfinite(old).all():
+                motion = [(center[1]-old[1])*111.2*np.cos(np.deg2rad(center[0])),(center[0]-old[0])*111.2]
+        future = [lookup.get((sid,int(ns+j*6*HOUR))) for j in range(1,21)]
+        target_centers = [[float(track['base_lat'][j]),float(track['base_lon'][j])%360] if j is not None else [0.,0.] for j in future]
+        rm = [float(j is not None and np.isfinite(target_centers[k]).all()) for k,j in enumerate(future)]
+        target_centers = np.nan_to_num(target_centers).tolist()
+        wind,p = track['target'][i,:,2],track['target'][i,:,3]
+        wm = track['target_mask'][i,:,2].astype(bool)&np.isfinite(wind)&(wind>=0)&(wind<250)
+        pm = track['target_mask'][i,:,3].astype(bool)&np.isfinite(p)&(p>800)&(p<1100)
+        pi = patches.get(i,-1)
+        if pi >= 0 and plan['rows'][pi]['split'] != split:
+            raise ValueError('Patch split mismatch')
+        issue = issue_intensity[i]
+        iv = [bool(np.isfinite(issue[0]) and 0<=issue[0]<250),bool(np.isfinite(issue[1]) and 800<issue[1]<1100)]
+        rows.append({'split':split,'storm_id':sid,'atlas':ai,'patch':pi,'center':center,'motion':motion,
+                     'issue_intensity':[float(issue[k]) if iv[k] else 0. for k in range(2)],'issue_mask':iv,
+                     'target_centers':target_centers,'route_mask':rm,
+                     'pressure':np.where(pm,p,0).tolist(),'pressure_mask':pm.tolist(),
+                     'vmax':np.where(wm,wind,0).tolist(),'vmax_mask':wm.tolist()})
+    counts = {s:sum(r['split']==s for r in rows) for s in ['train','validation','test']}
+    patch_counts = {s:sum(r['split']==s and r['patch']>=0 for r in rows) for s in counts}
+    if counts['train'] < 10000 or patch_counts != {'train':800,'validation':100,'test':100}:
+        raise ValueError(f'Incomplete combined coverage: {counts}, native patches {patch_counts}')
+    train_times = np.flatnonzero((times.astype('datetime64[ns]').astype('datetime64[Y]').astype(int)+1970>=2000)&
+                                (times.astype('datetime64[ns]').astype('datetime64[Y]').astype(int)+1970<=2021))
+    sums,squares = np.zeros(8),np.zeros(8)
+    n = 0
+    for start in range(0,len(train_times),256):
+        ii = train_times[start:start+256]
+        b = np.concatenate([np.asarray(slp[ii],dtype='float32')[:,None],q[ii].astype('float32')*scale[None,:,None,None]+offset[None,:,None,None]],1).astype('float64')
+        if not np.isfinite(b).all():
+            raise ValueError('Nonfinite coarse training fields')
+        sums += b.sum((0,2,3)); squares += (b*b).sum((0,2,3)); n += len(ii)*25*33
+    mean = sums/n
+    std = np.maximum(np.sqrt(np.maximum(squares/n-mean*mean,0)),1e-4)
+    m.update(rows=rows, plan=plan, qpath=str(qpath), scale=scale.tolist(), offset=offset.tolist(),
+             channels=REUSE_CHANNELS,units=['hPa','m','m/s','m/s','m/s','m/s','m/s','m/s'],
+             global_lat=lat.tolist(),global_lon=lon.tolist(),regional_lat=list(np.linspace(15,-15,121)),
+             regional_lon=list(np.linspace(-15,15,121)),normalization={'mean':mean.tolist(),'std':std.tolist(),'fit_split':'train','end_year':2021},
+             identity=digest(path),counts=counts,patch_counts=patch_counts)
+    print(json.dumps({'all_archive_windows':counts,'native_pressure_windows':patch_counts,'architecture':REUSE_ARCH}),flush=True)
+    return m
+
+
+class ReuseDataset(Dataset):
+    def __init__(self,m,split,training=False):
+        self.m = m
+        self.rows = [r for r in m['rows'] if r['split']==split]
+        self.arrays = None
+
+    def __len__(self):
+        return len(self.rows)
+
+    def __getitem__(self,i):
+        m,row = self.m,self.rows[i]
+        if self.arrays is None:
+            self.arrays = {k:np.load(m['files'][k]['resolved'],mmap_mode='r') for k in ['slp','pressure']}
+            self.arrays['q'] = np.load(m['qpath'],mmap_mode='r')
+            with np.load(m['files']['geography']['resolved'],allow_pickle=False) as geo:
+                self.arrays['land'] = geo['land_fraction']
+                self.arrays['height'] = geo['elevation_m']/8000
+        ai = row['atlas']
+        ii = slice(ai-8,ai+21)
+        coarse = np.concatenate([np.array(self.arrays['slp'][ii],dtype='float32')[:,None],
+              np.array(self.arrays['q'][ii],dtype='float32')*np.array(m['scale'],dtype='float32')[None,:,None,None]+np.array(m['offset'],dtype='float32')[None,:,None,None]],1)
+        mean,std = np.array(m['normalization']['mean'],dtype='float32'),np.array(m['normalization']['std'],dtype='float32')
+        coarse = (coarse-mean[None,:,None,None])/std[None,:,None,None]
+        pi = row['patch']
+        anchor = m['plan']['rows'][pi] if pi>=0 else {'center_lat':round(row['center'][0]*4)/4,'center_lon':round(row['center'][1]*4)/4}
+        lat = anchor['center_lat']+np.linspace(15,-15,121,dtype='float32')
+        lon = anchor['center_lon']+np.linspace(-15,15,121,dtype='float32')
+        yy,xx = np.meshgrid(lat,lon,indexing='ij')
+        y = np.rint((90-yy)*4).astype(int); x = np.rint(xx*4).astype(int)%1440
+        rs = np.stack([yy/90,xx/180-1,self.arrays['land'][y,x],self.arrays['height'][y,x]]).astype('float32')
+        cy,cx = np.meshgrid(m['global_lat'],m['global_lon'],indexing='ij')
+        iy = np.rint((90-cy)*4).astype(int); ix = np.rint(cx*4).astype(int)%1440
+        gs = np.stack([cy/90,cx/180-1,self.arrays['land'][iy,ix],self.arrays['height'][iy,ix]]).astype('float32')
+        detail = np.zeros((29,1,121,121),dtype='float32')
+        if pi>=0:
+            detail[:,0] = (np.array(self.arrays['pressure'][pi],dtype='float32')-mean[0])/std[0]
+            if not np.isfinite(detail).all():
+                raise ValueError('Native pressure contains nonfinite fields')
+        inputs = {'global_history':coarse[:9], 'regional_history':detail[:9],
+                  'global_static':gs,'regional_static':rs,'detail_available':np.array([pi>=0],dtype='float32'),
+                  'center':np.array(row['center'],dtype='float32'),'motion':np.array(row['motion'],dtype='float32'),
+                  'issue_intensity':np.array(row['issue_intensity'],dtype='float32'),'issue_mask':np.array(row['issue_mask'],dtype='float32')}
+        targets = {'global':coarse[9:],'global_mask':np.ones_like(coarse[9:]),
+                   'regional_lat_weight':np.broadcast_to(np.cos(np.deg2rad(lat))[None,None,:,None],(20,1,121,1)).astype('float32'),
+                   'regional':detail[9:],'regional_mask':np.full_like(detail[9:],float(pi>=0)),
+                   'center':np.array(row['target_centers'],dtype='float32'),
+                   'storm_mask':np.array(row['route_mask'],dtype='float32')}
+        for k in ['pressure','pressure_mask','vmax','vmax_mask']:
+            targets[k] = np.array(row[k],dtype='float32')
+        return {k:torch.from_numpy(v.copy()) for k,v in inputs.items()},{k:torch.from_numpy(v.copy()) for k,v in targets.items()}
+
+
+"""v165 implementation, embedded with verified archive readers by the builder."""
+VERSION = '1.2.65'
+ARCHITECTURE = REUSE_ARCH = 'wp-causal-transport-evolution-field-tracker-v165'
+TRAIN_HORIZONS = [4, 8, 12, 20]
+
+
+def sample_field(field, grid, padding='border'):
+    # Geometry and interpolation stay FP32, including under CUDA autocast.
+    with torch.autocast(device_type=field.device.type, enabled=False):
+        return F.grid_sample(field.float(), grid.float(), align_corners=True,
+                             mode='bilinear', padding_mode=padding)
+
+
+def identity_grid(field):
+    h, w = field.shape[-2:]
+    yy, xx = torch.meshgrid(torch.linspace(-1, 1, h, device=field.device),
+                            torch.linspace(-1, 1, w, device=field.device), indexing='ij')
+    return torch.stack([xx, yy], -1)[None].expand(field.shape[0], -1, -1, -1)
+
+
+def departure_grid(field, velocity, latitude, spacing):
+    # East/north m/s -> backward departure coordinates on a north-to-south grid.
+    h, w = field.shape[-2:]
+    u, v = velocity.float().unbind(1)
+    dx = u * 21.6 / (111.2 * latitude.float().deg2rad().cos().clamp_min(.2) * spacing)
+    dy = -v * 21.6 / (111.2 * spacing)
+    return identity_grid(field) - torch.stack([2*dx/(w-1), 2*dy/(h-1)], -1)
+
+
+class TransportBlock(nn.Module):
+    def __init__(self, width):
+        super().__init__()
+        self.net = nn.Sequential(nn.Conv2d(width, width, 5, padding=2, groups=width),
+                                 nn.GroupNorm(8, width), nn.Conv2d(width, width*4, 1),
+                                 nn.GELU(), nn.Conv2d(width*4, width, 1))
+        self.scale = nn.Parameter(torch.full((1, width, 1, 1), .01))
+
+    def forward(self, x):
+        return x + self.scale * self.net(x)
+
+
+class EvolutionNet(nn.Module):
+    def __init__(self, channels, outputs, base=72, tiny=False):
+        super().__init__()
+        widths = [base, base*2, base*4, base*6]
+        depths = [1]*4 if tiny else [2, 2, 4, 4]
+        self.stem = nn.Conv2d(channels, base, 3, padding=1)
+        self.enc = nn.ModuleList(nn.Sequential(*[TransportBlock(w) for _ in range(d)])
+                                 for w, d in zip(widths, depths))
+        self.down = nn.ModuleList(nn.Conv2d(a, b, 3, stride=2, padding=1)
+                                  for a, b in zip(widths, widths[1:]))
+        self.up = nn.ModuleList(nn.Conv2d(widths[i+1], widths[i], 1) for i in (2, 1, 0))
+        self.dec = nn.ModuleList(TransportBlock(widths[i]) for i in (2, 1, 0))
+        self.out = nn.Conv2d(base, outputs, 1)
+        self.features = nn.Conv2d(base, 32, 1)
+        nn.init.zeros_(self.out.weight)
+        nn.init.zeros_(self.out.bias)
+
+    def block(self, module, x):
+        return checkpoint(module, x, use_reentrant=False) if self.training and torch.is_grad_enabled() else module(x)
+
+    def forward(self, x):
+        x = self.stem(x)
+        skips = []
+        for i, layer in enumerate(self.enc):
+            x = self.block(layer, x)
+            skips.append(x)
+            if i < 3:
+                x = self.down[i](x)
+        for up, layer, skip in zip(self.up, self.dec, reversed(skips[:-1])):
+            x = F.interpolate(up(x), size=skip.shape[-2:], mode='bilinear', align_corners=False)+skip
+            x = self.block(layer, x)
+        return self.out(x).float(), self.features(x).float()
+
+
+class RecurrentFeatures(nn.Module):
+    def __init__(self, history_channels):
+        super().__init__()
+        self.encode = nn.Sequential(nn.Conv2d(history_channels, 32, 3, padding=1),
+                                    nn.GELU(), TransportBlock(32))
+        self.gates = nn.Conv2d(64, 64, 3, padding=1)
+        self.candidate = nn.Conv2d(64, 32, 3, padding=1)
+
+    def forward(self, old, features):
+        reset, update = torch.sigmoid(self.gates(torch.cat([old, features], 1))).chunk(2, 1)
+        proposal = torch.tanh(self.candidate(torch.cat([old*reset, features], 1)))
+        return ((1-update)*old + update*proposal).float()
+
+
+def track_field(pressure, lat, lon, prior, domain=None):
+    """Associate a local pressure minimum; no independent learned route head."""
+    lat0, lon0 = prior[:, 0, None, None], prior[:, 1, None, None]
+    distance2 = ((lat-lat0)*111.2).square()+((lon-lon0)*111.2*lat0.deg2rad().cos()).square()
+    candidate = distance2 <= 650**2
+    if domain is not None:
+        candidate = candidate & domain
+    score = -pressure/3 - distance2/(2*650**2)
+    peak = score.masked_fill(~candidate, -1e9).flatten(1).argmax(1)
+    h, w = pressure.shape[-2:]
+    y, x = torch.arange(h, device=pressure.device)[None, :, None], torch.arange(w, device=pressure.device)[None, None, :]
+    local = ((y-(peak//w)[:, None, None]).abs() <= 1) & ((x-(peak%w)[:, None, None]).abs() <= 1) & candidate
+    pdf = torch.softmax(score.masked_fill(~local, -1e9).flatten(1), 1).reshape_as(score)
+    center = torch.stack([(pdf*lat).sum((1, 2)), (pdf*lon).sum((1, 2))], 1)
+    grid = torch.stack([2*(center[:, 1]-lon[:, 0, 0])/(lon[:, 0, -1]-lon[:, 0, 0])-1,
+                        2*(center[:, 0]-lat[:, 0, 0])/(lat[:, -1, 0]-lat[:, 0, 0])-1], -1)[:, None, None]
+    central = sample_field(pressure[:, None], grid)[:, 0, 0, 0]
+    annulus = (distance2 >= 300**2) & (distance2 <= 650**2)
+    background = (pressure*annulus).sum((1, 2))/annulus.sum((1, 2)).clamp_min(1)
+    interior = (peak//w > 0) & (peak//w < h-1) & (peak%w > 0) & (peak%w < w-1)
+    valid = candidate.flatten(1).any(1) & interior & (background-central > 1.)
+    return center, central, valid, background-central
+
+
+class TransportForecaster(nn.Module):
+    def __init__(self, manifest, tiny=False):
+        super().__init__()
+        base = 8 if tiny else 72
+        self.coarse_memory, self.fine_memory = RecurrentFeatures(72), RecurrentFeatures(9)
+        self.coarse = EvolutionNet(8+32+4, 8+2, base, tiny)
+        self.fine = EvolutionNet(1+8+32+4+1, 1+2, base, tiny)
+        self.steering_logits = nn.Parameter(torch.tensor([.4, .4, .2]).log())
+        # Wind intensity is explicitly a scalar estimate, not a resolved 10-m wind map.
+        self.wind = nn.Sequential(nn.Linear(32+2, 64), nn.GELU(), nn.Linear(64, 1))
+        self.register_buffer('mean', torch.tensor(manifest['normalization']['mean'], dtype=torch.float32)[None, :, None, None])
+        self.register_buffer('std', torch.tensor(manifest['normalization']['std'], dtype=torch.float32)[None, :, None, None])
+        yy, xx = np.meshgrid(manifest['global_lat'], manifest['global_lon'], indexing='ij')
+        self.register_buffer('lat', torch.tensor(yy, dtype=torch.float32)[None])
+        self.register_buffer('lon', torch.tensor(xx, dtype=torch.float32)[None])
+
+    def initial(self, inputs):
+        required = {'global_history', 'regional_history', 'global_static', 'regional_static',
+                    'detail_available', 'center', 'motion', 'issue_intensity', 'issue_mask'}
+        if set(inputs) != required:
+            raise ValueError('Only declared issue-time and historical inputs are allowed')
+        gh, rh, rs = inputs['global_history'], inputs['regional_history'], inputs['regional_static']
+        grid = torch.stack([((rs[:, 1]+1)*180-100)/40-1, 1-rs[:, 0]*3], -1)
+        parent = sample_field(gh[:, -1, :1], grid)
+        available = inputs['detail_available'][:, :, None, None]
+        r = torch.where(available.bool(), rh[:, -1], parent)
+        return dict(g=gh[:, -1], r=r, gh=self.coarse_memory.encode(gh.flatten(1, 2)).float(),
+                    rh=self.fine_memory.encode(rh.flatten(1, 2)).float(), gs=inputs['global_static'], rs=rs,
+                    grid=grid, available=available, anchor=(r-parent)*available,
+                    coordinates=identity_grid(r).permute(0, 3, 1, 2), source=torch.zeros_like(r),
+                    center=inputs['center'], motion=inputs['motion'], issue=inputs['issue_intensity'],
+                    issue_mask=inputs['issue_mask'])
+
+    def steering(self, g):
+        physical = g.float()*self.std+self.mean
+        winds = physical[:, 2:].reshape(g.shape[0], 3, 2, *g.shape[-2:])
+        return (winds*torch.softmax(self.steering_logits, 0)[None, :, None, None, None]).sum(1)
+
+    def step(self, s):
+        delta, features = self.coarse(torch.cat([s['g'], s['gh'], s['gs']], 1))
+        velocity = self.steering(s['g']) + 15*torch.tanh(delta[:, 8:])
+        departure = departure_grid(s['g'], velocity, self.lat, 2.5)
+        g = sample_field(s['g'], departure) + .2*torch.tanh(delta[:, :8])
+        gh = self.coarse_memory(sample_field(s['gh'], departure), features)
+        parent = sample_field(g, s['grid'])
+        fine_velocity = sample_field(velocity, s['grid'])
+        r, rh, coordinates, source = s['r'], s['rh'], s['coordinates'], s['source']
+        parent_valid = (s['grid'].abs() <= 1).all(-1)[:, None].float()
+        if bool(s['available'].any()):
+            rd, rf = self.fine(torch.cat([r, parent, rh, s['rs'], parent_valid], 1))
+            fine_velocity = fine_velocity + 10*torch.tanh(rd[:, 1:])
+            dep = departure_grid(r, fine_velocity, s['rs'][:, 0]*90, .25)
+            # Compose material coordinates and sample the ORIGINAL anomaly once per lead.
+            # This avoids repeatedly interpolating away its core. Learned source terms
+            # can strengthen, weaken or deform it; survival is not hard-coded.
+            displacement = coordinates-identity_grid(r).permute(0, 3, 1, 2)
+            coordinates = dep.permute(0, 3, 1, 2)+sample_field(displacement, dep)
+            source = sample_field(source, dep, 'zeros') + .2*torch.tanh(rd[:, :1])
+            anomaly = sample_field(s['anchor'], coordinates.permute(0, 2, 3, 1), 'zeros')+source
+            proposed = parent[:, :1]+anomaly*parent_valid
+            r = torch.where(s['available'].bool(), proposed, parent[:, :1])
+            rh = self.fine_memory(sample_field(rh, dep), rf)
+        else:
+            r = parent[:, :1]
+        # Association prior uses only predicted circulation, never a future center.
+        at = torch.stack([(s['center'][:, 1]-100)/40-1, 1-s['center'][:, 0]/30], -1)[:, None, None]
+        steering = sample_field(velocity, at)[:, :, 0, 0]
+        displacement_km = .7*steering*21.6 + .3*s['motion']
+        prior = s['center']+torch.stack([displacement_km[:, 1]/111.2,
+                    displacement_km[:, 0]/(111.2*s['center'][:, 0].deg2rad().cos().clamp_min(.2))], 1)
+        gp, rp = (g*self.std+self.mean)[:, 0], (r*self.std[:, :1]+self.mean[:, :1])[:, 0]
+        coarse_center, coarse_p, coarse_ok, coarse_depth = track_field(gp, self.lat, self.lon, prior)
+        fine_lat, fine_lon = s['rs'][:, 0]*90, (s['rs'][:, 1]+1)*180
+        fine_center, fine_p, fine_ok, fine_depth = track_field(rp, fine_lat, fine_lon, prior, parent_valid[:, 0].bool())
+        inside = (prior[:, 0] < fine_lat[:, 0, 0]) & (prior[:, 0] > fine_lat[:, -1, 0]) & \
+                 (prior[:, 1] > fine_lon[:, 0, 0]) & (prior[:, 1] < fine_lon[:, 0, -1])
+        inside = inside & (prior[:, 0] >= 0) & (prior[:, 0] <= 60) & (prior[:, 1] >= 100) & (prior[:, 1] <= 180)
+        use_fine = s['available'][:, 0, 0, 0].bool() & inside
+        center = torch.where(use_fine[:, None], fine_center, coarse_center)
+        pressure = torch.where(use_fine, fine_p, coarse_p)
+        ok = torch.where(use_fine, fine_ok, coarse_ok)
+        wind_features = torch.cat([gh.mean((2, 3)), s['issue'][:, :1]/100, s['issue_mask'][:, :1]], 1)
+        vmax = F.softplus(self.wind(wind_features)[:, 0])*30
+        motion = torch.stack([(center[:, 1]-s['center'][:, 1])*111.2*((center[:, 0]+s['center'][:, 0])/2).deg2rad().cos(),
+                              (center[:, 0]-s['center'][:, 0])*111.2], 1)
+        out = dict(global_=g, regional=r, center=center, pressure=pressure, grid_pressure=pressure,
+                   vmax=vmax, track_valid=ok, native_route=use_fine, regional_valid=parent_valid.bool(),
+                   pressure_depth=torch.where(use_fine, fine_depth, coarse_depth),
+                   global_velocity=velocity, regional_velocity=fine_velocity)
+        out['global'] = out.pop('global_')
+        return dict(s, g=g, r=r, gh=gh, rh=rh, coordinates=coordinates, source=source,
+                    center=center, motion=motion), out
+
+    def forward(self, inputs, steps=20):
+        state, outputs = self.initial(inputs), []
+        for _ in range(steps):
+            state, output = self.step(state)
+            outputs.append(output)
+        return {k: torch.stack([o[k] for o in outputs], 1) for k in outputs[0]}
+
+
+def weighted_mean(value, weight):
+    return (value*weight).sum()/weight.expand_as(value).sum().clamp_min(1)
+
+
+def objective165(output, target, inputs, manifest):
+    terms = {}
+    for key in ('global', 'regional'):
+        pred, truth, mask = output[key].float(), target[key].float(), target[key+'_mask'].float()
+        if key == 'regional':
+            mask = mask*output['regional_valid']
+        latitude = inputs['global_static' if key == 'global' else 'regional_static'][:, :1]*90
+        area = latitude.deg2rad().cos().clamp_min(0)*mask
+        terms[key] = weighted_mean(F.smooth_l1_loss(pred, truth, reduction='none'), area)
+        for axis in (-2, -1):
+            a, b = pred.diff(dim=axis), truth.diff(dim=axis)
+            w = area.narrow(axis, 0, a.shape[axis])
+            terms[key] = terms[key]+.2*weighted_mean((a-b).abs(), w)
+    # Labels localize supervision only. They are never passed to initial()/step().
+    lat, lon = inputs['regional_static'][:, 0]*90, (inputs['regional_static'][:, 1]+1)*180
+    ct = target['center']
+    dist2 = ((lat-ct[:, 0, None, None])*111.2).square()+ \
+            ((lon-ct[:, 1, None, None])*111.2*ct[:, 0, None, None].deg2rad().cos()).square()
+    region = (dist2 < 600**2)[:, None]*target['regional_mask']*output['regional_valid']*target['storm_mask'][:, None, None, None]
+    p, truth = output['regional'].float(), target['regional'].float()
+    terms['storm_field'] = weighted_mean((p-truth).abs(), region)
+    # Compare resolved native pressure minima against the SAME resolved target field,
+    # not subgrid best-track pressure (e.g. Tip's 875 hPa is absent in this archive).
+    local = region.flatten(1).bool()
+    pmin = p.flatten(1).masked_fill(~local, 1e4).min(1).values
+    tmin = truth.flatten(1).masked_fill(~local, 1e4).min(1).values
+    terms['resolved_core'] = weighted_mean((pmin-tmin).abs(), local.any(1).float())
+    # Radial-band pressure contrasts retain size/asymmetry information without
+    # imposing an idealized vortex or forcing a storm to survive.
+    terms['radial_structure'] = 0
+    for low, high in ((0, 150), (150, 300), (300, 600)):
+        band = ((dist2 >= low**2) & (dist2 < high**2))[:, None]*region
+        den = band.sum((1, 2, 3)).clamp_min(1)
+        contrast = ((p-truth)*band).sum((1, 2, 3))/den
+        terms['radial_structure'] = terms['radial_structure']+weighted_mean(contrast.abs(), (den > 1).float())/3
+    displacement = (output['center']-ct)*torch.stack([torch.ones_like(ct[:, 0])*111.2,
+                                  111.2*ct[:, 0].deg2rad().cos()], 1)
+    terms['route'] = weighted_mean(F.smooth_l1_loss(displacement/100, torch.zeros_like(displacement), reduction='none'),
+                                   target['storm_mask'][:, None])
+    terms['wind'] = weighted_mean(F.smooth_l1_loss(output['vmax']/30, target['vmax']/30, reduction='none'), target['vmax_mask'])
+    terms['flow_smooth'] = sum(v.diff(dim=a).abs().mean()/30 for v in
+                    [output['global_velocity'], output['regional_velocity']] for a in [-2, -1])
+    loss = terms['global']+terms['regional']+.5*terms['storm_field']+.2*terms['resolved_core']+ \
+           .1*terms['radial_structure']+.1*terms['route']+.05*terms['wind']+.002*terms['flow_smooth']
+    return loss, terms
+
+
+def training_indices(rows, epoch):
+    """Every coarse window once, plus storm-balanced native replays (~25% native)."""
+    rng = np.random.default_rng(165000+epoch)
+    indices = list(range(len(rows)))
+    groups = {}
+    for i, row in enumerate(rows):
+        if row['patch'] >= 0:
+            groups.setdefault(row['storm_id'], []).append(i)
+    native = sum(len(v) for v in groups.values())
+    extra = max(0, math.ceil((.25*len(rows)-native)/.75))
+    keys = sorted(groups)
+    for j in range(extra):
+        # Round-robin storms, random window within each storm.
+        indices.append(int(rng.choice(groups[keys[j % len(keys)]])))
+    rng.shuffle(indices)
+    return indices
+
+
+def save_training_state(path, model, optimizer, scaler, manifest, epoch, history, best):
+    atomic_checkpoint(path, dict(version=VERSION, architecture=ARCHITECTURE, dataset_sha256=manifest['identity'],
+        data_contract={k:manifest[k] for k in ('channels', 'units', 'global_lat', 'global_lon', 'regional_lat', 'regional_lon', 'normalization')},
+        epoch=epoch, model=model.state_dict(), optimizer=optimizer.state_dict(), scaler=scaler.state_dict(),
+        history=history, best_value=best, python_rng=random.getstate(), numpy_rng=np.random.get_state(),
+        torch_rng=torch.get_rng_state(), cuda_rng=torch.cuda.get_rng_state_all() if torch.cuda.is_available() else None))
+
+
+def restore_training_state(path, model, optimizer, scaler, manifest):
+    saved = torch.load(path, map_location='cpu', weights_only=False)
+    if saved['architecture'] != ARCHITECTURE or saved['dataset_sha256'] != manifest['identity']:
+        raise ValueError('Resume requires the identical v165 architecture and dataset; v164 is not compatible')
+    model.load_state_dict(saved['model'])
+    optimizer.load_state_dict(saved['optimizer'])
+    scaler.load_state_dict(saved['scaler'])
+    random.setstate(saved['python_rng']); np.random.set_state(saved['numpy_rng']); torch.set_rng_state(saved['torch_rng'])
+    if torch.cuda.is_available() and saved.get('cuda_rng') is not None:
+        torch.cuda.set_rng_state_all(saved['cuda_rng'])
+    return saved['epoch']+1, saved['history'], saved['best_value']
+
+
+def train165(model, m, args, device):
+    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=.01)
+    scaler = torch.amp.GradScaler('cuda', enabled=device.type == 'cuda' and bool(args.amp))
+    last, best_path = args.output/'last.pt', args.output/'best.pt'
+    start, history, best = 1, [], float('inf')
+    if last.is_file():
+        start, history, best = restore_training_state(last, model, optimizer, scaler, m)
+        print('Resuming completed epoch', start-1, flush=True)
+    atomic_json(args.output/'manifest.json', dict(version=VERSION, architecture=ARCHITECTURE,
+        parameters=sum(p.numel() for p in model.parameters()), dataset_sha256=m['identity'],
+        script_sha256=digest(__file__), samples=m['counts'], native_samples=m['patch_counts'],
+        future_weather_as_inputs=False, official_forecasts_as_inputs=False, input_hours=list(range(-48, 1, 6)),
+        forecast_hours=list(range(6, 121, 6)), pressure='resolved field at the reported field-derived center',
+        native_sampling='all coarse windows plus storm-balanced native replays to 25 percent',
+        validation='fixed 120h joint loss, balanced native/coarse strata; no test-set selection',
+        physical_microbatch=1, effective_batch=args.batch, tbptt_steps=4,
+        limitations=['regional WP, not global', 'native MSLP only on 1000 windows',
+                     'no fine upper-air variables', 'not an exact conservation solver', 'Tip is a development case']))
+    for epoch in range(start, args.epochs+1):
+        horizon = TRAIN_HORIZONS[min(epoch-1, len(TRAIN_HORIZONS)-1)]
+        metrics = {}
+        for split in ('train', 'validation'):
+            training = split == 'train'
+            model.train(training)
+            data = ReuseDataset(m, split)
+            sampler = training_indices(data.rows, epoch) if training else None
+            loader = DataLoader(data, batch_size=1, sampler=sampler, num_workers=min(args.workers, 2),
+                                **({'prefetch_factor':1} if args.workers else {}))
+            groups, failures = {False:[], True:[]}, []
+            optimizer.zero_grad(set_to_none=True)
+            began = time.time()
+            for index, (inputs, targets) in enumerate(loader, 1):
+                inputs = {k:v.to(device) for k, v in inputs.items()}
+                steps = horizon if training else 20
+                total, block_loss = 0., 0
+                with torch.set_grad_enabled(training):
+                    state = model.initial(inputs)
+                    for step in range(steps):
+                        with torch.autocast('cuda', dtype=torch.float16) if scaler.is_enabled() else nullcontext():
+                            state, output = model.step(state)
+                        frame = {k:v[:, step].to(device) for k, v in targets.items()}
+                        loss, terms = objective165(output, frame, inputs, m)
+                        if not torch.isfinite(loss):
+                            raise RuntimeError(f'Nonfinite loss epoch={epoch} sample={index} step={step}; no checkpoint advanced')
+                        total += float(loss.detach())/steps
+                        failures.append(float((~output['track_valid']).float().mean()))
+                        if training:
+                            block_loss = block_loss+loss/(steps*args.batch)
+                            if (step+1) % 4 == 0 or step+1 == steps:
+                                scaler.scale(block_loss).backward()
+                                state = {k:v.detach() for k, v in state.items()}
+                                block_loss = 0
+                    if training and (index % args.batch == 0 or index == len(loader)):
+                        scaler.unscale_(optimizer)
+                        remainder = index % args.batch
+                        if index == len(loader) and remainder:
+                            for parameter in model.parameters():
+                                if parameter.grad is not None:
+                                    parameter.grad.mul_(args.batch/remainder)
+                        norm = nn.utils.clip_grad_norm_(model.parameters(), 1.)
+                        if not torch.isfinite(norm):
+                            raise RuntimeError('Nonfinite gradient; checkpoint unchanged. Retry with AMP=0.')
+                        scaler.step(optimizer); scaler.update(); optimizer.zero_grad(set_to_none=True)
+                groups[bool(inputs['detail_available'][0, 0])].append(total)
+                if index == 1 or index % 10 == 0:
+                    print(f'{split} epoch={epoch}/{args.epochs} sample={index}/{len(loader)} horizon={steps} loss={total:.5f} elapsed_s={time.time()-began:.0f}', flush=True)
+            # Keep rare native examples visible in selection, rather than 5.7% dilution.
+            metrics[split+'_native'] = float(np.mean(groups[True]))
+            metrics[split+'_coarse'] = float(np.mean(groups[False]))
+            metrics[split] = (metrics[split+'_native']+metrics[split+'_coarse'])/2
+            metrics[split+'_association_failure_fraction'] = float(np.mean(failures))
+        promote = metrics['validation'] < best
+        if promote:
+            best = metrics['validation']
+        history.append(dict(epoch=epoch, horizon=horizon, **metrics))
+        save_training_state(last, model, optimizer, scaler, m, epoch, history, best)
+        save_training_state(args.output/f'epoch_{epoch:03d}.pt', model, optimizer, scaler, m, epoch, history, best)
+        if promote:
+            save_training_state(best_path, model, optimizer, scaler, m, epoch, history, best)
+        atomic_json(args.output/'history.json', history)
+        print(f'Saved epoch {epoch} directly to {args.output}; best={promote}', flush=True)
+    print('Training complete. Test set untouched; best.pt selected by full-120h validation.', flush=True)
+
+
+def main165():
+    parser = argparse.ArgumentParser(description='v1.2.65 causal pressure transport and evolution; Drive-only data')
+    parser.add_argument('batch', type=int, nargs='?', default=10)
+    parser.add_argument('workers', type=int, nargs='?', default=3)
+    parser.add_argument('amp', type=int, nargs='?', default=1, choices=[0, 1])
+    parser.add_argument('--manifest', type=Path, default=ROOT/'data/v164_reuse/manifest.json')
+    persistent = Path('/content/drive/MyDrive/typhoon_predict') if Path('/content').is_dir() else ROOT
+    parser.add_argument('--output', type=Path, default=persistent/'training/v165_transport_pressure')
+    parser.add_argument('--epochs', type=int, default=12)
+    parser.add_argument('--device', choices=['auto', 'cpu', 'mps', 'cuda'], default='auto')
+    parser.add_argument('--preflight', action='store_true')
+    args = parser.parse_args()
+    if args.batch < 1 or args.workers < 0 or args.epochs < 1:
+        parser.error('Invalid batch, workers or epochs')
+    if Path('/content').is_dir() and (not (persistent.parent).is_dir() or not args.output.resolve().is_relative_to(persistent.resolve())):
+        raise ValueError('Mount Google Drive first; Colab checkpoints must persist under MyDrive/typhoon_predict')
+    manifest = load_reuse(args.manifest)
+    for split in ('train', 'validation', 'test'):
+        data = ReuseDataset(manifest, split)
+        data[0]; data[next(i for i, r in enumerate(data.rows) if r['patch'] >= 0)]
+    if args.preflight:
+        print('PASS full existing archive checksums, splits and native samples. No training started.', flush=True)
+        return
+    device = device_for(args.device)
+    random.seed(165); np.random.seed(165); torch.manual_seed(165)
+    model = TransportForecaster(manifest).to(device)
+    print(json.dumps(dict(version=VERSION, architecture=ARCHITECTURE, parameters=sum(p.numel() for p in model.parameters()),
+        device=str(device), samples=manifest['counts'], native_samples=manifest['patch_counts'], output=str(args.output))), flush=True)
+    args.output.mkdir(parents=True, exist_ok=True)
+    lock = args.output/'training.lock'
+    fd = os.open(lock, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+    os.write(fd, json.dumps(dict(pid=os.getpid(), host=socket.gethostname())).encode()); os.close(fd)
+    try:
+        train165(model, manifest, args, device)
+    finally:
+        lock.unlink(missing_ok=True)
+
+
+if __name__ == '__main__':
+    main165()

training/trackformer_1_2/source/v173/v173_pressure_train.py

@@ -0,0 +1,176 @@
+"""Full-dataset, resumable Metal training for the v168 moving-core prototype."""
+import argparse
+import fcntl
+import importlib.util
+import json
+import os
+from pathlib import Path
+import random
+import signal
+import socket
+import time
+import sys
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+from model import CoreForecaster, objective, base, VERSION, ARCHITECTURE
+
+ROOT=Path(__file__).resolve().parents[1]
+HORIZONS=[4,8,12,20]
+
+
+class Tee:
+    def __init__(self, terminal, log): self.terminal,self.log=terminal,log
+    def write(self, value):
+        self.terminal.write(value);self.log.write(value);self.log.flush()
+    def flush(self): self.terminal.flush();self.log.flush()
+
+
+def batches(indices, rows, effective, physical):
+    for start in range(0,len(indices),effective):
+        window=indices[start:start+effective];parts=[]
+        for native in (True,False):
+            group=[i for i in window if (rows[i]['patch']>=0)==native]
+            parts.extend(group[j:j+physical] for j in range(0,len(group),physical))
+        yield parts,len(window)
+
+
+def save(path,model,optimizer,m,epoch,history,best,progress=None):
+    base.atomic_checkpoint(path,dict(version=VERSION,architecture=ARCHITECTURE,
+        dataset_sha256=m['identity'],model=model.state_dict(),optimizer=optimizer.state_dict(),
+        data_contract={k:m[k] for k in ('channels','units','global_lat','global_lon','regional_lat','regional_lon','normalization')},
+        epoch=epoch,history=history,best=best,progress=progress,
+        python_rng=random.getstate(),numpy_rng=np.random.get_state(),torch_rng=torch.get_rng_state()))
+
+
+def restore(path,model,optimizer,m):
+    p=torch.load(path,map_location='cpu',weights_only=False)
+    if p['architecture']!=ARCHITECTURE or p['dataset_sha256']!=m['identity']:
+        raise ValueError('Architecture/dataset mismatch')
+    model.load_state_dict(p['model'],strict=True);optimizer.load_state_dict(p['optimizer'])
+    random.setstate(p['python_rng']);np.random.set_state(p['numpy_rng']);torch.set_rng_state(p['torch_rng'])
+    return p
+
+
+def warm_start(model,path,m):
+    if base.digest(path)!='99ed776097e05ad6df03375465d9618741bed63a4ee57724d3ba98e295039d30':
+        raise ValueError('Expected the verified v168 epoch 3 baseline checkpoint')
+    p=torch.load(path,map_location='cpu',weights_only=False)
+    if p['version']!='1.2.68' or p['epoch']!=3 or p['dataset_sha256']!=m['identity']:
+        raise ValueError('Warm-start identity mismatch')
+    weights=p['model']
+    missing,extra=model.load_state_dict(weights,strict=False)
+    if extra or any(not k.startswith('context.') for k in missing):
+        raise ValueError('Incomplete environmental transfer')
+
+
+def main():
+    p=argparse.ArgumentParser()
+    for name,default in [('batch',10),('workers',2),('amp',0)]:p.add_argument(name,type=int,nargs='?',default=default)
+    p.add_argument('--microbatch',type=int,default=2)
+    p.add_argument('--epochs',type=int,default=12)
+    p.add_argument('--device',default='cuda' if torch.cuda.is_available() else 'mps',choices=['mps','cuda','cpu'])
+    here=Path(__file__).resolve().parent
+    colab=Path('/content/drive/MyDrive/typhoon_predict')
+    p.add_argument('--manifest',type=Path,default=(here if colab.exists() else ROOT)/'data/v164_reuse/manifest.json')
+    p.add_argument('--output',type=Path,default=colab/'training/v173' if colab.exists() else here/'runs/mac')
+    p.add_argument('--warm-start',type=Path,default=here/'baseline_epoch_003.pt' if colab.exists() else ROOT/'v168/runs/mac/epoch_003.pt')
+    p.add_argument('--preflight',action='store_true')
+    a=p.parse_args()
+    if min(a.batch,a.microbatch,a.epochs)<1 or a.workers<0 or a.amp not in (0,1):p.error('Positive batches/epochs required; amp must be 0 or 1')
+    if a.amp: print('AMP request recorded; pressure dynamics use FP32 for numerical stability.',flush=True)
+    if a.preflight:
+        m=base.load_reuse(a.manifest)
+        assert m['counts']==dict(train=13949,validation=1041,test=1195)
+        assert m['patch_counts']==dict(train=800,validation=100,test=100)
+        model=CoreForecaster(m);warm_start(model,a.warm_start,m)
+        print('Verified full dataset and v168 E3 warm start; parameters=',sum(p.numel() for p in model.parameters()))
+        return
+    torch.set_num_threads(4);random.seed(168);np.random.seed(168);torch.manual_seed(168)
+    base.EvolutionNet.block=lambda self,module,x:module(x)
+    device=base.device_for(a.device);a.output.mkdir(parents=True,exist_ok=True)
+    handle=(a.output/'training.lock').open('a+')
+    try:fcntl.flock(handle,fcntl.LOCK_EX|fcntl.LOCK_NB)
+    except BlockingIOError:raise RuntimeError('Training already active for this output')
+    handle.seek(0);handle.truncate();json.dump(dict(pid=os.getpid(),host=socket.gethostname()),handle);handle.flush()
+    log=(a.output/'train.log').open('a',buffering=1)
+    sys.stdout=Tee(sys.stdout,log);sys.stderr=Tee(sys.stderr,log)
+    stop=[False]
+    for sig in (signal.SIGTERM,signal.SIGINT):signal.signal(sig,lambda *_:stop.__setitem__(0,True))
+    m=base.load_reuse(a.manifest)
+    assert m['counts']==dict(train=13949,validation=1041,test=1195)
+    assert m['patch_counts']==dict(train=800,validation=100,test=100)
+    model=CoreForecaster(m).to(device)
+    optimizer=torch.optim.AdamW(model.parameters(),lr=3e-5,weight_decay=.01)
+    last=a.output/'last.pt';history=[];best=float('inf');start=1;progress=None
+    if last.exists():
+        saved=restore(last,model,optimizer,m)
+        history,best,start,progress=saved['history'],saved['best'],saved['epoch']+1,saved['progress']
+        if progress and progress['batch']!=a.batch:raise ValueError('Mid-epoch resume needs identical effective batch')
+    else:warm_start(model,a.warm_start,m)
+    manifest=dict(version=VERSION,architecture=ARCHITECTURE,parameters=sum(x.numel() for x in model.parameters()),
+        samples=m['counts'],native_samples=m['patch_counts'],dataset_sha256=m['identity'],device=str(device),
+        effective_batch=a.batch,microbatch=a.microbatch,precision='float32',future_weather_as_inputs=False,
+        future_best_track_as_inputs=False,official_forecasts_as_inputs=False,
+        pressure_map='moving learned core plus resolved environment; observation-conditioned initialization, not raw analysis',
+        internal_core_spacing_km=20,initial_core_prior_sigma_km=100,inner_absolute_reanalysis_loss_exclusion_km=150,
+        core_structure_status='prototype; unresolved inner structure is not spatially validated',
+        pressure_change_supervision=True,motion_change_supervision=True,
+        environmental_attention='two spatial pooling scales, two transformer blocks, cross attention; zero initialized correction',
+        route='pressure-field association; no independent displayed route or pressure head',
+        warm_start=str(a.warm_start),warm_start_sha256=base.digest(a.warm_start),
+        model_sha256=base.digest(Path(__file__).with_name('model.py')),trainer_sha256=base.digest(__file__))
+    base.atomic_json(a.output/'manifest.json',manifest)
+    print(json.dumps(manifest),flush=True)
+    for epoch in range(start,a.epochs+1):
+        metrics={}
+        for split in ('train','validation'):
+            training=split=='train';model.train(training);data=base.ReuseDataset(m,split)
+            indices=base.training_indices(data.rows,epoch) if training else list(range(len(data)))
+            windows=list(batches(indices,data.rows,a.batch,a.microbatch))
+            offset=progress['window'] if training and progress else 0
+            totals=progress['totals'] if training and progress else [[0.,0],[0.,0]]
+            parts=[part for group,_ in windows[offset:] for part in group]
+            loader=iter(DataLoader(data,batch_sampler=parts,num_workers=a.workers,**({'prefetch_factor':1} if a.workers else {})))
+            began=time.time();steps=HORIZONS[min(epoch-1,3)] if training else 20
+            for wi,(group,count) in enumerate(windows[offset:],offset):
+                optimizer.zero_grad(set_to_none=True)
+                for _ in group:
+                    x,y=next(loader);x={k:v.to(device) for k,v in x.items()};size=x['center'].shape[0]
+                    with torch.set_grad_enabled(training):
+                        state=model.initial(x);block=0;total=0.
+                        for lead in range(steps):
+                            state,out=model.step(state);target={k:v[:,lead].to(device) for k,v in y.items()}
+                            target['previous_pressure']=y['pressure'][:,lead-1].to(device) if lead else x['issue_intensity'][:,1]
+                            target['previous_pressure_mask']=y['pressure_mask'][:,lead-1].to(device) if lead else x['issue_mask'][:,1]
+                            target['previous_center']=y['center'][:,lead-1].to(device) if lead else x['center']
+                            target['previous_storm_mask']=y['storm_mask'][:,lead-1].to(device) if lead else torch.ones_like(target['storm_mask'])
+                            loss,terms=objective(out,target,x,m)
+                            if not bool(torch.isfinite(loss)):raise RuntimeError('Nonfinite loss; previous checkpoint retained')
+                            total+=float(loss.detach())/steps
+                            if training:
+                                block=block+loss*size/(count*steps)
+                                if (lead+1)%4==0 or lead+1==steps:
+                                    block.backward();block=0;state={k:v.detach() for k,v in state.items()}
+                    native=int(bool(x['detail_available'][0,0]));totals[native][0]+=total*size;totals[native][1]+=size
+                if training:
+                    norm=torch.nn.utils.clip_grad_norm_(model.parameters(),1.)
+                    if not bool(torch.isfinite(norm)):raise RuntimeError('Nonfinite gradient; previous checkpoint retained')
+                    optimizer.step()
+                    if (wi+1)%50==0 or wi+1==len(windows) or stop[0]:
+                        save(last,model,optimizer,m,epoch-1,history,best,dict(window=wi+1,totals=totals,batch=a.batch))
+                if wi%5==0 or wi+1==len(windows):
+                    print(f'{split} epoch={epoch}/{a.epochs} window={wi+1}/{len(windows)} horizon={steps} loss={total:.5f} pressure={float(terms["pressure"].detach()):.5f} route={float(terms["route"].detach()):.5f} elapsed_s={time.time()-began:.0f}',flush=True)
+                if stop[0]:print('Stopped at optimizer boundary; resume from last.pt',flush=True);return
+            metrics[split]=sum(v/n for v,n in totals if n)/sum(n>0 for _,n in totals);progress=None
+        promote=metrics['validation']<best
+        if promote:best=metrics['validation']
+        history.append(dict(epoch=epoch,horizon=HORIZONS[min(epoch-1,3)],**metrics))
+        for path in [a.output/f'epoch_{epoch:03d}.pt',last]+([a.output/'best.pt'] if promote else []):
+            save(path,model,optimizer,m,epoch,history,best)
+        base.atomic_json(a.output/'history.json',history)
+        print(f'Saved completed epoch {epoch}; best={promote}',flush=True)
+    print('Training complete; best selected on fixed 120h validation.',flush=True)
+
+
+if __name__=='__main__':main()

training/trackformer_1_2/train.py

@@ -0,0 +1,33 @@
+"""Portable launcher for the unchanged archived v173 trainer; no auto-training."""
+import argparse
+from pathlib import Path
+import runpy
+import sys
+
+
+def main():
+    here = Path(__file__).resolve().parent
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--data-root', type=Path, default=here / 'data')
+    p.add_argument('--warm-start', type=Path, default=here / 'checkpoints/v168_epoch_003.pt')
+    p.add_argument('--output', type=Path, required=True)
+    p.add_argument('--device', choices=['cpu', 'mps', 'cuda'], required=True)
+    p.add_argument('--epochs', type=int, default=4)
+    p.add_argument('--batch', type=int, default=10)
+    p.add_argument('--microbatch', type=int, default=4)
+    p.add_argument('--workers', type=int, default=3)
+    p.add_argument('--preflight', action='store_true')
+    a = p.parse_args()
+    source = here / 'source/v173'
+    sys.path.insert(0, str(source))
+    sys.argv = [str(source / 'v173_pressure_train.py'), str(a.batch), str(a.workers), '0',
+        '--microbatch', str(a.microbatch), '--epochs', str(a.epochs),
+        '--device', a.device, '--manifest', str(a.data_root.resolve() / 'manifest.json'),
+        '--warm-start', str(a.warm_start.resolve()), '--output', str(a.output.resolve())]
+    if a.preflight:
+        sys.argv.append('--preflight')
+    runpy.run_path(str(source / 'v173_pressure_train.py'), run_name='__main__')
+
+
+if __name__ == '__main__':
+    main()