Replace legacy files with Trackformer1.1

Remove the previous model files and publish only the Trackformer1.1 causal inference bundle.

.gitattributes

@@ -1,35 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+models/**/*.pt filter=lfs diff=lfs merge=lfs -text
+models/trackformer_1_1/trackformer_1_1_norm_stats.npz filter=lfs diff=lfs merge=lfs -text

README.md

@@ -3,165 +3,103 @@ license: mit
 library_name: pytorch
 pipeline_tag: time-series-forecasting
 tags:
-- tropical-cyclone
-- weather-forecasting
-- pytorch
-- era5
-- ibtracs
+  - tropical-cyclone
+  - weather-forecasting
+  - pytorch
+  - ibtracs
+  - causal-inference
 ---
 
-# Typhoon Predict — tropical-cyclone forecasting
-
-**Research models — not an operational warning system. Do not use for evacuation, aviation,
-maritime, or emergency decisions.**
-
-## Current best model: TrackFormer v23
-
-TrackFormer v23 predicts the atmospheric steering flow that carries a storm as an explicit
-chain-of-thought (CoT) intermediate step, conditions that estimate on how the flow has been
-evolving over the previous day (t-24h, t-12h, now), and derives track from it. Result:
-**434.96 km RMS track error** (10-seed ensemble), WP+EP 2020+, full 20-lead-horizon test set
-(3,763 windows).
-
-This is the best-performing model in the whole project, reached through a longer architecture
-progression:
-
-1. **v10–v20** — a small CNN encoder reads a deep-layer-mean steering-wind patch around the storm.
-2. **v21, v22** — chain-of-thought: predict the steering flow itself, then derive track from it
-   (v22 adds a latent CoT with weight-tied feedback rounds).
-3. **v23** — add a temporal history of the CoT steering representation. Best result: **434.96 km**.
-4. **v24–v29** — four further environmental additions on top of v23 (an environmental token, an
-   ocean-heat CNN patch, a drift adapter, raw ERA5 steering wind) all came back **null**: once a
-   CoT representation already extracts the steering signal that matters, handing the model the raw
-   field again is redundant.
-5. **v31–v34** — land/terrain-interaction correction, motivated by real-world reports of typhoons
-   stalling at mountainous coastlines (Typhoon Gaemi, 2024, at Taiwan) and terrain-deflection
-   literature (AOT-TCNet, arXiv 2603.29200):
-
-| model | aggregate track (km) | Typhoon Tip 1979 (km) | Typhoon Noul 2026, ocean/landfall (km) |
-|---|---|---|---|
-| v23 (baseline) | **434.96** | 939 | 267 / 356 |
-| v31 — LandDrag, uniform training | 443.07 (+8.11) | — | — |
-| v32 — LandDrag, window-oversampled | 460.48 (+25.52, backfired) | — | — |
-| v33 — LandDrag, storm-normalized | 442.33 (+7.37) | **876** | **243 / 319** |
-| v34 — LandGate, **frozen v23 backbone** | 460.52 (−0.33 vs. own backbone) | **795** | 287 / 382 |
-
-v34 is the methodologically important result: v31–v33 each retrained the *entire* architecture
-from scratch, so their deltas vs. v23 include ~19 km/seed of ordinary retrain noise on top of
-whatever the land correction did. v34 instead freezes a real, already-trained v23 checkpoint and
-trains only a new ~437-parameter gated correction — a true same-backbone-plus-one-addition
-comparison. Result: essentially null everywhere, including the mountainous-near-land regime every
-earlier attempt targeted. On the two real out-of-training storms available, v33 and v34 each split
-1–1 against v23 — a small-n disagreement with the aggregate test set, not a reliable effect.
-
-**Methodological lessons:** retrain-to-retrain seed noise (~19 km/seed) is large enough to
-manufacture or hide most small version-to-version deltas; freezing a real backbone and training
-only a small addition isolates a causal effect that comparing two from-scratch runs cannot; and a
-large in-distribution aggregate test set does not always agree with genuinely out-of-training
-real-storm validation.
-
-v23's 10-seed ensemble is released in this repo (`v23_seed0.pt`–`v23_seed9.pt`, fp32, 52.6 MB
-each) with a standalone architecture module and CLI — see "Usage — v23" below. Full write-up,
-architecture equations, and every intermediate result: `paper/trackformer.pdf`, "Chain-of-thought
-steering and land-interaction testing," in the GitHub repo
-(**https://github.com/yu314-coder/typhoon-predict**).
-
-## Usage — v23
-
-Two modes, controlled by whether you pass `--steering`:
-
-**IBTrACS-only** (default) — give it nothing but the storm's own recent track (position, max wind,
-central pressure). This is what any best-track record gives you for a storm, nothing more. The
-steering field and its 12h/24h history are zero-filled with an explicit availability flag — the
-same "unavailable == exact zeros, not fabricated" convention used throughout this project.
+# Trackformer1.1
 
-```bash
-python run_v23.py --track my_storm.json --out forecast.json
-```
+Trackformer1.1 is a research model for causal tropical-cyclone track,
+pressure, intensity, and wind-structure inference over the western Pacific.
+It is not an operational warning system and must not be used for evacuation,
+aviation, maritime, emergency-management, or other safety-critical decisions.
+
+## What it uses
+
+Inference accepts the observed storm history and weather analyses available at
+the issue time. It uses the current, 12-hour, and 24-hour analysis states to
+extrapolate a bounded western-Pacific pressure and flow state. The route sees
+a domain covering China, Japan, Taiwan, the Philippines, and the open western
+Pacific, so nearby lows, subtropical ridges, troughs, jets, and other storms
+can affect the steering field.
+
+No positive-lead weather field, official agency forecast, or post-issue
+observation is passed to the model. Later observations can be used only for
+verification after a forecast has been generated.
+
+## Model structure
+
+1. A causal regional state module extrapolates pressure, 500 hPa height, and
+   850/500/200 hPa wind from three analysis snapshots.
+2. A weighted steering ensemble samples inner, deep-layer, ridge, trough, and
+   jet views across the full western-Pacific domain and integrates the route.
+3. Three primary neural experts predict maximum wind, central pressure, RMW,
+   and directional 34/50/64 kt radii from a nine-step track window and the
+   current four-channel analysis patch.
+4. Three structure experts provide a validation-selected secondary blend.
+5. Three temporal experts read only same-storm 12-hour and 24-hour analysis
+   patches. Their residual branch is enabled only for the validated wind
+   adjustment; pressure remains on the calibrated primary path.
+6. The final intensity output is coupled to the causal pressure-map minimum,
+   pressure deficit, 850 hPa wind, and quadrant anomaly extent. Radius outputs
+   remain ordered as R34 >= R50 >= R64.
+
+The public bundle contains frozen inference checkpoints and calibration state;
+it does not include raw weather archives or a training service.
+
+## Files
+
+- `trackformer_1_1.py` - public loader and route API.
+- `trackformer_1_1_route.py` - whole-domain causal pressure-state route.
+- `trackformer_1_1_intensity.py` - intensity and wind-structure inference.
+- `trackformer_1_1_temporal.py` - inference-only temporal expert architecture.
+- `models/trackformer_1_1/` - three expert groups, calibration, and manifest.
 
-**Full data** — additionally supply a real deep-layer-mean steering-wind patch (850/500/200 hPa
-u/v, 2.5° resolution, ±20° box centered on the storm) for the current fix and, ideally, the two
-fixes 12h/24h before it. This is what the headline **434.96 km** result requires.
+## Quick start
 
 ```bash
-python run_v23.py --track my_storm.json --steering my_steering.npz --out forecast.json
+python -m pip install -r requirements.txt
+python - <<'PY'
+import numpy as np
+from trackformer_1_1 import load_intensity, forecast_pacific_state
+
+model = load_intensity(device="cpu")
+track = np.zeros((9, 54), dtype="float32")
+field = np.zeros((4, 17, 17), dtype="float32")
+current_structure = np.full(13, np.nan, dtype="float32")
+rows, metadata = model.predict(
+    track,
+    field,
+    current_wind=65.0,
+    current_pressure=980.0,
+    previous_wind=60.0,
+    previous_pressure=985.0,
+    current_structure=current_structure,
+)
+print(rows[0])
+print(metadata["model"])
+PY
 ```
 
-`my_storm.json`: a list of fixes, oldest→newest, spaced 6h apart, ending at the fix to forecast
-from — see `run_v23.py`'s docstring for the exact schema. `my_steering.npz`: keyed by the same ISO
-timestamps; the GitHub repo's `_fetch_dolphin_steering.py` is a complete working example of
-building one from NOAA/NOMADS GFS analysis fields for a live storm (ERA5 works the same way for a
-past one).
-
-**How much does the steering field matter?** Tested on Typhoon Dolphin (2026, active as of this
-writing): with real fetched GFS steering, v23's 120h forecast was 14.7°N,150.7°E / 99 kt / 951 hPa;
-with the steering field zeroed out (IBTrACS-only) it was 17.5°N,156.3°E / 90 kt / 957 hPa — the
-track moved by several hundred km while intensity only softened modestly. So on this storm the
-steering field mainly earns its keep on **track**, not intensity.
-
-## Released checkpoints: StormFusion-MT & TrackFormer v1–v9
-
-The earlier, fully released and locally-runnable line. Each predicts, at 20 six-hourly lead times
-(6–120 h), a 17-dim state per lead: east/north storm motion (km), max wind (kt), central pressure
-(hPa), radius of max wind (km), and 34/50/64-kt wind radii in four quadrants.
-
-| model | params | inputs | training data |
-|---|---|---|---|
-| **TrackFormer v9** | 17M (fp16, 33MB) | **track history + IBTrACS environment, protected triple-stream** | all basins, 1980+, 193k partial-lead windows |
-| TrackFormer v8 | 15M (fp16, 30MB) | track history only, protected dual-stream | all basins, 1980+, 193k partial-lead windows |
-| StormFusion-MT v2 | 3.3M (fp16, 6.7MB) | ERA5 patches + track history | WP, 2000+, 1,337 storm-centered windows |
-| TrackFormer (v1) | 21M (fp16, 43MB) | track history only (single-stream) | all basins, 1980+, 84,150 windows |
-
-Weights and full reproducible code (dataset builders, training, eval) are in the GitHub repo
-(`models/`).
-
-### Results — WP 2020+ held-out test (lower is better)
-
-| model | track km | vmax kt | pres hPa | rmw km | radius km |
-|---|---|---|---|---|---|
-| StormFusion-MT v2 (3.3M, ERA5) | 729 | 24.2 | 21.6 | 16.2 | 31.8 |
-| TrackFormer v1 (21M, single-stream) | 720 | 22.1 | 21.2 | 11.8 | 31.5 |
-| TrackFormer v3 (15M, dual-stream) | 659 | 21.6 | 18.1 | 11.8 | 28.8 |
-| TrackFormer v8 (15M, +partial-lead data) | 649 | 20.7 | 15.9 | **11.3** | 27.8 |
-| **TrackFormer v9 (17M, +IBTrACS environment)** | **618** | **18.6** | 15.8 | 11.5 | **27.2** |
-
-**Key findings.** (1) A track-only model that never sees ERA5 **matches or beats** the full ERA5
-model, so **data diversity > engineered features > parameters** (a 17.7M ERA5 model overfit and did
-*worse* than the 3.3M one). (2) Naively adding motion-dynamics features to a single-stream model
-improves intensity but hurts track through **negative transfer**; **TrackFormer v3** fixes this with a
-protected dual-stream architecture (separate kinematic/thermodynamic encoders, gradient routing, a
-zero-init gated thermo→track adapter, and a persistence-residual track head), cutting WP-2020+ track
-error to 659 km (−61, storm-bootstrap 95% CI [−103, −16] km, p≈0.995) while keeping the intensity
-gains. Full architecture and derivation (incl. a random-matrix block-covariance uncertainty head) in
-`paper/trackformer.pdf`, Appendix A, in the GitHub repo.
-
-### Architectures
-
-- **StormFusion-MT v2** — separate inner/outer ERA5 conv encoders keeping a 3×3 grid of spatial
-  tokens, track/environment token encoders, a temporal Transformer context, learned + sinusoidal
-  lead-time queries, cross-attention decoding, and multi-task state / log-scale heads.
-- **TrackFormer** — the same decoder design, track-only: a 40-dim track-history projection →
-  Transformer context (d_model 384, 8 heads, 4+6 layers) → lead queries → dual heads. No
-  atmospheric inputs.
-
-### Usage
-
-See the GitHub repo for `model_v2.py` / `train_track.py`, the checkpoints, and normalization
-stats. Inputs are per-feature standardized (stats saved with each checkpoint / dataset);
-multiply predictions by `TARGET_SCALE = [100,100,35,20,50] + [50]*12` for physical units.
-
-## Data
-
-IBTrACS v04r01 best tracks (NOAA NCEI) and ERA5 reanalysis (Copernicus/ECMWF). Obtain the source
-data under its own access and licensing terms.
-
-## Limitations
-
-- Research models throughout — not operational quality in either line. TrackFormer v23 (434.96 km
-  RMS track error, 6–120 h) and the released StormFusion-MT/TrackFormer v1–v9 checkpoints
-  (~618–730 km, different test split) are both far from operational.
-- v24–v34 (the further additions and land-interaction line built on top of v23) remain research
-  artifacts, not packaged for this card's load/run format — only v23 itself is released.
-- The real ceiling is storm **diversity** (~13k storms have ever existed); larger models overfit.
-- Wind-radius labels are sparse; no calibration or comparison against official agency forecasts.
-- Pre-satellite track/intensity labels are lower quality.
+The intensity contract is `track=(9,54)`, `field=(4,17,17)`, and optional
+`history_field=(8,17,17)` for the 12-hour and 24-hour analysis patches. The
+route contract is `fields=(3,7,latitude,longitude)` and
+`pressure=(3,latitude,longitude)`, ordered current, 12 hours before, and 24
+hours before. See `models/trackformer_1_1/manifest.json` for the complete
+contract.
+
+## Requirements and limits
+
+CPU inference works with Python 3.10+, NumPy, PyTorch, and SciPy. A modern
+Mac with 8 GB RAM is a practical minimum; 16 GB RAM is preferable when
+decoding large analysis grids. The checkpoints are native PyTorch files.
+GGUF is not an appropriate format for this CNN/Transformer weather model;
+keep the native PyTorch weights or convert to another format only after
+numerical parity testing.
+
+The model is experimental. Track and intensity errors vary by storm, basin,
+analysis source, and data quality. Use official meteorological agencies for
+real-world forecasts and warnings.

forecast.json

@@ -1,74 +0,0 @@
-{
-  "storm": "Bavi",
-  "source": "JTWC/TCGP fixes through 2026-07-10 0600 UTC",
-  "initial_time": "2026-07-10T06:00:00Z",
-  "initial_lat": 21.9,
-  "initial_lon": 126.9,
-  "points": [
-    {
-      "lead_hours": 6,
-      "lat": 22.466064453125,
-      "lon": 126.55152130126953,
-      "p10_lat": 22.288002014160156,
-      "p90_lat": 22.62434959411621,
-      "p10_lon": 126.4314956665039,
-      "p90_lon": 126.70477294921875
-    },
-    {
-      "lead_hours": 12,
-      "lat": 22.821269989013672,
-      "lon": 126.27210998535156,
-      "p10_lat": 22.475460052490234,
-      "p90_lat": 23.098590850830078,
-      "p10_lon": 126.02592468261719,
-      "p90_lon": 126.5489273071289
-    },
-    {
-      "lead_hours": 24,
-      "lat": 23.898107528686523,
-      "lon": 125.54524230957031,
-      "p10_lat": 23.513370513916016,
-      "p90_lat": 24.373027801513672,
-      "p10_lon": 124.97864532470703,
-      "p90_lon": 126.13536834716797
-    },
-    {
-      "lead_hours": 48,
-      "lat": 25.304624557495117,
-      "lon": 124.66926574707031,
-      "p10_lat": 24.34754180908203,
-      "p90_lat": 26.398544311523438,
-      "p10_lon": 123.34161376953125,
-      "p90_lon": 125.87503814697266
-    },
-    {
-      "lead_hours": 72,
-      "lat": 26.52523422241211,
-      "lon": 123.29611206054688,
-      "p10_lat": 24.960338592529297,
-      "p90_lat": 28.163558959960938,
-      "p10_lon": 120.4675064086914,
-      "p90_lon": 125.69815826416016
-    },
-    {
-      "lead_hours": 96,
-      "lat": 26.998743057250977,
-      "lon": 122.69322204589844,
-      "p10_lat": 24.666839599609375,
-      "p90_lat": 29.167266845703125,
-      "p10_lon": 119.0267562866211,
-      "p90_lon": 125.30994415283203
-    },
-    {
-      "lead_hours": 120,
-      "lat": 28.687833786010742,
-      "lon": 121.19312286376953,
-      "p10_lat": 26.278013229370117,
-      "p90_lat": 31.288469314575195,
-      "p10_lon": 115.32806396484375,
-      "p90_lon": 125.7118911743164
-    }
-  ],
-  "device": "mps",
-  "note": "Mac checkpoint inference using current track fixes and mean-normalized atmospheric input because 2026 ERA5 fields are unavailable locally. Not an operational forecast."
-}

forecast_world_map.html

@@ -1,61 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>Bavi Mac Model Forecast</title>
-  <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css">
-  <style>
-    html, body, #map { height: 100%; margin: 0; }
-    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
-    .panel { position: absolute; z-index: 1000; top: 16px; left: 16px; width: min(360px, calc(100vw - 32px)); padding: 14px 16px; background: rgba(255,255,255,.96); border: 1px solid #d5d9df; box-shadow: 0 3px 14px rgba(0,0,0,.18); }
-    h1 { margin: 0 0 7px; font-size: 20px; }
-    p { margin: 5px 0; font-size: 13px; line-height: 1.4; color: #374151; }
-    .legend { display: flex; gap: 12px; flex-wrap: wrap; margin-top: 9px; font-size: 12px; color: #374151; }
-    .key { display: inline-flex; align-items: center; gap: 5px; }
-    .swatch { width: 20px; height: 3px; display: inline-block; }
-    .mean { background: #d7263d; }
-    .actual { background: #111827; }
-    .corridor { width: 20px; height: 10px; background: rgba(245,158,11,.32); border: 1px solid #d97706; }
-  </style>
-</head>
-<body>
-  <div id="map"></div>
-  <section class="panel">
-    <h1>Bavi: Mac checkpoint prediction</h1>
-    <p><b>Initial fix:</b> 10 Jul 2026 06:00 UTC, 21.9°N 126.9°E</p>
-    <p><b>Run:</b> local Mac Apple MPS, 50 ensemble members, 120-hour horizon</p>
-    <p><b>Important:</b> this is a research proxy using a mean-normalized atmospheric field because the matching 2026 ERA5 field is not available locally. It is not an operational warning forecast.</p>
-    <div class="legend">
-      <span class="key"><i class="swatch actual"></i>official initial fix</span>
-      <span class="key"><i class="swatch mean"></i>model mean</span>
-      <span class="key"><i class="swatch corridor"></i>10–90% corridor</span>
-    </div>
-  </section>
-  <script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"></script>
-  <script>
-    const initial = [21.9, 126.9];
-    const forecast = [
-      {h: 6, lat: 22.4336, lon: 126.5818, la: 22.3279, lb: 22.5795, oa: 126.4390, ob: 126.7272},
-      {h: 12, lat: 22.7873, lon: 126.3022, la: 22.5105, lb: 23.0514, oa: 126.0263, ob: 126.6464},
-      {h: 24, lat: 23.8919, lon: 125.4258, la: 23.5613, lb: 24.3624, oa: 124.9874, ob: 125.9527},
-      {h: 48, lat: 25.6544, lon: 124.6313, la: 24.6905, lb: 26.3908, oa: 123.1265, ob: 126.0750},
-      {h: 72, lat: 26.4361, lon: 123.5473, la: 24.9631, lb: 28.2892, oa: 120.7869, ob: 125.8778},
-      {h: 96, lat: 26.6257, lon: 121.9343, la: 24.2808, lb: 28.4809, oa: 118.0243, ob: 126.7538},
-      {h: 120, lat: 28.6126, lon: 121.8454, la: 26.2118, lb: 30.8639, oa: 117.2112, ob: 126.6462}
-    ];
-    const map = L.map('map', {worldCopyJump: true}).setView([25, 126], 4);
-    L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {maxZoom: 18, attribution: '&copy; OpenStreetMap contributors'}).addTo(map);
-    L.marker(initial).addTo(map).bindPopup('<b>Official initial fix</b><br>21.9°N, 126.9°E<br>10 Jul 2026 06:00 UTC').openPopup();
-    const meanLine = [initial];
-    forecast.forEach(p => {
-      meanLine.push([p.lat, p.lon]);
-      L.rectangle([[p.la, p.oa], [p.lb, p.ob]], {color:'#d97706', weight:1, fillColor:'#f59e0b', fillOpacity:.18}).addTo(map).bindTooltip('+' + p.h + 'h model 10–90% box');
-      L.circleMarker([p.lat, p.lon], {radius: 5, color:'#d7263d', fillColor:'#d7263d', fillOpacity:1}).addTo(map).bindTooltip('+' + p.h + 'h: ' + p.lat.toFixed(2) + '°N, ' + p.lon.toFixed(2) + '°E');
-    });
-    L.polyline(meanLine, {color:'#d7263d', weight:4, opacity:.9}).addTo(map);
-    L.polyline([initial, [21.9,126.9]], {color:'#111827', weight:5}).addTo(map);
-    map.fitBounds(L.latLngBounds(meanLine), {padding: [45, 45]});
-  </script>
-</body>
-</html>

models/trackformer_1_1/manifest.json

@@ -0,0 +1,33 @@
+{
+  "name": "Trackformer1.1",
+  "task": "causal western-Pacific tropical-cyclone track, pressure, intensity, and wind-structure research inference",
+  "model_type": "regional analysis-state route plus spatial/temporal neural structure ensemble",
+  "checkpoint_count": {
+    "primary_intensity": 3,
+    "structure_experts": 3,
+    "temporal_experts": 3
+  },
+  "training_data": {
+    "track": "IBTrACS best-track history",
+    "weather": "analysis/reanalysis fields only",
+    "split": "storm-held-out chronological train/validation/test split",
+    "future_weather_as_input": false,
+    "official_forecast_as_input": false
+  },
+  "track_input_shape": [9, 54],
+  "intensity_field_shape": [4, 17, 17],
+  "history_field_shape": [8, 17, 17],
+  "route_field_layout": "[snapshots=3, channels=7, latitude, longitude] with hgt500,u/v850,u/v500,u/v200",
+  "lead_hours": [6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96, 102, 108, 114, 120],
+  "outputs": [
+    "track latitude/longitude",
+    "maximum sustained wind",
+    "central pressure",
+    "radius of maximum wind",
+    "34/50/64 kt wind radii by quadrant"
+  ],
+  "native_distance_unit": "nautical miles",
+  "public_distance_unit": "kilometres",
+  "license": "MIT",
+  "warning": "Research output only; not an operational warning or safety-critical forecast."
+}

models/trackformer_1_1/trackformer_1_1_calibration.json

@@ -0,0 +1,2180 @@
+{
+  "version": "Trackformer1.1-calibration",
+  "created_utc": "2026-08-04T03:35:06.917313+00:00",
+  "fit_split": "val (storm-held-out 2016-2019)",
+  "evaluation_split": "test (storm-held-out 2020+)",
+  "features": [
+    "bias",
+    "current_pressure_hpa",
+    "current_wind_kt",
+    "primary_predicted_wind_kt",
+    "predicted_wind_minus_current_wind_kt",
+    "current_pressure_minus_previous_pressure_hpa",
+    "current_wind_minus_previous_wind_kt"
+  ],
+  "wind_target_convention": "same as Trackformer1.1 model output (1-minute estimate); blend uses current wind as an observed forecast-time anchor",
+  "checkpoint_count": 3,
+  "metrics": {
+    "raw_val_pressure_mae_all_leads_hpa": 12.745838165283203,
+    "calibrated_val_pressure_mae_all_leads_hpa": 13.02608874699582,
+    "raw_test_pressure_mae_all_leads_hpa": 12.803126335144043,
+    "calibrated_test_pressure_mae_all_leads_hpa": 12.420955012285965,
+    "joint_calibrated_val_pressure_mae_all_leads_hpa": 12.730707934229281,
+    "joint_calibrated_test_pressure_mae_all_leads_hpa": 12.230934403282232,
+    "raw_val_pressure_mae_120h_hpa": 16.14628028869629,
+    "calibrated_val_pressure_mae_120h_hpa": 15.681344145679113,
+    "raw_test_pressure_mae_120h_hpa": 16.42153549194336,
+    "calibrated_test_pressure_mae_120h_hpa": 14.524238379900986,
+    "joint_calibrated_val_pressure_mae_120h_hpa": 15.545918282225045,
+    "joint_calibrated_test_pressure_mae_120h_hpa": 14.458328501318364,
+    "pressure_anchored_val_pressure_mae_all_leads_hpa": 12.587559582395707,
+    "pressure_anchored_test_pressure_mae_all_leads_hpa": 11.99345142652379,
+    "pressure_anchored_val_pressure_mae_120h_hpa": 15.544537539571403,
+    "pressure_anchored_test_pressure_mae_120h_hpa": 14.435201089126327,
+    "raw_val_wind_mae_all_leads_kt": 17.10424041748047,
+    "calibrated_val_wind_mae_all_leads_kt": 16.91584014892578,
+    "raw_test_wind_mae_all_leads_kt": 16.560529708862305,
+    "calibrated_test_wind_mae_all_leads_kt": 16.396728515625,
+    "raw_val_wind_mae_120h_kt": 21.62657356262207,
+    "calibrated_val_wind_mae_120h_kt": 21.440736770629883,
+    "raw_test_wind_mae_120h_kt": 20.42694664001465,
+    "calibrated_test_wind_mae_120h_kt": 20.36166763305664,
+    "raw_structure_mae_120h_native": [
+      13.61,
+      34.27,
+      35.875,
+      31.447,
+      32.959,
+      18.523,
+      19.544,
+      17.72,
+      17.436,
+      11.272,
+      11.788,
+      10.746,
+      10.529
+    ],
+    "blended_structure_mae_120h_native": [
+      13.615,
+      34.109,
+      35.432,
+      31.447,
+      32.737,
+      18.626,
+      19.763,
+      17.891,
+      17.661,
+      11.29,
+      11.747,
+      10.746,
+      10.475
+    ]
+  },
+  "calibrations": [
+    {
+      "beta": [
+        979.3647389439432,
+        1.9158192596454662,
+        -10.625316061573692,
+        -10.76484441891422,
+        1.4216365382963003,
+        0.355287389506127,
+        -2.653478803931415
+      ],
+      "mean": [
+        0.0,
+        978.1810383079426,
+        64.5815707735542,
+        65.59845112223823,
+        1.0168803486840257,
+        1.905043632598728,
+        1.4701967164620617
+      ],
+      "scale": [
+        1.0,
+        50.53637228468569,
+        33.10783692877566,
+        32.14420199228587,
+        4.047375438494807,
+        54.79089485626104,
+        6.246907173086729
+      ]
+    },
+    {
+      "beta": [
+        978.6045857988166,
+        1.159678080634184,
+        -10.476473797695414,
+        -11.027839130141558,
+        0.25385328395687057,
+        0.45833242498682186,
+        -3.181226204489663
+      ],
+      "mean": [
+        0.0,
+        976.7190828402366,
+        64.52144970414201,
+        65.9957684040775,
+        1.4743186999354843,
+        1.9063609467455622,
+        1.4738165680473372
+      ],
+      "scale": [
+        1.0,
+        62.987212868626365,
+        33.18977815879015,
+        31.37842015427967,
+        6.600915311239932,
+        54.79480783300083,
+        6.245251042331157
+      ]
+    },
+    {
+      "beta": [
+        978.0161338069863,
+        0.6738374269289117,
+        -10.062859593303838,
+        -11.437666297247567,
+        -1.0826424344554468,
+        0.3649143931938072,
+        -2.4904427275749708
+      ],
+      "mean": [
+        0.0,
+        975.2491119005329,
+        64.46758436944938,
+        65.93912073678699,
+        1.4715363673376147,
+        1.7575488454706927,
+        1.4773534635879217
+      ],
+      "scale": [
+        1.0,
+        73.34317349947774,
+        33.277770226738575,
+        30.210884717895517,
+        9.857814699499565,
+        56.14964419892791,
+        6.253661273135333
+      ]
+    },
+    {
+      "beta": [
+        977.6126259632483,
+        0.3647266027866861,
+        -9.488025865326827,
+        -11.892068495452548,
+        -2.183654318457364,
+        0.26197009521576825,
+        -1.7017446652271828
+      ],
+      "mean": [
+        0.0,
+        973.9270895080024,
+        64.41123295791346,
+        65.77106518447222,
+        1.359832226558769,
+        1.5952874925903973,
+        1.4903675163011263
+      ],
+      "scale": [
+        1.0,
+        81.55905643779808,
+        33.37057257362826,
+        28.96361227936494,
+        12.738465555338884,
+        57.48200889919564,
+        6.2549372779430845
+      ]
+    },
+    {
+      "beta": [
+        977.3788958147819,
+        0.22978396861298192,
+        -8.819607237745391,
+        -12.14781196679265,
+        -2.743935857195942,
+        0.04992926797301592,
+        -1.3349625849092375
+      ],
+      "mean": [
+        0.0,
+        972.7582368655387,
+        64.35366577619472,
+        65.45164637299878,
+        1.0979805968040597,
+        1.5890471950133571,
+        1.5031166518254675
+      ],
+      "scale": [
+        1.0,
+        88.23866281788312,
+        33.456506355578135,
+        27.75689837682731,
+        15.347421693937026,
+        57.524265495181936,
+        6.247664265837107
+      ]
+    },
+    {
+      "beta": [
+        977.2594465932758,
+        0.2760853766109035,
+        -8.128811856734984,
+        -12.238453665761691,
+        -2.9696078556524057,
+        -0.03436852261542168,
+        -1.1949635193531134
+      ],
+      "mean": [
+        0.0,
+        972.4617673311515,
+        64.34275513240107,
+        64.98030532864153,
+        0.6375501962404668,
+        1.584498661112764,
+        1.5165129425766142
+      ],
+      "scale": [
+        1.0,
+        89.9186470511227,
+        33.49768138488822,
+        26.56546307724779,
+        17.78815483866843,
+        57.59243440899489,
+        6.244839191073782
+      ]
+    },
+    {
+      "beta": [
+        977.275208830549,
+        0.3302926221894572,
+        -7.4827672649673,
+        -12.181590337721174,
+        -2.958535712519607,
+        -0.05888547667459402,
+        -1.1528998888740287
+      ],
+      "mean": [
+        0.0,
+        972.166915274463,
+        64.32801312649164,
+        64.60189941317412,
+        0.2738862863979647,
+        1.5853221957040573,
+        1.527744630071599
+      ],
+      "scale": [
+        1.0,
+        91.5873950283228,
+        33.53705182833371,
+        25.505423746027805,
+        20.194468969727616,
+        57.6690743414348,
+        6.241065684632235
+      ]
+    },
+    {
+      "beta": [
+        977.4265828468792,
+        0.3456389495464159,
+        -6.887855834667866,
+        -11.982728429603078,
+        -2.8483573166969975,
+        -0.01676464039392852,
+        -1.155605952556869
+      ],
+      "mean": [
+        0.0,
+        971.8718754677443,
+        64.30399640772339,
+        63.97318780188467,
+        -0.3308086069806788,
+        1.5837449483610238,
+        1.545577009429726
+      ],
+      "scale": [
+        1.0,
+        93.26701702857976,
+        33.579947436293786,
+        24.620441527249962,
+        22.370585532622172,
+        57.76717976524845,
+        6.2318182994660445
+      ]
+    },
+    {
+      "beta": [
+        977.7077824519231,
+        0.3742494390176481,
+        -6.340741475621145,
+        -11.754265657938584,
+        -2.6828266265386937,
+        0.016897803479940448,
+        -1.1134641714774627
+      ],
+      "mean": [
+        0.0,
+        971.5954026442307,
+        64.2549579326923,
+        62.96718305378006,
+        -1.2877748783391256,
+        1.5760216346153846,
+        1.5689603365384615
+      ],
+      "scale": [
+        1.0,
+        94.93760398672073,
+        33.613050887448374,
+        23.706436575938007,
+        24.41700063160801,
+        57.87417128115503,
+        6.217322594269493
+      ]
+    },
+    {
+      "beta": [
+        978.1375037775763,
+        0.4649928695065894,
+        -5.8395505850139715,
+        -11.477235869564007,
+        -2.4819997208339086,
+        0.10752048000060792,
+        -1.1103025131158928
+      ],
+      "mean": [
+        0.0,
+        971.3303112722876,
+        64.17527954064673,
+        62.03331732324835,
+        -2.1419622182629916,
+        1.5754004230885463,
+        1.5929283771532186
+      ],
+      "scale": [
+        1.0,
+        96.6811703822946,
+        33.65355257692086,
+        22.79463316794241,
+        26.2208909033306,
+        58.03843631538493,
+        6.204621897205797
+      ]
+    },
+    {
+      "beta": [
+        978.6816245816854,
+        0.6120426122179327,
+        -5.393762657505621,
+        -11.16348574493176,
+        -2.2680355887737136,
+        0.21808458899551153,
+        -1.107812340721413
+      ],
+      "mean": [
+        0.0,
+        971.0885305749924,
+        64.04745968968665,
+        60.8586191099612,
+        -3.1888405779846396,
+        1.5728627928202008,
+        1.6186492242166108
+      ],
+      "scale": [
+        1.0,
+        98.45100928052985,
+        33.671915141098914,
+        21.924313547692126,
+        27.825420835081715,
+        58.230564926174964,
+        6.192075094590328
+      ]
+    },
+    {
+      "beta": [
+        979.3450283438027,
+        0.7319180819424854,
+        -5.008376019672533,
+        -10.768778319983676,
+        -2.0429282545741065,
+        0.3674105985052596,
+        -1.2015351802290106
+      ],
+      "mean": [
+        0.0,
+        970.8610387620653,
+        63.89229354986977,
+        59.479008114427415,
+        -4.413285438072377,
+        1.5874061590317143,
+        1.6341351309943313
+      ],
+      "scale": [
+        1.0,
+        100.23062800348737,
+        33.674191443192385,
+        21.208226375492284,
+        29.24792990211032,
+        58.4371110933118,
+        6.184937924572314
+      ]
+    },
+    {
+      "beta": [
+        980.105604446503,
+        0.7666194688253678,
+        -4.689530902345973,
+        -10.289081391756739,
+        -1.8255623125939082,
+        0.4955171144086594,
+        -1.3491949486587504
+      ],
+      "mean": [
+        0.0,
+        970.6553960166743,
+        63.68905357418558,
+        58.03452988909188,
+        -5.654523683032338,
+        1.6220472440944882,
+        1.6265246255982708
+      ],
+      "scale": [
+        1.0,
+        102.0201408123609,
+        33.62765022480105,
+        20.715588686897885,
+        30.3788753865059,
+        58.65838429251217,
+        6.17016637339649
+      ]
+    },
+    {
+      "beta": [
+        980.9283154121864,
+        0.7315739553554528,
+        -4.397436869389718,
+        -9.8222155905967,
+        -1.6061360661083666,
+        0.6129502278031091,
+        -1.459642620721356
+      ],
+      "mean": [
+        0.0,
+        970.4040829047842,
+        63.52236247467664,
+        56.605309408885475,
+        -6.917053074410943,
+        1.6501480442574412,
+        1.619448340345956
+      ],
+      "scale": [
+        1.0,
+        103.88514324892287,
+        33.61229933848826,
+        20.186672231267604,
+        31.42790190641402,
+        58.92879090161479,
+        6.170992037104559
+      ]
+    },
+    {
+      "beta": [
+        981.8252993068684,
+        0.5928998786610551,
+        -4.101469153326283,
+        -9.42271938876919,
+        -1.4771057284324305,
+        0.663139976586497,
+        -1.582271831745498
+      ],
+      "mean": [
+        0.0,
+        970.11468178954,
+        63.39004410838059,
+        55.095669031969464,
+        -8.29437507190416,
+        1.6852551984877127,
+        1.613421550094518
+      ],
+      "scale": [
+        1.0,
+        105.82467616006231,
+        33.61784905160175,
+        19.689630541879367,
+        32.26821406536604,
+        59.243797369533446,
+        6.163178774221445
+      ]
+    },
+    {
+      "beta": [
+        982.781539444267,
+        0.6025154669117084,
+        -3.823209689209051,
+        -9.064186918081038,
+        -1.3626446088366062,
+        0.659595056954032,
+        -1.7078633128626304
+      ],
+      "mean": [
+        0.0,
+        970.1533056531459,
+        63.22868093260939,
+        53.804770275488785,
+        -9.423910663973901,
+        1.7376237623762376,
+        1.6045991695943789
+      ],
+      "scale": [
+        1.0,
+        106.49924076137351,
+        33.55507285388263,
+        19.118239462204585,
+        32.921422156523604,
+        59.64370137739178,
+        6.154107714919649
+      ]
+    },
+    {
+      "beta": [
+        983.7722258273848,
+        0.6687148174280548,
+        -3.5729812231535414,
+        -8.792480353894183,
+        -1.3003606126715186,
+        0.499498994331008,
+        -1.6753764571780796
+      ],
+      "mean": [
+        0.0,
+        970.1787800129786,
+        63.05759247242051,
+        52.68523681194731,
+        -10.372355683216563,
+        1.6383841661258922,
+        1.5837118754055808
+      ],
+      "scale": [
+        1.0,
+        107.29605632482229,
+        33.53430196992395,
+        18.571850136403008,
+        33.45834533772734,
+        58.75240472843225,
+        6.141393220321764
+      ]
+    },
+    {
+      "beta": [
+        984.8051476654017,
+        0.7936591779096613,
+        -3.3305818529271134,
+        -8.53375512175729,
+        -1.2606585077726875,
+        0.3600260216844111,
+        -1.762847372231583
+      ],
+      "mean": [
+        0.0,
+        970.1988120772149,
+        62.87163834350767,
+        51.340679551052034,
+        -11.5309587998509,
+        1.3928394654347467,
+        1.5367101138426003
+      ],
+      "scale": [
+        1.0,
+        108.15524982595403,
+        33.52528278502775,
+        18.101358971225256,
+        33.91105548737279,
+        56.37757439013659,
+        6.0910850383445165
+      ]
+    },
+    {
+      "beta": [
+        985.8285618053217,
+        0.9087397364417128,
+        -3.022972086698143,
+        -8.322423688142754,
+        -1.3446136356566873,
+        0.3946433377092663,
+        -1.7388411472291765
+      ],
+      "mean": [
+        0.0,
+        970.2800606264735,
+        62.76507241495453,
+        49.89703195558408,
+        -12.868040449894732,
+        1.1162007409902324,
+        1.5151566183900302
+      ],
+      "scale": [
+        1.0,
+        108.48954799478317,
+        33.561878314366474,
+        17.68762257887688,
+        34.08294834352858,
+        53.89123657113572,
+        6.0795658479880625
+      ]
+    },
+    {
+      "beta": [
+        986.8479875626188,
+        0.9988686965957757,
+        -2.6834677443169466,
+        -8.099529947859729,
+        -1.4667797091389447,
+        0.5844770131345003,
+        -1.5645908925443726
+      ],
+      "mean": [
+        0.0,
+        970.663672482294,
+        62.6716185869753,
+        48.54065532316958,
+        -14.130963267924193,
+        0.833822767317326,
+        1.4964588011746416
+      ],
+      "scale": [
+        1.0,
+        107.56308024859545,
+        33.588233290907006,
+        17.283634363151315,
+        33.904315820004165,
+        51.321735772531284,
+        6.081771020585556
+      ]
+    }
+  ],
+  "pressure_joint_features": [
+    "bias",
+    "current_pressure_hpa",
+    "current_wind_kt",
+    "calibrated_predicted_wind_kt",
+    "raw_predicted_pressure_hpa",
+    "raw_predicted_pressure_minus_current_hpa",
+    "calibrated_predicted_wind_minus_current_kt",
+    "current_pressure_minus_previous_pressure_hpa",
+    "current_wind_minus_previous_wind_kt"
+  ],
+  "pressure_joint_calibrations": [
+    {
+      "beta": [
+        979.3647389439432,
+        2.1244914734848255,
+        -6.002552197162719,
+        -6.110930904804655,
+        10.470565126637606,
+        3.817114397046572,
+        0.5822412387685045,
+        0.16010090364060767,
+        -1.5439923636219977
+      ],
+      "mean": [
+        0.0,
+        978.1810383079426,
+        64.5815707735542,
+        65.6266441483449,
+        979.0951558127063,
+        0.9141175047636491,
+        1.0450733747906875,
+        1.905043632598728,
+        1.4701967164620617
+      ],
+      "scale": [
+        1.0,
+        50.53637228468569,
+        33.10783692877566,
+        32.124343617572436,
+        24.762051237279874,
+        39.796705658565024,
+        4.159573246659055,
+        54.79089485626104,
+        6.246907173086729
+      ]
+    },
+    {
+      "beta": [
+        978.6045857988166,
+        0.8713799654438338,
+        -7.7527258211177985,
+        -8.237667857241275,
+        6.714629045232456,
+        2.1450799243690115,
+        0.018155804213034234,
+        0.2910972149675519,
+        -2.3186426773038207
+      ],
+      "mean": [
+        0.0,
+        976.7190828402366,
+        64.52144970414201,
+        66.21541114460082,
+        978.656016247089,
+        1.9369334068524062,
+        1.6939614404588057,
+        1.9063609467455622,
+        1.4738165680473372
+      ],
+      "scale": [
+        1.0,
+        62.987212868626365,
+        33.18977815879015,
+        31.219218256081252,
+        25.2167769986195,
+        53.347899343611246,
+        7.58431677406538,
+        54.79480783300083,
+        6.245251042331157
+      ]
+    },
+    {
+      "beta": [
+        978.0161338069863,
+        0.42796089044169344,
+        -8.495149928651433,
+        -9.72355373046241,
+        4.306850308592872,
+        1.2549277151505402,
+        -0.9592509347076426,
+        -0.05607486236487535,
+        -2.032501028079223
+      ],
+      "mean": [
+        0.0,
+        975.2491119005329,
+        64.46758436944938,
+        66.03674610847548,
+        978.6352417010256,
+        3.3861298004927334,
+        1.5691617390261097,
+        1.7575488454706927,
+        1.4773534635879217
+      ],
+      "scale": [
+        1.0,
+        73.34317349947774,
+        33.277770226738575,
+        30.11070808190084,
+        26.15742021970667,
+        64.75917499444205,
+        10.511785983418822,
+        56.14964419892791,
+        6.253661273135333
+      ]
+    },
+    {
+      "beta": [
+        977.6126259632483,
+        0.25733740761036766,
+        -8.223026850989438,
+        -10.354225400510941,
+        3.7337223226615857,
+        1.0377977674639305,
+        -1.9363265512130752,
+        -0.3109780621723116,
+        -1.4713391665546236
+      ],
+      "mean": [
+        0.0,
+        973.9270895080024,
+        64.41123295791346,
+        65.7963597440974,
+        978.8774953411398,
+        4.950405833137481,
+        1.3851267861839434,
+        1.5952874925903973,
+        1.4903675163011263
+      ],
+      "scale": [
+        1.0,
+        81.55905643779808,
+        33.37057257362826,
+        28.928456009421513,
+        26.279899465884235,
+        74.324356368596,
+        12.97541456694104,
+        57.48200889919564,
+        6.2549372779430845
+      ]
+    },
+    {
+      "beta": [
+        977.3788958147819,
+        0.19565831212711526,
+        -7.627340048103773,
+        -10.525660728364645,
+        3.65180442270761,
+        0.9114316402072032,
+        -2.4560523652352155,
+        -0.5048895919362318,
+        -1.2221630437590159
+      ],
+      "mean": [
+        0.0,
+        972.7582368655387,
+        64.35366577619472,
+        65.43843451049428,
+        979.1345288578711,
+        6.376291992332433,
+        1.0847687342995598,
+        1.5890471950133571,
+        1.5031166518254675
+      ],
+      "scale": [
+        1.0,
+        88.23866281788312,
+        33.456506355578135,
+        27.78207056922819,
+        25.33951308468857,
+        82.58471046960283,
+        15.162746063357607,
+        57.524265495181936,
+        6.247664265837107
+      ]
+    },
+    {
+      "beta": [
+        977.2594465932758,
+        0.21130054047204685,
+        -7.018341900403828,
+        -10.58329505292094,
+        3.5920580788574266,
+        0.8153638167483641,
+        -2.727568831621463,
+        -0.5801340900358954,
+        -1.1526400476893242
+      ],
+      "mean": [
+        0.0,
+        972.4617673311515,
+        64.34275513240107,
+        64.95803123366723,
+        979.3716344541115,
+        6.909867122959999,
+        0.6152761012661567,
+        1.584498661112764,
+        1.5165129425766142
+      ],
+      "scale": [
+        1.0,
+        89.9186470511227,
+        33.49768138488822,
+        26.6383543934097,
+        24.546593638967988,
+        84.83689103290898,
+        17.166710109155744,
+        57.59243440899489,
+        6.244839191073782
+      ]
+    },
+    {
+      "beta": [
+        977.275208830549,
+        0.2227503073241216,
+        -6.426683692995159,
+        -10.520635051916873,
+        3.5429980271404626,
+        0.74185897909257,
+        -2.8219107567360324,
+        -0.6004254146464897,
+        -1.1561584357339976
+      ],
+      "mean": [
+        0.0,
+        972.166915274463,
+        64.32801312649164,
+        64.58668019188688,
+        979.5777262002586,
+        7.410810925795525,
+        0.25866706539523343,
+        1.5853221957040573,
+        1.527744630071599
+      ],
+      "scale": [
+        1.0,
+        91.5873950283228,
+        33.53705182833371,
+        25.602260620153988,
+        23.943168400019932,
+        86.8486866400537,
+        19.072189386922403,
+        57.6690743414348,
+        6.241065684632235
+      ]
+    },
+    {
+      "beta": [
+        977.4265828468792,
+        0.23446887366411298,
+        -5.841713308306412,
+        -10.298255141336625,
+        3.538099855573987,
+        0.6848819961434182,
+        -2.804375619473821,
+        -0.5602620390530704,
+        -1.1905193358282722
+      ],
+      "mean": [
+        0.0,
+        971.8718754677443,
+        64.30399640772339,
+        63.996917009317954,
+        979.8604918721014,
+        7.9886164043570975,
+        -0.30707939897642006,
+        1.5837449483610238,
+        1.545577009429726
+      ],
+      "scale": [
+        1.0,
+        93.26701702857976,
+        33.579947436293786,
+        24.703194308095586,
+        23.414953388343157,
+        89.03173262580074,
+        20.765893804880417,
+        57.76717976524845,
+        6.2318182994660445
+      ]
+    },
+    {
+      "beta": [
+        977.7077824519231,
+        0.2731983522105385,
+        -5.277213350632824,
+        -10.088854720334119,
+        3.4939775555802064,
+        0.590462787082304,
+        -2.808858166118079,
+        -0.5226757418073821,
+        -1.1750023522827215
+      ],
+      "mean": [
+        0.0,
+        971.5954026442307,
+        64.2549579326923,
+        63.085182326989106,
+        980.3641269023602,
+        8.768724258129414,
+        -1.1697756054166417,
+        1.5760216346153846,
+        1.5689603365384615
+      ],
+      "scale": [
+        1.0,
+        94.93760398672073,
+        33.613050887448374,
+        23.75717496005899,
+        22.878541050644525,
+        91.45421724246802,
+        22.17963402594675,
+        57.87417128115503,
+        6.217322594269493
+      ]
+    },
+    {
+      "beta": [
+        978.1375037775763,
+        0.3554194868427499,
+        -4.767789317327665,
+        -9.900624192069188,
+        3.3333618901542037,
+        0.42821914484805135,
+        -2.7793970447450915,
+        -0.40881233039958326,
+        -1.1973209086991168
+      ],
+      "mean": [
+        0.0,
+        971.3303112722876,
+        64.17527954064673,
+        62.25949261227415,
+        981.2040692465151,
+        9.873757974227486,
+        -1.9157869289489844,
+        1.5754004230885463,
+        1.5929283771532186
+      ],
+      "scale": [
+        1.0,
+        96.6811703822946,
+        33.65355257692086,
+        22.790069308723673,
+        22.401349860189654,
+        94.13272251001614,
+        23.452160129348044,
+        58.03843631538493,
+        6.204621897205797
+      ]
+    },
+    {
+      "beta": [
+        978.6816245816854,
+        0.45700856193464073,
+        -4.282115832870207,
+        -9.676417705655844,
+        3.202586323985946,
+        0.263424547765887,
+        -2.744635628620983,
+        -0.2812257628990227,
+        -1.2145691549473818
+      ],
+      "mean": [
+        0.0,
+        971.0885305749924,
+        64.04745968968665,
+        61.24103552841074,
+        982.0910472678383,
+        11.002516692845989,
+        -2.806424161275905,
+        1.5728627928202008,
+        1.6186492242166108
+      ],
+      "scale": [
+        1.0,
+        98.45100928052985,
+        33.671915141098914,
+        21.846830745260633,
+        22.00199125306356,
+        96.68925057678072,
+        24.488503386648656,
+        58.230564926174964,
+        6.192075094590328
+      ]
+    },
+    {
+      "beta": [
+        979.3450283438027,
+        0.5026116383483132,
+        -3.815461840782289,
+        -9.321996789582482,
+        3.1706830476456243,
+        0.1869869500870577,
+        -2.67047300578785,
+        -0.13156395947336183,
+        -1.321484648871915
+      ],
+      "mean": [
+        0.0,
+        970.8610387620653,
+        63.89229354986977,
+        60.07496924171664,
+        983.040380796722,
+        12.179342034656822,
+        -3.8173243087375806,
+        1.5874061590317143,
+        1.6341351309943313
+      ],
+      "scale": [
+        1.0,
+        100.23062800348737,
+        33.674191443192385,
+        21.02995207203543,
+        21.69896940964998,
+        98.52812879500274,
+        25.29834728692795,
+        58.4371110933118,
+        6.184937924572314
+      ]
+    },
+    {
+      "beta": [
+        980.105604446503,
+        0.4819710508401576,
+        -3.454897296475616,
+        -8.997754477229522,
+        2.9217652089719137,
+        0.13715468467271474,
+        -2.6075446851545543,
+        0.031810072532767186,
+        -1.467156119894784
+      ],
+      "mean": [
+        0.0,
+        970.6553960166743,
+        63.68905357418558,
+        58.87242237660589,
+        983.8862911363949,
+        13.230895119720502,
+        -4.816631199052089,
+        1.6220472440944882,
+        1.6265246255982708
+      ],
+      "scale": [
+        1.0,
+        102.0201408123609,
+        33.62765022480105,
+        20.411349603025727,
+        21.523634442810142,
+        100.00571132508524,
+        25.877311290276214,
+        58.65838429251217,
+        6.17016637339649
+      ]
+    },
+    {
+      "beta": [
+        980.9283154121864,
+        0.42406183474284354,
+        -3.101795843309463,
+        -8.59816263901043,
+        2.823608314829573,
+        0.16132514777708762,
+        -2.4809137481393724,
+        0.1604517720706006,
+        -1.5813368102627405
+      ],
+      "mean": [
+        0.0,
+        970.4040829047842,
+        63.52236247467664,
+        57.70297459142684,
+        984.7348281791393,
+        14.330745274355168,
+        -5.819387881169164,
+        1.6501480442574412,
+        1.619448340345956
+      ],
+      "scale": [
+        1.0,
+        103.88514324892287,
+        33.61229933848826,
+        19.754848726816206,
+        21.389626694015444,
+        101.29978840472074,
+        26.440624986798476,
+        58.92879090161479,
+        6.170992037104559
+      ]
+    },
+    {
+      "beta": [
+        981.8252993068684,
+        0.3282559402948829,
+        -2.7917770927328625,
+        -8.299277606331454,
+        2.6249222689964187,
+        0.20733431960316168,
+        -2.409438660750097,
+        0.24058273814096195,
+        -1.7023733781274468
+      ],
+      "mean": [
+        0.0,
+        970.11468178954,
+        63.39004410838059,
+        56.4489657036824,
+        985.5594694910368,
+        15.44478770149678,
+        -6.941078406200517,
+        1.6852551984877127,
+        1.613421550094518
+      ],
+      "scale": [
+        1.0,
+        105.82467616006231,
+        33.61784905160175,
+        19.14823400203281,
+        21.34911374648086,
+        102.74317126116405,
+        27.003378378170513,
+        59.243797369533446,
+        6.163178774221445
+      ]
+    },
+    {
+      "beta": [
+        982.781539444267,
+        0.31618464576562727,
+        -2.511209001172497,
+        -7.999402402069606,
+        2.497911494808863,
+        0.18749180315001615,
+        -2.3085711754224185,
+        0.2585546959223717,
+        -1.8317178283595457
+      ],
+      "mean": [
+        0.0,
+        970.1533056531459,
+        63.22868093260939,
+        55.3443473903031,
+        986.1220949673112,
+        15.96878931416524,
+        -7.884333544438428,
+        1.7376237623762376,
+        1.6045991695943789
+      ],
+      "scale": [
+        1.0,
+        106.49924076137351,
+        33.55507285388263,
+        18.482496364875466,
+        21.217461982998845,
+        103.07606579674263,
+        27.54307460962646,
+        59.64370137739178,
+        6.154107714919649
+      ]
+    },
+    {
+      "beta": [
+        983.7722258273848,
+        0.33981880304597933,
+        -2.2724190975909124,
+        -7.716540651393952,
+        2.487078414467849,
+        0.15245280072872294,
+        -2.188940669353884,
+        0.08654409924485539,
+        -1.8049092360904309
+      ],
+      "mean": [
+        0.0,
+        970.1787800129786,
+        63.05759247242051,
+        54.32578140431453,
+        987.0499083947857,
+        16.871128381807104,
+        -8.731811068724843,
+        1.6383841661258922,
+        1.5837118754055808
+      ],
+      "scale": [
+        1.0,
+        107.29605632482229,
+        33.53430196992395,
+        17.865324126234672,
+        21.019255280469395,
+        103.73911523783231,
+        28.166402893346593,
+        58.75240472843225,
+        6.141393220321764
+      ]
+    },
+    {
+      "beta": [
+        984.8051476654017,
+        0.3951285735895073,
+        -2.045812347972766,
+        -7.401342794020973,
+        2.5680992481457343,
+        0.10213632471215839,
+        -2.0796369943547277,
+        -0.0974652163959373,
+        -1.9027420660166647
+      ],
+      "mean": [
+        0.0,
+        970.1988120772149,
+        62.87163834350767,
+        53.108948937069755,
+        988.0273557485792,
+        17.82854367136424,
+        -9.76268940423507,
+        1.3928394654347467,
+        1.5367101138426003
+      ],
+      "scale": [
+        1.0,
+        108.15524982595403,
+        33.52528278502775,
+        17.333953998949035,
+        20.799190418897737,
+        104.55786154820235,
+        28.71080692804529,
+        56.37757439013659,
+        6.0910850383445165
+      ]
+    },
+    {
+      "beta": [
+        985.8285618053217,
+        0.44350304929556517,
+        -1.8276319568600226,
+        -7.161537529233555,
+        2.612368345826643,
+        0.055391102093499026,
+        -2.0487106124521177,
+        -0.10864333910550422,
+        -1.8863535960463707
+      ],
+      "mean": [
+        0.0,
+        970.2800606264735,
+        62.76507241495453,
+        51.71612292526145,
+        989.0245838364434,
+        18.744523209969817,
+        -11.048949497080926,
+        1.1162007409902324,
+        1.5151566183900302
+      ],
+      "scale": [
+        1.0,
+        108.48954799478317,
+        33.561878314366474,
+        16.93686204423229,
+        20.63978997941638,
+        104.76933022718211,
+        29.264807512918956,
+        53.89123657113572,
+        6.0795658479880625
+      ]
+    },
+    {
+      "beta": [
+        986.8479875626188,
+        0.470340939618217,
+        -1.6504285707864457,
+        -6.963977969610529,
+        2.5909179161370255,
+        0.02709494425615321,
+        -2.0348327401780897,
+        0.045200539893647855,
+        -1.722190325073895
+      ],
+      "mean": [
+        0.0,
+        970.663672482294,
+        62.6716185869753,
+        50.29897747716873,
+        989.9238731027123,
+        19.260200620418303,
+        -12.372641116066658,
+        0.833822767317326,
+        1.4964588011746416
+      ],
+      "scale": [
+        1.0,
+        107.56308024859545,
+        33.588233290907006,
+        16.634206748030838,
+        20.60855568110453,
+        103.4789331077719,
+        29.685587447486235,
+        51.321735772531284,
+        6.081771020585556
+      ]
+    }
+  ],
+  "pressure_anchor_alpha": [
+    0.5522160094389178,
+    0.6962881299556641,
+    0.7642130854290704,
+    0.8250283768554111,
+    0.8682641709344661,
+    0.8950311405808169,
+    0.912311094958641,
+    0.9251489323454353,
+    0.9362969190603518,
+    0.9450910275730012,
+    0.953263937622913,
+    0.9605904396465027,
+    0.9650098139429872,
+    0.9694222567928482,
+    0.973242185094525,
+    0.9765976015127111,
+    0.9792250259796094,
+    0.9817388698882592,
+    0.9835805375991149,
+    0.9838229441690179
+  ],
+  "pressure_anchor_policy": "validation-fitted blend with valid observed current pressure; no blend when current pressure is missing",
+  "wind_blend_alpha": [
+    1.0277212275681893,
+    1.1489795568075691,
+    1.0663403998709395,
+    1.0186010559120267,
+    0.987967013306198,
+    0.9650641191631195,
+    0.9444263916806881,
+    0.9282677834453357,
+    0.9083684904148223,
+    0.8944074477909971,
+    0.8800766496867902,
+    0.8649619816342672,
+    0.8518192654447947,
+    0.8413105316408789,
+    0.8368414301404576,
+    0.8366307550923628,
+    0.8418348967136898,
+    0.8466503456441108,
+    0.8586348526797178,
+    0.8755695728454723
+  ],
+  "structure_blend_features": [
+    "current_rmw_or_radius_native_nm",
+    "primary_structure_native_nm",
+    "optional_secondary_structure_expert_native_nm"
+  ],
+  "structure_blend_alpha": [
+    [
+      1.0,
+      1.0,
+      0.5549493412791997,
+      1.0,
+      0.9753869181876241,
+      0.6093764778483237,
+      0.6047313500745581,
+      0.6098850823506468,
+      0.592881985511388,
+      0.42590516633443765,
+      0.6195051390738097,
+      1.0,
+      0.5608806719907258
+    ],
+    [
+      1.0,
+      1.0,
+      0.7786456821183296,
+      1.0,
+      1.0,
+      0.8160746904360723,
+      0.7729585422358642,
+      0.8425760483695786,
+      0.8142225430932971,
+      0.7046296166746046,
+      0.7969846939122845,
+      1.0,
+      0.6884011708218611
+    ],
+    [
+      1.0,
+      1.0,
+      0.8090536105281151,
+      1.0,
+      1.0,
+      0.8471455035922965,
+      0.7857574635319617,
+      0.8874206525034055,
+      0.860082995947976,
+      0.8239691354642307,
+      0.8772408335676136,
+      1.0,
+      0.7127141967586793
+    ],
+    [
+      1.0,
+      1.0,
+      0.7979206267482302,
+      1.0,
+      1.0,
+      0.8513245701071473,
+      0.7557281044138736,
+      0.8953281132435532,
+      0.8823452204080448,
+      0.8994108661181437,
+      0.935888284206547,
+      1.0,
+      0.7614745781233312
+    ],
+    [
+      1.0,
+      1.0,
+      0.7889656833371654,
+      1.0,
+      0.9995282276968595,
+      0.813974979553649,
+      0.7261373602450153,
+      0.8520991012979712,
+      0.8571141216277187,
+      0.9547290251465658,
+      0.959194489030165,
+      1.0,
+      0.8093554855049242
+    ],
+    [
+      1.0,
+      1.0,
+      0.790841522213487,
+      1.0,
+      0.989425399763569,
+      0.7677379120463775,
+      0.6804313851656493,
+      0.8081026737119595,
+      0.8160784965854719,
+      0.9553568730634433,
+      0.94906212902518,
+      1.0,
+      0.8506601404079891
+    ],
+    [
+      1.0,
+      1.0,
+      0.7946505021912497,
+      1.0,
+      0.9842208422424614,
+      0.7309946140644263,
+      0.6519656259054535,
+      0.7832582102291513,
+      0.7751977883552036,
+      0.9498443768015948,
+      0.9364057805619501,
+      1.0,
+      0.8686047360783458
+    ],
+    [
+      1.0,
+      1.0,
+      0.8048051919510004,
+      1.0,
+      0.977409615843526,
+      0.7224643906694298,
+      0.6365795828673083,
+      0.766592821423072,
+      0.7398517247851228,
+      0.9404076028219883,
+      0.9255773996092755,
+      1.0,
+      0.86686536561545
+    ],
+    [
+      0.9989969287476876,
+      1.0,
+      0.8060150457554067,
+      1.0,
+      0.9635497591152855,
+      0.7298933141800126,
+      0.6276519134653644,
+      0.7587540062356607,
+      0.7370947132207954,
+      0.9282816956429373,
+      0.8960508524231412,
+      1.0,
+      0.8517048378522423
+    ],
+    [
+      0.9962949755088357,
+      1.0,
+      0.8024267962891638,
+      1.0,
+      0.9532191018037218,
+      0.7414856091287201,
+      0.629047832296785,
+      0.7588638521544967,
+      0.7411730238585288,
+      0.9244463977489501,
+      0.896517586802664,
+      1.0,
+      0.8363283369905071
+    ],
+    [
+      0.9906150062159008,
+      0.9928592943545933,
+      0.8017538447631487,
+      1.0,
+      0.9481221332985175,
+      0.7504970569022518,
+      0.6437585926652084,
+      0.7682739191164304,
+      0.7458488449448917,
+      0.9016502567528687,
+      0.9196549454100816,
+      1.0,
+      0.8222928380829917
+    ],
+    [
+      0.9872786368824288,
+      0.9870256484759862,
+      0.8036197038036084,
+      1.0,
+      0.9456840187031937,
+      0.7536197843475184,
+      0.6720399020859967,
+      0.7861770994146164,
+      0.7545241776213014,
+      0.8622271776091911,
+      0.9544728012066145,
+      1.0,
+      0.8091403753140322
+    ],
+    [
+      0.9858912730817866,
+      0.9782260755748675,
+      0.8224480738020116,
+      1.0,
+      0.9408562399433626,
+      0.751923185451568,
+      0.7079975704373077,
+      0.8081543972650469,
+      0.7607623883181744,
+      0.838646332479633,
+      1.0,
+      1.0,
+      0.8165953708628378
+    ],
+    [
+      0.9871317357369944,
+      0.9675020524431993,
+      0.8435905187514622,
+      1.0,
+      0.9354981762431331,
+      0.7469631531510479,
+      0.746366785020888,
+      0.8291036037207948,
+      0.7566102823880994,
+      0.8383450731194783,
+      1.0,
+      1.0,
+      0.826557900171084
+    ],
+    [
+      0.9854462797686748,
+      0.9575337922720787,
+      0.8632940254404728,
+      1.0,
+      0.9361793399856915,
+      0.7280315743113683,
+      0.7782362972629818,
+      0.8461591629929479,
+      0.7364949444253786,
+      0.8495574180679718,
+      1.0,
+      1.0,
+      0.8319355974514233
+    ],
+    [
+      0.9799350216481773,
+      0.948053493097228,
+      0.8777561442871291,
+      1.0,
+      0.9389259406046586,
+      0.7268423625933376,
+      0.8056289626997586,
+      0.858630296390731,
+      0.7303639110314664,
+      0.8680875406118934,
+      1.0,
+      1.0,
+      0.8546179948062796
+    ],
+    [
+      0.9740716852608886,
+      0.9403381171414777,
+      0.8814982444352361,
+      1.0,
+      0.9376654486264268,
+      0.720231177359567,
+      0.8229001102851932,
+      0.883352887181907,
+      0.7374999300634676,
+      0.862734447860439,
+      1.0,
+      1.0,
+      0.8757411053631797
+    ],
+    [
+      0.9686221325152385,
+      0.9305462545814487,
+      0.883874105956774,
+      1.0,
+      0.9383603227817988,
+      0.714941943020425,
+      0.8307300156928373,
+      0.9061038362396052,
+      0.7477493305948096,
+      0.8656451575094964,
+      1.0,
+      1.0,
+      0.9054612373084847
+    ],
+    [
+      0.9662039837991756,
+      0.9275664889767167,
+      0.8912243532082841,
+      1.0,
+      0.9403396402123274,
+      0.7157872514985167,
+      0.8458014076196586,
+      0.9215386465479368,
+      0.7592801106445597,
+      0.8765838611817265,
+      1.0,
+      1.0,
+      0.9177342044253676
+    ],
+    [
+      0.9568044542361462,
+      0.9385390035449604,
+      0.9215888189795768,
+      1.0,
+      0.9503495133295314,
+      0.7244552996295812,
+      0.8600858326127176,
+      0.9420104384137908,
+      0.7495840140906448,
+      0.9216970099860546,
+      1.0,
+      1.0,
+      0.9582402976615332
+    ]
+  ],
+  "checkpoint_root": "models/trackformer_1_1",
+  "structure_checkpoint_root": "models/trackformer_1_1",
+  "structure_expert_alpha": [
+    [
+      0.0,
+      0.9361481070518494,
+      0.934322714805603,
+      0.8858486413955688,
+      0.9938719272613525,
+      0.9489486813545227,
+      0.9187760949134827,
+      0.9228118062019348,
+      0.9387768507003784,
+      0.7600101828575134,
+      0.7809425592422485,
+      0.8700641393661499,
+      0.8380165100097656
+    ],
+    [
+      0.0,
+      0.7883517742156982,
+      0.8298157453536987,
+      0.7546190619468689,
+      0.891186535358429,
+      0.8175759315490723,
+      0.7462324500083923,
+      0.7695027589797974,
+      0.7692294716835022,
+      0.6570655107498169,
+      0.5868498086929321,
+      0.7810206413269043,
+      0.6184545159339905
+    ],
+    [
+      0.0,
+      0.6988456845283508,
+      0.7698739171028137,
+      0.6341904401779175,
+      0.781299352645874,
+      0.7261586785316467,
+      0.7200528383255005,
+      0.6777958273887634,
+      0.6547061204910278,
+      0.6781790852546692,
+      0.38850289583206177,
+      0.739601194858551,
+      0.4023652672767639
+    ],
+    [
+      0.0,
+      0.6077090501785278,
+      0.75852370262146,
+      0.5542184710502625,
+      0.668627917766571,
+      0.6401088833808899,
+      0.7013946771621704,
+      0.6870279908180237,
+      0.6323707103729248,
+      0.7411512136459351,
+      0.19386884570121765,
+      0.6939995288848877,
+      0.3757428824901581
+    ],
+    [
+      0.0,
+      0.5452795028686523,
+      0.8159465193748474,
+      0.5034195780754089,
+      0.5881041884422302,
+      0.6064771413803101,
+      0.7117744088172913,
+      0.6996253728866577,
+      0.6671974062919617,
+      0.7673929929733276,
+      0.1434878557920456,
+      0.6283478736877441,
+      0.3827730417251587
+    ],
+    [
+      0.0,
+      0.4475332498550415,
+      0.8445053696632385,
+      0.47751277685165405,
+      0.49595507979393005,
+      0.5493122339248657,
+      0.6586169004440308,
+      0.6564105749130249,
+      0.6699652671813965,
+      0.7021469473838806,
+      0.0653224065899849,
+      0.5543050765991211,
+      0.38605213165283203
+    ],
+    [
+      0.006327976007014513,
+      0.34530171751976013,
+      0.8709386587142944,
+      0.4365202486515045,
+      0.4342052638530731,
+      0.5322895646095276,
+      0.6248392462730408,
+      0.5894513726234436,
+      0.7012799382209778,
+      0.626562237739563,
+      0.015733113512396812,
+      0.44189080595970154,
+      0.42251747846603394
+    ],
+    [
+      0.005135390907526016,
+      0.2684456408023834,
+      0.8810635805130005,
+      0.4226278066635132,
+      0.39568835496902466,
+      0.5028242468833923,
+      0.6358619332313538,
+      0.5655720829963684,
+      0.7411352396011353,
+      0.5535630583763123,
+      0.0,
+      0.3738625943660736,
+      0.4239470660686493
+    ],
+    [
+      0.023205677047371864,
+      0.21901144087314606,
+      0.8607876896858215,
+      0.43362921476364136,
+      0.3754803538322449,
+      0.5236393809318542,
+      0.6005999445915222,
+      0.5589695572853088,
+      0.7332651615142822,
+      0.47174206376075745,
+      0.009717775508761406,
+      0.35761409997940063,
+      0.4059191644191742
+    ],
+    [
+      0.038556747138500214,
+      0.1978488266468048,
+      0.834216296672821,
+      0.4369942843914032,
+      0.3645400106906891,
+      0.5292827486991882,
+      0.556195855140686,
+      0.5879309773445129,
+      0.7033751010894775,
+      0.4590916037559509,
+      0.06794524937868118,
+      0.3964718282222748,
+      0.42892006039619446
+    ],
+    [
+      0.0822339728474617,
+      0.15992115437984467,
+      0.7834641337394714,
+      0.42339903116226196,
+      0.34574249386787415,
+      0.48923566937446594,
+      0.5099923610687256,
+      0.627753496170044,
+      0.6312965750694275,
+      0.4491918981075287,
+      0.08122247457504272,
+      0.33692267537117004,
+      0.465788871049881
+    ],
+    [
+      0.11642027646303177,
+      0.118315190076828,
+      0.7409539222717285,
+      0.4470598101615906,
+      0.3227274417877197,
+      0.4294480085372925,
+      0.49222809076309204,
+      0.7322760820388794,
+      0.5469415783882141,
+      0.36480313539505005,
+      0.024686744436621666,
+      0.2646491229534149,
+      0.4103580713272095
+    ],
+    [
+      0.1868918538093567,
+      0.10242144018411636,
+      0.6756333708763123,
+      0.4364897906780243,
+      0.290968120098114,
+      0.4043419063091278,
+      0.45341530442237854,
+      0.7665934562683105,
+      0.5088798999786377,
+      0.24618837237358093,
+      0.0,
+      0.16969110071659088,
+      0.35006994009017944
+    ],
+    [
+      0.2503180205821991,
+      0.1268322765827179,
+      0.5735778212547302,
+      0.4366355836391449,
+      0.30388057231903076,
+      0.442385733127594,
+      0.398971289396286,
+      0.7520959377288818,
+      0.5388989448547363,
+      0.26548394560813904,
+      0.008171271532773972,
+      0.1257970780134201,
+      0.3485977053642273
+    ],
+    [
+      0.2900908887386322,
+      0.16893012821674347,
+      0.4577920436859131,
+      0.4277336597442627,
+      0.3232477009296417,
+      0.531777560710907,
+      0.39727750420570374,
+      0.6795014142990112,
+      0.48868805170059204,
+      0.2898959517478943,
+      0.1418028324842453,
+      0.12177688628435135,
+      0.2917960286140442
+    ],
+    [
+      0.2792268693447113,
+      0.2319025993347168,
+      0.4227851331233978,
+      0.44706737995147705,
+      0.3128238320350647,
+      0.6999660134315491,
+      0.43848201632499695,
+      0.5300739407539368,
+      0.39969006180763245,
+      0.39730560779571533,
+      0.26391106843948364,
+      0.18718558549880981,
+      0.33163970708847046
+    ],
+    [
+      0.28902363777160645,
+      0.28392016887664795,
+      0.4272365868091583,
+      0.5053210854530334,
+      0.2757094204425812,
+      0.8456398248672485,
+      0.4518815577030182,
+      0.45749273896217346,
+      0.3181617558002472,
+      0.4448428452014923,
+      0.3280032277107239,
+      0.21995072066783905,
+      0.40605419874191284
+    ],
+    [
+      0.30310046672821045,
+      0.3220006227493286,
+      0.4188046455383301,
+      0.5786864757537842,
+      0.2313844859600067,
+      0.9909186959266663,
+      0.3816840648651123,
+      0.41152098774909973,
+      0.2809295356273651,
+      0.5186776518821716,
+      0.4197472035884857,
+      0.19759920239448547,
+      0.5271488428115845
+    ],
+    [
+      0.3526214361190796,
+      0.35234275460243225,
+      0.43079662322998047,
+      0.5791170597076416,
+      0.1899081915616989,
+      1.0,
+      0.36282944679260254,
+      0.3539854884147644,
+      0.28582316637039185,
+      0.496574729681015,
+      0.43650829792022705,
+      0.10935331135988235,
+      0.5543745160102844
+    ],
+    [
+      0.41773712635040283,
+      0.3903321921825409,
+      0.47357064485549927,
+      0.5240141749382019,
+      0.20888248085975647,
+      1.0,
+      0.37714311480522156,
+      0.2732824683189392,
+      0.40228506922721863,
+      0.46711480617523193,
+      0.3247523307800293,
+      0.06386715173721313,
+      0.638704240322113
+    ]
+  ],
+  "structure_native_unit": "nautical_miles",
+  "track_input_clip": {
+    "method": "per-feature 0.1%-99.9% bounds from train split only",
+    "quantiles": [
+      0.001,
+      0.999
+    ],
+    "lower": [
+      -3.8563146591186523,
+      -3.859726667404175,
+      -2.669590950012207,
+      -2.828439712524414,
+      -1.514838695526123,
+      -0.877439558506012,
+      -0.20029544830322266,
+      -0.5029191970825195,
+      -0.4581102430820465,
+      -0.4543793201446533,
+      -0.44044506549835205,
+      -0.4524264335632324,
+      -0.32242000102996826,
+      -0.3159736096858978,
+      -0.31081247329711914,
+      -0.31689807772636414,
+      -0.2571345567703247,
+      -0.25485461950302124,
+      -0.25090861320495605,
+      -0.253328412771225,
+      0.0,
+      -1.109837293624878,
+      -1.4902359247207642,
+      -1.5492080450057983,
+      -3.043226718902588,
+      -0.8778678178787231,
+      -0.22049888968467712,
+      -0.6087565422058105,
+      -0.5303210616111755,
+      -0.5303064584732056,
+      -0.530174195766449,
+      -0.5302548408508301,
+      -0.3700577914714813,
+      -0.3699590861797333,
+      -0.36966797709465027,
+      -0.36991986632347107,
+      -0.28939348459243774,
+      -0.2892126142978668,
+      -0.2889581322669983,
+      -0.2892405688762665,
+      -1.000949740409851,
+      -1.9555184841156006,
+      -1.3818809986114502,
+      -3.743236541748047,
+      -4.178081035614014,
+      -7.5739426612854,
+      -1.9869922399520874,
+      -0.791445791721344,
+      -1.895654320716858,
+      -1.900766134262085,
+      -1.8269368410110474,
+      -1.1999244689941406,
+      -1.2392349243164062,
+      -1.5779284238815308
+    ],
+    "upper": [
+      3.46697735786438,
+      2.962402105331421,
+      3.792782783508301,
+      3.5486209392547607,
+      3.303658962249756,
+      1.1986064910888672,
+      9.119026184082031,
+      6.6407904624938965,
+      5.609043598175049,
+      5.1235761642456055,
+      5.236553192138672,
+      5.678617000579834,
+      6.238978385925293,
+      6.22589635848999,
+      6.73668098449707,
+      6.552648067474365,
+      7.652637958526611,
+      7.037979602813721,
+      6.988698482513428,
+      7.6510162353515625,
+      0.0,
+      1.7232352495193481,
+      1.4755607843399048,
+      1.5490014553070068,
+      0.3285984992980957,
+      1.1391236782073975,
+      4.535170078277588,
+      1.6426928043365479,
+      1.8856501579284668,
+      1.8857020139694214,
+      1.8861727714538574,
+      1.88588547706604,
+      2.7022807598114014,
+      2.7030017375946045,
+      2.705130100250244,
+      2.7032880783081055,
+      3.45550274848938,
+      3.4576637744903564,
+      3.460709571838379,
+      3.457329511642456,
+      2.0224556922912598,
+      1.5678421258926392,
+      4.212479591369629,
+      3.814079999923706,
+      4.954610824584961,
+      5.965235233306885,
+      0.5032732486724854,
+      1.2635104656219482,
+      2.1631147861480713,
+      3.6985673904418945,
+      1.0047227144241333,
+      2.321204662322998,
+      3.150118350982666,
+      1.4707427024841309
+    ]
+  },
+  "temporal_checkpoint_root": "models/trackformer_1_1",
+  "temporal_wind_blend_alpha": [
+    1.006157773537495,
+    1.082670297723516,
+    1.0076812926999208,
+    0.9684541176843595,
+    0.937035559922028,
+    0.9061196390585828,
+    0.8828505612779566,
+    0.8649551163976384,
+    0.850160066458564,
+    0.8436538164907559,
+    0.8360733120277236,
+    0.8246513293372426,
+    0.8130469984314852,
+    0.8040146581229802,
+    0.8026821984394348,
+    0.806057957319184,
+    0.8108057351642745,
+    0.8134246099298341,
+    0.8212623454663425,
+    0.8365160626176127
+  ],
+  "temporal_wind_min_current_kt": 80.0,
+  "temporal_wind_metrics": {
+    "val": {
+      "all_leads_kt": 16.9397,
+      "lead_120h_kt": 21.4157
+    },
+    "test": {
+      "all_leads_kt": 16.3692,
+      "lead_120h_kt": 20.328
+    }
+  },
+  "temporal_input_policy": "same-storm t-12 h and t-24 h dlm4 analysis patches; no future atmospheric fields",
+  "pressure_policy": "retain the calibrated pressure path; temporal branch is wind-only"
+}

v23_terrain_wp.npz → models/trackformer_1_1/trackformer_1_1_intensity_seed0.pt

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6b0f49401b54cb40b566fd96c6db86a2e9ef1ccf31fabc685e73b13ef6e7ba14
-size 164910
+oid sha256:f26a55bb3db6e88a69656e2633e8316f71698866d4be4c336a1b2524a5f58401
+size 8896661

best.pt → models/trackformer_1_1/trackformer_1_1_intensity_seed1.pt

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ea6e045bea4e354c36b7fc0ccb72de99efa5634ad813de96e545aed4d7c2840e
-size 1436940
+oid sha256:74c379bda87dd52a3d7558d58110d104e427d7972ad59e2dca02b4e61b641e1c
+size 8896725

v23_seed1.pt → models/trackformer_1_1/trackformer_1_1_intensity_seed2.pt

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0aeda7ef5f821983661590daf65add15530ee9ed2a84ac8d862296b3edafaabd
-size 52625227
+oid sha256:7023a827ebc100d19a70183e5ffe9f23023da58c178eb9fcd668d681a2c90b53
+size 8896661

v23_seed2.pt → models/trackformer_1_1/trackformer_1_1_structure_seed0.pt

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:efd58477767017dbb88c0db74c01f39ee36ae30444db55333865aa1e8d97b2fa
-size 52625227
+oid sha256:46a2d38cae5ce1cb727f589d5dbd969a05480aaf32e3b33d4b7ab3e285beb42a
+size 8896961

models/trackformer_1_1/trackformer_1_1_structure_seed1.pt

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

models/trackformer_1_1/trackformer_1_1_structure_seed2.pt

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

models/trackformer_1_1/trackformer_1_1_temporal_seed0.pt

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

models/trackformer_1_1/trackformer_1_1_temporal_seed1.pt

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

models/trackformer_1_1/trackformer_1_1_temporal_seed2.pt

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

requirements.txt

@@ -1,5 +1,3 @@
-numpy==2.5.1
-torch==2.13.0
-scikit-learn==1.9.0
-matplotlib==3.11.0
-folium==0.20.0
+numpy>=1.26
+torch>=2.1
+scipy>=1.11

run_inference.py

@@ -1,94 +0,0 @@
-import json
-import argparse
-from pathlib import Path
-import numpy as np
-import torch
-from torch import nn
-
-ROOT = Path(__file__).resolve().parent
-parser = argparse.ArgumentParser(description="Run the Bavi typhoon checkpoint locally.")
-parser.add_argument("--checkpoint", type=Path, default=ROOT / "best.pt")
-parser.add_argument("--output", type=Path, default=ROOT / "forecast.json")
-parser.add_argument("--device", choices=["auto", "mps", "cpu"], default="auto")
-args = parser.parse_args()
-CKPT = args.checkpoint.expanduser().resolve()
-OUT = args.output.expanduser().resolve()
-
-class FieldEncoder(nn.Module):
-    def __init__(self, channels, hidden=128):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.Conv2d(channels,64,3,padding=1), nn.GELU(), nn.BatchNorm2d(64),
-            nn.Conv2d(64,96,3,stride=2,padding=1), nn.GELU(), nn.BatchNorm2d(96),
-            nn.Conv2d(96,hidden,3,stride=2,padding=1), nn.GELU(),
-            nn.AdaptiveAvgPool2d(1))
-    def forward(self, x): return self.net(x).flatten(1)
-
-class ERA5CycloneEnsemble(nn.Module):
-    def __init__(self, track_dim, channels, steps, output_dim, hidden=192, latent=32):
-        super().__init__()
-        self.steps, self.output_dim, self.latent = steps, output_dim, latent
-        self.field = FieldEncoder(channels, 128)
-        self.track_gru = nn.GRU(track_dim,96,batch_first=True,bidirectional=True)
-        self.fuse = nn.Sequential(nn.Linear(128*steps+192,hidden),nn.GELU(),nn.Dropout(.15),nn.Linear(hidden,hidden),nn.GELU())
-        self.mean = nn.Linear(hidden,output_dim)
-        self.log_scale = nn.Linear(hidden,output_dim)
-        self.latent_proj = nn.Sequential(nn.Linear(latent,hidden),nn.GELU(),nn.Linear(hidden,output_dim))
-    def encode(self, track_x, field_x):
-        b,t,c,h,w=field_x.shape
-        field_z=self.field(field_x.reshape(b*t,c,h,w)).reshape(b,t,-1).flatten(1)
-        _,state=self.track_gru(track_x)
-        return self.fuse(torch.cat([field_z,state.transpose(0,1).flatten(1)],dim=1))
-    def sample(self, track_x, field_x, n, temperature=1.0):
-        z=self.encode(track_x,field_x)
-        mean=self.mean(z); log_scale=self.log_scale(z).clamp(-5,2)
-        eps=torch.randn(n,z.shape[0],self.latent,device=z.device)
-        low=self.latent_proj(eps.reshape(-1,self.latent)).reshape(n,z.shape[0],-1)
-        independent=torch.randn_like(low)*torch.exp(log_scale).unsqueeze(0)
-        return mean.unsqueeze(0)+temperature*(low+independent)
-
-raw=torch.load(CKPT,map_location="cpu",weights_only=False)
-if args.device == "mps":
-    device = torch.device("mps")
-elif args.device == "cpu":
-    device = torch.device("cpu")
-else:
-    device=torch.device("mps" if torch.backends.mps.is_available() else "cpu")
-config=raw["config"]
-track_scaler=raw["track_scaler"]; y_scaler=raw["y_scaler"]
-field_mean=np.asarray(raw["field_mean"],dtype="float32")
-field_std=np.asarray(raw["field_std"],dtype="float32")
-model=ERA5CycloneEnsemble(9,10,1,28).to(device)
-model.load_state_dict(raw["model_state"]); model.eval()
-
-fixes=[
-    ("2026-07-09T12:00:00",19.2,128.8,100,952),
-    ("2026-07-09T18:00:00",20.1,128.2,90,953),
-    ("2026-07-10T00:00:00",20.8,127.3,75,964),
-    ("2026-07-10T06:00:00",21.9,126.9,75,962),
-]
-track=[]
-for i,(stamp,lat,lon,wind,pres) in enumerate(fixes):
-    dlat=0 if i==0 else lat-fixes[i-1][1]
-    dlon=0 if i==0 else ((lon-fixes[i-1][2]+180)%360)-180
-    track.append([lat,lon,wind,pres,dlat,dlon,float(np.hypot(dlat,dlon)),np.sin(2*np.pi*191/366),np.cos(2*np.pi*191/366)])
-track=np.asarray(track,dtype="float32")
-track[:,:1]-=track[-1:,0:1]
-track[:,1:2]=((track[:,1:2]-track[-1:,1:2]+180)%360)-180
-track[:,2]/=100.0
-track[:,3]=(track[:,3]-950.0)/50.0
-xtrack=track_scaler.transform(track).astype("float32")[None]
-field=np.zeros((1,1,10,33,33),dtype="float32")
-with torch.no_grad():
-    ens=model.sample(torch.from_numpy(xtrack).to(device),torch.from_numpy(field).to(device),50,float(config.get("sample_temperature",1.0))).cpu().numpy()
-ens=ens.mean(0,keepdims=True)+(ens-ens.mean(0,keepdims=True))*1.1297996044158936
-pred=y_scaler.inverse_transform(ens[:,0,:])
-base_lat,base_lon=fixes[-1][1],fixes[-1][2]
-points=[]
-for k,lead in enumerate(config["lead_hours"]):
-    j=4*k
-    lat=base_lat+pred[:,j]; lon=(base_lon+pred[:,j+1])%360
-    points.append({"lead_hours":int(lead),"lat":float(lat.mean()),"lon":float(lon.mean()),"p10_lat":float(np.quantile(lat,.1)),"p90_lat":float(np.quantile(lat,.9)),"p10_lon":float(np.quantile(lon,.1)),"p90_lon":float(np.quantile(lon,.9))})
-result={"storm":"Bavi","source":"JTWC/TCGP fixes through 2026-07-10 0600 UTC","initial_time":"2026-07-10T06:00:00Z","initial_lat":base_lat,"initial_lon":base_lon,"points":points,"device":str(device),"note":"Mac checkpoint inference using current track fixes and mean-normalized atmospheric input because 2026 ERA5 fields are unavailable locally. Not an operational forecast."}
-OUT.write_text(json.dumps(result,indent=2))
-print(json.dumps(result,indent=2))

run_v23.py

@@ -1,222 +0,0 @@
-"""Run TrackFormer v23 on a storm's track history, in either of two modes:
-
-  IBTrACS-only (default, no --steering given): the model sees only the storm's own recent
-  positions/wind/pressure -- exactly what IBTrACS (or any best-track record) gives you for a past
-  storm, nothing else. The steering field and its 12h/24h history are zero-filled with an explicit
-  availability flag, the same "unavailable == exact zeros, not fabricated" convention used
-  throughout this project whenever a field genuinely isn't there.
-
-  Full data (--steering given): the model additionally sees a real deep-layer-mean steering-wind
-  patch (850/500/200 hPa u/v, weighted 0.269/0.500/0.231) around the storm -- for the current fix
-  and, if present, t-12h/t-24h. This is what the project's headline 434.96 km number requires; on
-  Typhoon Dolphin (2026) zeroing this field out shifted the 120h forecast position by ~600 km while
-  softening the intensity forecast only modestly (99 -> 90 kt) -- see the project's README for the
-  full ablation.
-
-Usage:
-    python run_v23.py --track my_storm.json --out forecast.json
-    python run_v23.py --track my_storm.json --steering my_steering.npz --out forecast.json
-
---track JSON format: a list of fixes, OLDEST to NEWEST, spaced 6 hours apart, ending at the fix to
-forecast from ("now"). Up to 9 fixes are used (fewer is fine -- the model pads with the same
-pre-genesis zero-fill it saw for young storms in training); extra leading fixes beyond 9 are
-ignored.
-    [{"time": "2026-07-29T00:00", "lat": 14.1, "lon": 169.1, "vmax_kt": 121.6, "pres_hpa": 941},
-     {"time": "2026-07-29T06:00", "lat": 14.5, "lon": 168.4, "vmax_kt": 121.7, "pres_hpa": 941}]
-`pres_hpa` may be null/omitted per-fix if unknown -- it is then treated as unavailable for that fix
-(zero-filled, flagged), not fabricated.
-
---steering NPZ format (optional): float32 arrays of shape [2,17,17] (u,v in m/s, 2.5 deg
-resolution, +-20 deg box centered on the storm), keyed by ISO time strings matching entries in
---track (e.g. "2026-07-29T06:00"). Only the LAST fix's key is required; keys for the fixes 12h and
-24h before it are used for v23's temporal-history stack if present, and zero-filled (flagged
-unavailable) if not -- so a steering file with only the current fix still runs, just without the
-temporal-history benefit. See _fetch_dolphin_steering.py in the repo root for a working example of
-building this from NOAA/NOMADS GFS analysis fields for a live storm, or from ERA5 for a past one.
-"""
-import argparse
-import json
-import math
-import os
-import sys
-
-import numpy as np
-import torch
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from trackformer_v23 import build_v23, TMEAN, TSTD, DSC, TARGET_SCALE  # noqa: E402
-
-R = 111.2       # km per degree latitude
-HIST = 9        # kinematic-history window length the model was trained with
-
-_here = os.path.dirname(os.path.abspath(__file__))
-_terrain = np.load(os.path.join(_here, "v23_terrain_wp.npz"))
-_T_LAT, _T_LON, _LSM = _terrain["lat"], _terrain["lon"], _terrain["lsm"]
-_LAND = _LSM > 0.5
-_LAND_LAT = _T_LAT[np.where(_LAND)[0]]
-_LAND_LON = _T_LON[np.where(_LAND)[1]]
-
-
-def dist2land(lat_i, lon_i):
-    if len(_LAND_LAT) == 0:
-        return 3000.0
-    dlat = _LAND_LAT - lat_i
-    dlon = (_LAND_LON - lon_i) * math.cos(math.radians(lat_i))
-    return float(np.hypot(dlon * R, dlat * R).min())
-
-
-def load_track(path):
-    fixes = json.load(open(path))
-    fixes = fixes[-HIST:] if len(fixes) > HIST else fixes
-    times = [f["time"] for f in fixes]
-    lat = np.array([f["lat"] for f in fixes], dtype="float64")
-    lon = np.array([f["lon"] for f in fixes], dtype="float64")
-    vmax = np.array([f["vmax_kt"] for f in fixes], dtype="float64")
-    pres = np.array([f.get("pres_hpa", None) if f.get("pres_hpa", None) is not None else np.nan
-                      for f in fixes], dtype="float64")
-    tns = np.array([np.datetime64(t).astype("datetime64[ns]").astype("int64") for t in times])
-    return times, tns, lat, lon, vmax, pres
-
-
-def build_window(times, tns, lat, lon, vmax, pres):
-    """Kinematic/thermodynamic feature window -- same construction as this project's other
-    real-storm inference scripts (e.g. _dolphin_v23_v35.py / _noul_v33.py)."""
-    n = len(times)
-    base = n - 1
-    hidx = [max(0, base - HIST + 1 + k) for k in range(HIST)]
-    n_padded = max(0, HIST - 1 - base)
-    t0 = int(tns[base])
-    doy = (np.datetime64(times[base]) - np.datetime64(times[base][:4] + "-01-01")).astype(int) + 1
-    phase = 2 * math.pi * doy / 365.25
-    seq = np.zeros((HIST, 54), dtype="float32")
-    prev, pdir = -1, None
-
-    def mkm(a, b, c, d):
-        dlat = c - a; dlon = ((d - b + 180) % 360) - 180
-        return dlon * R * math.cos(math.radians((a + c) / 2)), dlat * R
-
-    for i, idx in enumerate(hidx):
-        e, n_ = mkm(lat[base], lon[base], lat[idx], lon[idx])
-        se, sn = (0., 0.) if prev < 0 else mkm(lat[prev], lon[prev], lat[idx], lon[idx])
-        f = seq[i]; f[0:4] = [e, n_, se, sn]
-        vv = [vmax[idx], pres[idx], np.nan, np.nan]
-        for j in range(4):
-            f[4 + j] = vv[j] if np.isfinite(vv[j]) else 0.
-        f[24:28] = [float(np.isfinite(x)) for x in vv]
-        f[21:23] = [math.sin(phase), math.cos(phase)]; f[23] = (t0 - int(tns[idx])) / 3.6e12
-        sp = math.hypot(se, sn); hs, hc = (se / sp, sn / sp) if (sp > 1e-3 and prev >= 0) else (0., 0.)
-        f[40], f[41], f[42] = hs, hc, sp
-        f[43] = (pdir[0] * hc - pdir[1] * hs) if (pdir and (hs or hc) and (pdir[0] or pdir[1])) else 0.
-        if prev >= 0:
-            dv = np.isfinite(vmax[prev]) and np.isfinite(vmax[idx])
-            dp = np.isfinite(pres[prev]) and np.isfinite(pres[idx])
-            f[44] = vmax[idx] - vmax[prev] if dv else 0.
-            f[45] = pres[idx] - pres[prev] if dp else 0.
-            f[46], f[47] = float(dv), float(dp)
-        lat_i, lon_i = lat[idx], lon[idx]
-        m = np.datetime64(times[idx]).astype("datetime64[M]").astype(int) % 12 + 1
-        d2l = dist2land(lat_i, lon_i % 360)
-        thermal = 0.5 * 23.44 * math.sin(2 * math.pi * (m - 3) / 12.0)
-        f[48] = lat_i; f[49] = abs(lat_i); f[50] = math.sin(math.radians(lon_i)); f[51] = math.cos(math.radians(lon_i))
-        f[52] = d2l; f[53] = max(0., min(31., 30. - 0.30 * abs(lat_i - thermal) ** 1.4))
-        if hs or hc:
-            pdir = (hs, hc)
-        prev = idx
-
-    seq_n = (seq - TMEAN) / TSTD
-    vpair = np.concatenate([seq[-1, 2:4], seq[-2, 2:4]]).astype("float32")
-    return seq_n, vpair, n_padded
-
-
-def load_steering(path, times):
-    """Returns (slp[1,4,17,17], hist[1,8,17,17], have[1,2]) for the LAST fix in `times`. `path` may
-    be None -- then everything is zero-filled (the IBTrACS-only ablation)."""
-    if path is None:
-        return (np.zeros((1, 4, 17, 17), "float32"),
-                np.zeros((1, 8, 17, 17), "float32"),
-                np.zeros((1, 2), "float32"))
-    dlm = np.load(path)
-    now_t = np.datetime64(times[-1])
-
-    def key_at(back_h):
-        return str(now_t - np.timedelta64(back_h, "h"))
-
-    slp = np.zeros((1, 4, 17, 17), "float32")
-    now_key = times[-1]
-    if now_key in dlm:
-        uv = dlm[now_key]
-        slp[0, 2:4] = np.clip(uv / DSC[:, None, None], -4.0, 4.0)
-    elif key_at(0) in dlm:
-        uv = dlm[key_at(0)]
-        slp[0, 2:4] = np.clip(uv / DSC[:, None, None], -4.0, 4.0)
-
-    hist = np.zeros((1, 8, 17, 17), "float32")
-    have = np.zeros((1, 2), "float32")
-    cur = slp[0]
-    for c, back in enumerate((12, 24)):
-        k = key_at(back)
-        if k in dlm:
-            uv = dlm[k]
-            hist[0, c * 4 + 2:c * 4 + 4] = np.clip(uv / DSC[:, None, None], -4.0, 4.0)
-            have[0, c] = 1.0
-        else:
-            hist[0, c * 4:(c + 1) * 4] = cur
-    return slp, hist, have
-
-
-@torch.no_grad()
-def forecast(models, times, tns, lat, lon, vmax, pres, steering_path):
-    seq_n, vpair, n_padded = build_window(times, tns, lat, lon, vmax, pres)
-    tr = torch.from_numpy(seq_n[None]); vp = torch.from_numpy(vpair[None])
-    slp, hist, have = load_steering(steering_path, times)
-    args = [tr, vp, torch.from_numpy(slp), torch.from_numpy(hist), torch.from_numpy(have)]
-    motion = torch.stack([m(*args)[0] for m in models]).mean(0)[0] * TARGET_SCALE
-    motion = motion.float().numpy()   # [20, 17]
-    la, lo = float(lat[-1]), float(lon[-1])
-    lats, lons, vmaxs, presses = [], [], [], []
-    for L in range(20):
-        e, n_ = motion[L, 0], motion[L, 1]
-        la = la + n_ / R; lo = lo + e / (R * math.cos(math.radians(la)))
-        lats.append(la); lons.append(lo)
-        vmaxs.append(float(motion[L, 2])); presses.append(float(motion[L, 3]))
-    return lats, lons, vmaxs, presses, n_padded
-
-
-def main():
-    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
-    ap.add_argument("--track", required=True, help="track-history JSON, see module docstring")
-    ap.add_argument("--steering", default=None, help="steering NPZ (omit for IBTrACS-only mode)")
-    ap.add_argument("--seeds", default=os.path.join(_here, "v23_seed*.pt"), help="checkpoint glob")
-    ap.add_argument("--out", default=None, help="write forecast JSON here (default: stdout)")
-    args = ap.parse_args()
-
-    import glob
-    ckpts = sorted(glob.glob(args.seeds))
-    if not ckpts:
-        sys.exit(f"no checkpoints matched {args.seeds!r}")
-    models = []
-    for c in ckpts:
-        m = build_v23().eval()
-        m.load_state_dict(torch.load(c, map_location="cpu", weights_only=False)["model"])
-        models.append(m)
-    mode = "IBTrACS-only (steering zeroed)" if args.steering is None else f"full data ({args.steering})"
-    print(f"loaded {len(models)} v23 seeds, mode: {mode}", file=sys.stderr)
-
-    times, tns, lat, lon, vmax, pres = load_track(args.track)
-    lats, lons, vmaxs, presses, n_padded = forecast(models, times, tns, lat, lon, vmax, pres, args.steering)
-
-    out = {"issue_time": times[-1], "mode": mode, "base_lat": float(lat[-1]), "base_lon": float(lon[-1]),
-           "lead_hours": list(range(6, 121, 6)),
-           "lats": [round(float(x), 3) for x in lats], "lons": [round(float(x), 3) for x in lons],
-           "vmax_kt": [round(float(x), 1) for x in vmaxs], "pres_hpa": [round(float(x), 1) for x in presses],
-           "n_padded_history": n_padded}
-    text = json.dumps(out, indent=2)
-    if args.out:
-        open(args.out, "w").write(text)
-        print(f"wrote {args.out}", file=sys.stderr)
-    else:
-        print(text)
-
-
-if __name__ == "__main__":
-    main()

trackformer_1_1.py

@@ -0,0 +1,35 @@
+"""Public Trackformer1.1 loading and inference API."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from trackformer_1_1_intensity import Trackformer11IntensityEnsemble
+from trackformer_1_1_route import (
+    LEAD_HOURS,
+    build_pacific_route,
+    detect_pressure_systems,
+    forecast_pacific_state,
+)
+
+
+PACKAGE_ROOT = Path(__file__).resolve().parent
+MODEL_ROOT = PACKAGE_ROOT / "models" / "trackformer_1_1"
+CALIBRATION_PATH = MODEL_ROOT / "trackformer_1_1_calibration.json"
+
+
+def load_intensity(device: str | None = None) -> Trackformer11IntensityEnsemble:
+    """Load the frozen Trackformer1.1 intensity and structure experts."""
+
+    return Trackformer11IntensityEnsemble(MODEL_ROOT, CALIBRATION_PATH, device=device)
+
+
+__all__ = [
+    "CALIBRATION_PATH",
+    "LEAD_HOURS",
+    "MODEL_ROOT",
+    "build_pacific_route",
+    "detect_pressure_systems",
+    "forecast_pacific_state",
+    "load_intensity",
+]

trackformer_1_1_base_route.py

@@ -0,0 +1,419 @@
+#!/usr/bin/env python3
+"""Causal large-system steering ensemble for out-of-archive cases.
+
+Trackformer1.1 is a physical route candidate, not a consensus of official forecasts.
+Each member reads only analysis snapshots at or before the issue time.  It
+samples multiple pressure levels over inner and synoptic-scale rings around
+the evolving center, and a small SLP-gradient component can represent the
+large-scale pressure field.  The final route is the weighted mean of the
+integrated members so curvature and disagreement remain visible.
+
+Input field layout:
+    fields: (snapshots, 7, latitude, longitude)
+    channels: hgt500, u850, v850, u500, v500, u200, v200
+    snapshots: current, t-12, t-24 (earlier snapshots may be zeroed)
+    pressure: (snapshots, latitude, longitude) SLP in hPa, optional
+
+No forecast lead field, official forecast track, or future observation is
+accepted by this module.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Sequence
+
+import numpy as np
+
+
+VERSION = "Trackformer1.1-causal-dynamic-big-system-steering-ensemble"
+LEADS = 20
+LEVEL_WEIGHTS = np.asarray([0.269, 0.500, 0.231], dtype="float32")
+MOTION_SLOPES = np.asarray([0.76, 0.78], dtype="float32")
+MOTION_INTERCEPTS = np.asarray([-2.03, 0.40], dtype="float32")
+TENDENCY_SCALES = (0.0, 0.65, 1.25)
+TENDENCY_SCALE_WEIGHTS = (0.15, 0.45, 0.40)
+
+
+ROUTE_VARIANTS = (
+    {
+        "name": "inner_850",
+        "level_weights": (1.0, 0.0, 0.0),
+        "ring_degrees": (3.0, 5.0),
+        "pressure_fraction": 0.00,
+        "weight": 0.30,
+    },
+    {
+        "name": "deep_layer_inner",
+        "level_weights": (0.269, 0.500, 0.231),
+        "ring_degrees": (3.0, 8.0),
+        "pressure_fraction": 0.04,
+        "weight": 0.22,
+    },
+    {
+        "name": "broad_850_ridge",
+        "level_weights": (1.0, 0.0, 0.0),
+        "ring_degrees": (5.0, 11.0),
+        "pressure_fraction": 0.05,
+        "weight": 0.16,
+    },
+    {
+        "name": "broad_500_trough",
+        "level_weights": (0.0, 1.0, 0.0),
+        "ring_degrees": (5.0, 12.0),
+        "pressure_fraction": 0.04,
+        "weight": 0.12,
+    },
+    {
+        "name": "synoptic_deep",
+        "level_weights": (0.269, 0.500, 0.231),
+        "ring_degrees": (7.0, 16.0),
+        "pressure_fraction": 0.10,
+        "weight": 0.12,
+    },
+    {
+        "name": "outer_200_jet",
+        "level_weights": (0.0, 0.0, 1.0),
+        "ring_degrees": (8.0, 18.0),
+        "pressure_fraction": 0.02,
+        "weight": 0.08,
+    },
+)
+CURVATURE_VARIANTS = (0.0, 0.20, 0.40)
+SNAPSHOT_WEIGHTS = (0.50, 0.30, 0.20)
+
+
+def _sorted_axes(latitude: np.ndarray, longitude: np.ndarray, field: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    latitude = np.asarray(latitude, dtype="float32").reshape(-1)
+    longitude = np.asarray(longitude, dtype="float32").reshape(-1)
+    field = np.asarray(field, dtype="float32")
+    lat_order = np.argsort(latitude)
+    lon_order = np.argsort(longitude)
+    return latitude[lat_order], longitude[lon_order], field[..., lat_order, :][..., :, lon_order]
+
+
+def _longitude_queries(values: np.ndarray, longitude: np.ndarray) -> np.ndarray:
+    values = np.asarray(values, dtype="float64")
+    low, high = float(longitude[0]), float(longitude[-1])
+    if low >= 0.0 and high > 180.0:
+        return np.mod(values, 360.0)
+    if low < 0.0 and high <= 180.0:
+        return ((values + 180.0) % 360.0) - 180.0
+    return np.clip(values, low, high)
+
+
+def _bilinear(field: np.ndarray, latitude: np.ndarray, longitude: np.ndarray, query_lat: np.ndarray, query_lon: np.ndarray) -> np.ndarray:
+    """Bilinear sample a 2-D field or a 2-channel field on a regular grid."""
+
+    lat, lon, values = _sorted_axes(latitude, longitude, field)
+    query_lat = np.clip(np.asarray(query_lat, dtype="float64"), float(lat[0]), float(lat[-1]))
+    query_lon = _longitude_queries(query_lon, lon)
+    row = np.interp(query_lat, lat, np.arange(len(lat), dtype="float64"))
+    column = np.interp(query_lon, lon, np.arange(len(lon), dtype="float64"))
+    row0 = np.floor(row).astype("int64")
+    col0 = np.floor(column).astype("int64")
+    row1 = np.minimum(row0 + 1, len(lat) - 1)
+    col1 = np.minimum(col0 + 1, len(lon) - 1)
+    rf = row - row0
+    cf = column - col0
+    if values.ndim == 2:
+        return (
+            values[row0, col0] * (1.0 - rf) * (1.0 - cf)
+            + values[row1, col0] * rf * (1.0 - cf)
+            + values[row0, col1] * (1.0 - rf) * cf
+            + values[row1, col1] * rf * cf
+        ).astype("float32")
+    return np.stack([
+        _bilinear(values[channel], lat, lon, query_lat, query_lon)
+        for channel in range(values.shape[0])
+    ], axis=1).astype("float32")
+
+
+def _geostrophic_field(pressure: np.ndarray, latitude: np.ndarray, longitude: np.ndarray) -> np.ndarray:
+    """Approximate geostrophic wind from causal SLP gradients."""
+
+    pressure = np.asarray(pressure, dtype="float32")
+    lat, lon, sorted_pressure = _sorted_axes(latitude, longitude, pressure)
+    earth_radius = 6_371_000.0
+    omega = 7.2921159e-5
+    dy = np.gradient(np.deg2rad(lat) * earth_radius)
+    dx = np.deg2rad(float(np.median(np.diff(lon)))) * earth_radius * np.cos(np.deg2rad(lat))
+    dp_dy = np.gradient(sorted_pressure.astype("float64"), axis=0) * 100.0 / dy[:, None]
+    dp_dx = np.gradient(sorted_pressure.astype("float64"), axis=1) * 100.0 / dx[:, None]
+    coriolis = 2.0 * omega * np.sin(np.deg2rad(lat))
+    coriolis = np.where(np.abs(coriolis) < 2.0e-5, np.sign(coriolis) * 2.0e-5, coriolis)
+    coriolis = np.where(coriolis == 0.0, 2.0e-5, coriolis)
+    rho = 1.15
+    u = -dp_dy / (rho * coriolis[:, None])
+    v = dp_dx / (rho * coriolis[:, None])
+    return np.stack([u, v]).astype("float32")
+
+
+def _ring(ring_degrees: tuple[float, float]) -> tuple[np.ndarray, np.ndarray]:
+    radii = np.arange(float(ring_degrees[0]), float(ring_degrees[1]) + 0.01, 1.0, dtype="float32")
+    angles = np.linspace(0.0, 2.0 * math.pi, 32, endpoint=False, dtype="float32")
+    north = (radii[:, None] * np.sin(angles)[None, :]).reshape(-1)
+    east = (radii[:, None] * np.cos(angles)[None, :]).reshape(-1)
+    return north, east
+
+
+def _step(flow: tuple[float, float]) -> np.ndarray:
+    u, v = flow
+    return np.asarray([
+        (float(MOTION_SLOPES[0]) * u + float(MOTION_INTERCEPTS[0])) * 21.6,
+        (float(MOTION_SLOPES[1]) * v + float(MOTION_INTERCEPTS[1])) * 21.6,
+    ], dtype="float32")
+
+
+def _clip_tendency(values: np.ndarray) -> np.ndarray:
+    """Limit noisy analysis differences without using any future frame."""
+
+    values = np.nan_to_num(np.asarray(values, dtype="float32"), copy=True)
+    if values.ndim < 3:
+        return values
+    for channel in range(values.shape[0]):
+        scale = float(np.nanpercentile(np.abs(values[channel]), 98.0))
+        if scale > 0.0 and math.isfinite(scale):
+            values[channel] = np.clip(values[channel], -2.0 * scale, 2.0 * scale)
+    return values
+
+
+def build_route(
+    fields: np.ndarray,
+    latitude: np.ndarray,
+    longitude: np.ndarray,
+    base_latitude: float,
+    base_longitude: float,
+    pressure: np.ndarray | None = None,
+    available: Sequence[float] = (1.0, 1.0),
+    route_variants: Sequence[dict] = ROUTE_VARIANTS,
+    curvature_variants: Sequence[float] = CURVATURE_VARIANTS,
+    snapshot_weights: Sequence[float] = SNAPSHOT_WEIGHTS,
+    tendency_scales: Sequence[float] = TENDENCY_SCALES,
+    history_motion_km_per_6h: tuple[float, float] | None = None,
+) -> tuple[np.ndarray, np.ndarray, dict]:
+    """Return dynamic member displacements, weights, and causal diagnostics.
+
+    The current analysis is advanced with a clipped tendency estimated only
+    from the two preceding analysis frames.  The fields are never replaced by
+    a positive-lead forecast.  Every member still starts at the same issue
+    position, but its broad steering environment can evolve with lead.
+    """
+
+    fields = np.asarray(fields, dtype="float32")
+    if fields.ndim != 4 or fields.shape[0] != 3 or fields.shape[1] != 7:
+        raise ValueError(f"expected fields (3,7,H,W), got {fields.shape}")
+    latitude = np.asarray(latitude, dtype="float32")
+    longitude = np.asarray(longitude, dtype="float32")
+    if pressure is None:
+        pressure = np.zeros((3, len(latitude), len(longitude)), dtype="float32")
+        pressure_available = np.zeros(3, dtype=bool)
+    else:
+        pressure = np.asarray(pressure, dtype="float32")
+        if pressure.shape != (3, len(latitude), len(longitude)):
+            raise ValueError(f"expected pressure (3,H,W), got {pressure.shape}")
+        pressure_available = np.isfinite(pressure).all(axis=(1, 2))
+    valid_snapshot = np.ones(3, dtype=bool)
+    avail = np.asarray(available, dtype="float64").reshape(-1)
+    if avail.size >= 1:
+        valid_snapshot[1] = bool(avail[0] > 0.5)
+    if avail.size >= 2:
+        valid_snapshot[2] = bool(avail[1] > 0.5)
+    valid_snapshot &= np.isfinite(fields).all(axis=(1, 2, 3))
+    if not valid_snapshot[0]:
+        raise RuntimeError("current causal analysis snapshot is unavailable")
+    snap_weights = np.asarray(snapshot_weights, dtype="float64") * valid_snapshot
+    snap_weights /= snap_weights.sum()
+    curve_values = np.asarray(tuple(curvature_variants), dtype="float64")
+    curve_values = np.clip(curve_values[np.isfinite(curve_values)], 0.0, 0.60)
+    if not len(curve_values):
+        raise ValueError("curvature_variants is empty")
+    tendency_values = np.asarray(tuple(tendency_scales), dtype="float64")
+    tendency_weights = np.asarray(tuple(TENDENCY_SCALE_WEIGHTS), dtype="float64")
+    if tendency_values.shape != tendency_weights.shape or np.any(~np.isfinite(tendency_values)):
+        raise ValueError("tendency_scales must match the fixed tendency weight table")
+    tendency_values = np.maximum(tendency_values, 0.0)
+    tendency_weights = np.maximum(tendency_weights, 0.0)
+    tendency_weights /= tendency_weights.sum()
+    variant_weights = np.asarray([float(item["weight"]) for item in route_variants], dtype="float64")
+    variant_weights = np.maximum(variant_weights, 0.0)
+    variant_weights /= variant_weights.sum()
+    geo_fields = np.zeros((3, 2, len(latitude), len(longitude)), dtype="float32")
+    for index in range(3):
+        if pressure_available[index]:
+            geo_fields[index] = _geostrophic_field(pressure[index], latitude, longitude)
+
+    current_fields = fields[0]
+    recent_delta = _clip_tendency(fields[0] - fields[1]) if valid_snapshot[1] else np.zeros_like(current_fields)
+    older_delta = _clip_tendency(fields[1] - fields[2]) if valid_snapshot[2] else recent_delta.copy()
+    tendency_views = (
+        recent_delta,
+        _clip_tendency(0.5 * (recent_delta + older_delta)),
+        older_delta,
+    )
+    current_geo = geo_fields[0]
+    recent_geo_delta = _clip_tendency(geo_fields[0] - geo_fields[1]) if pressure_available[1] else np.zeros_like(current_geo)
+    older_geo_delta = _clip_tendency(geo_fields[1] - geo_fields[2]) if pressure_available[2] else recent_geo_delta.copy()
+    geo_tendency_views = (
+        recent_geo_delta,
+        _clip_tendency(0.5 * (recent_geo_delta + older_geo_delta)),
+        older_geo_delta,
+    )
+    history_step = None
+    if history_motion_km_per_6h is not None:
+        candidate = np.asarray(history_motion_km_per_6h, dtype="float32").reshape(-1)
+        if candidate.size == 2 and np.isfinite(candidate).all():
+            history_step = candidate
+
+    members: list[np.ndarray] = []
+    weights: list[float] = []
+    member_rows: list[dict] = []
+    current_wind_levels = np.stack(
+        [current_fields[1:3], current_fields[3:5], current_fields[5:7]],
+        axis=0,
+    )
+    for snapshot_index in range(3):
+        if snap_weights[snapshot_index] <= 0.0:
+            continue
+        for variant_index, variant in enumerate(route_variants):
+            level_weights = np.asarray(variant["level_weights"], dtype="float32")
+            level_weights /= level_weights.sum()
+            ring_north, ring_east = _ring(tuple(variant["ring_degrees"]))
+            wind_field = np.tensordot(level_weights, current_wind_levels, axes=(0, 0)).astype("float32")
+            wind_tendency = np.tensordot(
+                level_weights,
+                np.stack(
+                    [
+                        tendency_views[snapshot_index][1:3],
+                        tendency_views[snapshot_index][3:5],
+                        tendency_views[snapshot_index][5:7],
+                    ],
+                    axis=0,
+                ),
+                axes=(0, 0),
+            ).astype("float32")
+            pressure_field = current_geo
+            geo_tendency = geo_tendency_views[snapshot_index]
+            pressure_fraction = float(variant.get("pressure_fraction", 0.0)) if pressure_available[0] else 0.0
+
+            def flow_from(field: np.ndarray, lat: float, lon: float) -> tuple[float, float]:
+                sample_lat = float(lat) + ring_north
+                sample_lon = float(lon) + ring_east / max(math.cos(math.radians(float(lat))), 0.20)
+                samples = _bilinear(field, latitude, longitude, sample_lat, sample_lon)
+                return float(np.nanmean(samples[:, 0])), float(np.nanmean(samples[:, 1]))
+
+            for tendency_index, tendency_scale in enumerate(tendency_values):
+                for curvature in curve_values:
+                    lat = float(base_latitude)
+                    lon = float(base_longitude)
+                    previous_step = _step(flow_from(wind_field, lat, lon))
+                    steps = np.zeros((LEADS, 2), dtype="float32")
+                    waypoints = []
+                    for lead in range(LEADS):
+                        # A bounded extrapolation of the observed analysis
+                        # tendency lets the steering regime change with lead.
+                        progress = min(2.0, 0.5 * ((lead + 1) * 6.0 / 12.0))
+                        dynamic_wind = wind_field + float(tendency_scale) * progress * wind_tendency
+                        dynamic_geo = pressure_field + float(tendency_scale) * progress * geo_tendency
+                        local_u, local_v = flow_from(dynamic_wind, lat, lon)
+                        local_geo_u, local_geo_v = flow_from(dynamic_geo, lat, lon) if pressure_fraction else (0.0, 0.0)
+                        local_flow = (
+                            (1.0 - pressure_fraction) * local_u + pressure_fraction * local_geo_u,
+                            (1.0 - pressure_fraction) * local_v + pressure_fraction * local_geo_v,
+                        )
+                        weather_step = _step(local_flow)
+                        if history_step is not None:
+                            history_weight = 0.20 * math.exp(-((lead + 1) * 6.0) / 36.0)
+                            weather_step = (1.0 - history_weight) * weather_step + history_weight * history_step
+                        inertia = min(0.18, 0.04 + 0.08 * float(curvature)) if lead else 0.0
+                        step = (1.0 - inertia) * weather_step + inertia * previous_step
+                        previous_step = step
+                        steps[lead] = step
+                        lat += float(step[1]) / 111.2
+                        lon += float(step[0]) / (111.2 * max(math.cos(math.radians(lat)), 0.20))
+                        lon %= 360.0
+                        if lead in (0, 3, 7, 11, 15, 19):
+                            waypoints.append({
+                                "lead_hours": (lead + 1) * 6,
+                                "latitude": round(lat, 4),
+                                "longitude": round(lon, 4),
+                                "u_mean_mps": round(local_flow[0], 4),
+                                "v_mean_mps": round(local_flow[1], 4),
+                                "tendency_progress": round(progress, 4),
+                            })
+                    members.append(steps)
+                    weights.append(
+                        float(snap_weights[snapshot_index])
+                        * float(variant_weights[variant_index])
+                        * float(tendency_weights[tendency_index])
+                        / float(len(curve_values))
+                    )
+                    member_rows.append({
+                        "member_index": len(members) - 1,
+                        "snapshot_index": snapshot_index,
+                        "variant": str(variant["name"]),
+                        "ring_degrees": list(variant["ring_degrees"]),
+                        "level_weights": level_weights.tolist(),
+                        "pressure_fraction": pressure_fraction,
+                        "curvature_fraction": round(float(curvature), 4),
+                        "tendency_scale": round(float(tendency_scale), 4),
+                        "sampled_waypoints": waypoints,
+                    })
+    member_weights = np.asarray(weights, dtype="float64")
+    member_weights /= member_weights.sum()
+    return np.stack(members).astype("float32"), member_weights, {
+        "version": VERSION,
+        "policy": "causal dynamic multi-level large-system analysis ensemble",
+        "input_policy": "current, t-12, and t-24 analysis fields only; the lead evolution is a bounded extrapolation of their observed tendency; no future analysis, forecast product, official track, or future observed row",
+        "channels": ["hgt500", "u850", "v850", "u500", "v500", "u200", "v200"],
+        "snapshot_weights": snap_weights.tolist(),
+        "member_weights": member_weights.tolist(),
+        "member_count": len(member_rows),
+        "route_variants": [dict(item) for item in route_variants],
+        "curvature_variants": [float(value) for value in curve_values],
+        "tendency_scales": [float(value) for value in tendency_values],
+        "tendency_weights": tendency_weights.tolist(),
+        "tendency_method": "bounded current-minus-past analysis tendency, capped at two 12-hour differences",
+        "history_motion_km_per_6h": None if history_step is None else history_step.tolist(),
+        "member_rows": member_rows,
+        "large_systems": [
+            "Pacific subtropical ridge represented by broad 850/500-hPa flow and 500-hPa height field",
+            "midlatitude trough and jet influence represented by broad 500/200-hPa rings",
+            "pressure-gradient steering represented by causal SLP geostrophic component when supplied",
+        ],
+    }
+
+
+def integrate_from_issue(member_displacements: np.ndarray, base_latitude: float, base_longitude: float) -> list[list[dict]]:
+    """Convert member km steps to serializable geographic paths."""
+
+    paths = []
+    for member in np.asarray(member_displacements, dtype="float32"):
+        lat, lon = float(base_latitude), float(base_longitude)
+        points = []
+        for lead, step in enumerate(member, start=1):
+            lon += float(step[0]) / (111.2 * max(math.cos(math.radians(lat)), 0.20))
+            lat += float(step[1]) / 111.2
+            lon %= 360.0
+            points.append({
+                "lead_hours": lead * 6,
+                "latitude": round(lat, 4),
+                "longitude": round(lon, 4),
+            })
+        paths.append(points)
+    return paths
+
+
+def weighted_route(member_displacements: np.ndarray, member_weights: np.ndarray) -> np.ndarray:
+    return np.tensordot(np.asarray(member_weights, dtype="float32"), np.asarray(member_displacements, dtype="float32"), axes=(0, 0)).astype("float32")
+
+
+__all__ = [
+    "VERSION",
+    "ROUTE_VARIANTS",
+    "CURVATURE_VARIANTS",
+    "SNAPSHOT_WEIGHTS",
+    "build_route",
+    "integrate_from_issue",
+    "weighted_route",
+]

trackformer_1_1_intensity.py

@@ -0,0 +1,748 @@
+#!/usr/bin/env python3
+"""Causal Trackformer1.1 intensity and wind-structure inference.
+
+The Trackformer1.1 route is responsible for position and the western-Pacific pressure
+state.  This module supplies the previously missing storm-structure outputs
+without changing that route: maximum sustained wind, central pressure, radius
+of maximum wind, and the four-quadrant R34/R50/R64 radii.
+
+The default weights are a validated residual-anchor spatial ensemble with a
+secondary structure expert and causal temporal branch. They are loaded only
+for inference and are conditioned on the same nine-step observed track window
+plus the current four-channel analysis patch.
+No positive-lead atmospheric field or official agency forecast is consumed.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+
+LEADS = 20
+NM_TO_KM = 1.852
+TARGET_SCALE = np.asarray([100.0, 100.0, 35.0, 20.0, 50.0] + [50.0] * 12, dtype="float32")
+STRUCTURE_SCALE = TARGET_SCALE[2:]
+THERMO_ENV_COLS = (
+    [4, 5, 6, 7]
+    + list(range(8, 20))
+    + list(range(24, 40))
+    + [44, 45, 46, 47, 48, 49, 50, 51, 52, 53]
+)
+# The 90th percentile of positive six-hour central-pressure changes in the
+# training split is 6 hPa.  Use that train-only statistic to stop a coarse
+# forecast-map minimum from disappearing in one step and being replaced by a
+# different synoptic cell.
+MAP_PRESSURE_RECOVERY_LIMIT_HPA = 6.0
+
+
+def sinusoidal(length: int, width: int) -> torch.Tensor:
+    position = torch.arange(length).unsqueeze(1).float()
+    divisor = torch.exp(torch.arange(0, width, 2).float() * (-np.log(10000.0) / width))
+    result = torch.zeros(length, width)
+    result[:, 0::2] = torch.sin(position * divisor)
+    result[:, 1::2] = torch.cos(position * divisor)
+    return result
+
+
+class StructureSpatialExpert(nn.Module):
+    """Inference copy of the architecture used by the frozen experts."""
+
+    def __init__(self, width: int, layers: int, heads: int, structure_residual: bool = False):
+        super().__init__()
+        self.structure_residual = bool(structure_residual)
+        self.track_proj = nn.Linear(len(THERMO_ENV_COLS), width)
+        self.register_buffer("track_time", sinusoidal(9, width).unsqueeze(0))
+        track_layer = nn.TransformerEncoderLayer(
+            width,
+            heads,
+            width * 4,
+            0.12,
+            batch_first=True,
+            norm_first=True,
+            activation="gelu",
+        )
+        self.track_encoder = nn.TransformerEncoder(track_layer, layers)
+        self.field_encoder = nn.Sequential(
+            nn.Conv2d(4, 64, 3, padding=1),
+            nn.GroupNorm(8, 64),
+            nn.SiLU(),
+            nn.Conv2d(64, width, 3, stride=2, padding=1),
+            nn.GroupNorm(8, width),
+            nn.SiLU(),
+        )
+        self.field_pool = nn.AvgPool2d(kernel_size=2, stride=2)
+        self.field_norm = nn.LayerNorm(width)
+        self.field_pos = nn.Parameter(torch.randn(1, 16, width) * 0.02)
+        decoder_layer = nn.TransformerDecoderLayer(
+            width,
+            heads,
+            width * 4,
+            0.12,
+            batch_first=True,
+            norm_first=True,
+            activation="gelu",
+        )
+        self.query = nn.Parameter(torch.randn(1, LEADS, width) * 0.02)
+        self.register_buffer("lead_time", sinusoidal(LEADS, width).unsqueeze(0))
+        self.decoder = nn.TransformerDecoder(decoder_layer, layers)
+        self.state = nn.Linear(width, 15)
+        self.log_scale = nn.Linear(width, 15)
+
+    def forward(
+        self,
+        track: torch.Tensor,
+        field: torch.Tensor,
+        current: torch.Tensor,
+        available: torch.Tensor,
+        current_structure: torch.Tensor | None = None,
+        structure_available: torch.Tensor | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        track_tokens = self.track_encoder(self.track_proj(track[:, :, THERMO_ENV_COLS]) + self.track_time)
+        field_tokens = self.field_pool(self.field_encoder(field)).flatten(2).transpose(1, 2)
+        field_tokens = self.field_norm(field_tokens + self.field_pos)
+        memory = torch.cat([track_tokens, field_tokens], dim=1)
+        query = (self.query + self.lead_time).expand(track.shape[0], -1, -1)
+        hidden = self.decoder(query, memory)
+        state = self.state(hidden)
+        state = state.clone()
+        state[:, :, :2] = state[:, :, :2] + (current * available)[:, None, :]
+        if self.structure_residual:
+            if current_structure is None or structure_available is None:
+                raise ValueError("structure residual mode requires current structure and availability tensors")
+            state[:, :, 2:] = state[:, :, 2:] + current_structure[:, None, :] * structure_available[:, None, :]
+        return state, self.log_scale(hidden)
+
+
+def _device(requested: str | None) -> torch.device:
+    value = requested or os.environ.get("TRACKFORMER_1_1_DEVICE")
+    if value:
+        return torch.device(value)
+    if torch.cuda.is_available():
+        return torch.device("cuda")
+    if torch.backends.mps.is_available():
+        return torch.device("mps")
+    return torch.device("cpu")
+
+
+def _calibrated_wind(states: np.ndarray, current_wind: float, calibration: dict) -> np.ndarray:
+    alphas = calibration.get("wind_blend_alpha")
+    if not alphas:
+        return states[:, :, 0]
+    predicted = states[:, :, 0]
+    result = np.empty_like(predicted)
+    for lead, alpha in enumerate(alphas[:LEADS]):
+        result[:, lead] = float(alpha) * predicted[:, lead] + (1.0 - float(alpha)) * current_wind
+    return np.clip(result, 0.0, 190.0)
+
+
+def _calibrated_pressure(
+    states: np.ndarray,
+    current_wind: float,
+    current_pressure: float,
+    previous_wind: float,
+    previous_pressure: float,
+    calibrated_wind: np.ndarray,
+    calibration: dict,
+) -> np.ndarray:
+    joint = calibration.get("pressure_joint_calibrations")
+    if not joint:
+        return np.clip(states[:, :, 1], 850.0, 1025.0)
+    predicted_pressure = states[:, :, 1]
+    result = np.empty_like(predicted_pressure)
+    for lead, item in enumerate(joint[:LEADS]):
+        features = np.column_stack([
+            np.full(len(predicted_pressure), 1.0, dtype="float32"),
+            np.full(len(predicted_pressure), current_pressure, dtype="float32"),
+            np.full(len(predicted_pressure), current_wind, dtype="float32"),
+            calibrated_wind[:, lead],
+            predicted_pressure[:, lead],
+            predicted_pressure[:, lead] - current_pressure,
+            calibrated_wind[:, lead] - current_wind,
+            np.full(len(predicted_pressure), current_pressure - previous_pressure, dtype="float32"),
+            np.full(len(predicted_pressure), current_wind - previous_wind, dtype="float32"),
+        ])
+        mean = np.asarray(item["mean"], dtype="float32")
+        scale = np.maximum(np.asarray(item["scale"], dtype="float32"), 1e-6)
+        normalized = (features - mean) / scale
+        normalized[:, 0] = 1.0
+        result[:, lead] = normalized @ np.asarray(item["beta"], dtype="float32")
+    anchor_alpha = calibration.get("pressure_anchor_alpha")
+    if anchor_alpha and np.isfinite(current_pressure) and current_pressure > 0.0:
+        for lead, alpha in enumerate(anchor_alpha[:LEADS]):
+            alpha = float(np.clip(alpha, 0.0, 2.0))
+            result[:, lead] = alpha * result[:, lead] + (1.0 - alpha) * float(current_pressure)
+    return np.clip(result, 850.0, 1025.0)
+
+
+def _sanitize(states: np.ndarray) -> np.ndarray:
+    """Apply output bounds and preserve the R34 >= R50 >= R64 ordering."""
+
+    result = np.asarray(states, dtype="float32").copy()
+    result[:, :, 0] = np.clip(result[:, :, 0], 0.0, 190.0)
+    result[:, :, 1] = np.clip(result[:, :, 1], 850.0, 1025.0)
+    result[:, :, 2] = np.clip(result[:, :, 2], 0.0, 300.0)
+    radii = np.clip(result[:, :, 3:15], 0.0, 1000.0)
+    for offset in range(4):
+        radii[:, :, 4 + offset] = np.minimum(radii[:, :, 4 + offset], radii[:, :, offset])
+        radii[:, :, 8 + offset] = np.minimum(radii[:, :, 8 + offset], radii[:, :, 4 + offset])
+    result[:, :, 3:15] = radii
+    return result
+
+
+def _row(mean: np.ndarray, spread: np.ndarray, lead: int) -> dict:
+    # The historical IBTrACS structure labels are nautical miles. Keep the
+    # neural/calibration state in that native unit, but expose all distance
+    # fields in kilometres because the map and route use kilometres.
+    radii = mean[lead, 3:15] * NM_TO_KM
+    radius_spread = spread[lead, 3:15] * NM_TO_KM
+    return {
+        "vmax_kt": round(float(mean[lead, 0]), 2),
+        "vmax_spread_kt": round(float(spread[lead, 0]), 2),
+        "central_pressure_hpa": round(float(mean[lead, 1]), 2),
+        "pressure_spread_hpa": round(float(spread[lead, 1]), 2),
+        "rmw_km": round(float(mean[lead, 2] * NM_TO_KM), 2),
+        "rmw_spread_km": round(float(spread[lead, 2] * NM_TO_KM), 2),
+        "wind_radii_km": [round(float(value), 2) for value in radii],
+        "wind_radii_spread_km": [round(float(value), 2) for value in radius_spread],
+        # Keep the map renderer's generic pressure field alias as well.
+        "pressure_hpa": round(float(mean[lead, 1]), 2),
+    }
+
+
+def _map_grid_feature(
+    pressure: np.ndarray,
+    fields: np.ndarray,
+    latitude: np.ndarray,
+    longitude: np.ndarray,
+    query_latitude: float,
+    query_longitude: float,
+) -> dict:
+    """Extract a storm-relative signal from one forecast pressure map.
+
+    The map can be much coarser than the route grid, especially for the Tip
+    reanalysis.  We therefore use a nearby pressure minimum, a broad annulus
+    environment, and quadrant-wise anomaly extents rather than pretending that
+    a single grid cell is an exact storm center.
+    """
+
+    pressure = np.asarray(pressure, dtype="float32")
+    fields = np.asarray(fields, dtype="float32")
+    latitude = np.asarray(latitude, dtype="float32").reshape(-1)
+    longitude = np.asarray(longitude, dtype="float32").reshape(-1)
+    lat_order = np.argsort(latitude)
+    lon_order = np.argsort(longitude)
+    latitude = latitude[lat_order]
+    longitude = longitude[lon_order]
+    pressure = pressure[np.ix_(lat_order, lon_order)]
+    fields = fields[:, lat_order, :][:, :, lon_order]
+    lat_grid, lon_grid = np.meshgrid(latitude, longitude, indexing="ij")
+    delta_lon = ((lon_grid - float(query_longitude) + 180.0) % 360.0) - 180.0
+    delta_lat = lat_grid - float(query_latitude)
+    distance_deg = np.hypot(delta_lat, delta_lon * np.cos(np.deg2rad(float(query_latitude))))
+    query_row, query_column = np.unravel_index(int(np.nanargmin(distance_deg)), distance_deg.shape)
+    query_pressure = float(pressure[query_row, query_column])
+    query_wind850 = float(np.hypot(fields[1, query_row, query_column], fields[2, query_row, query_column]) * 1.94384) if fields.shape[0] >= 3 else float("nan")
+    # A minimum farther than this is likely a separate synoptic system rather
+    # than the cyclone represented by the route point.  Keep the local query
+    # as a fallback instead of allowing a distant low to control intensity.
+    nearby = distance_deg <= 6.0
+    finite = np.isfinite(pressure)
+    candidate = np.where(nearby & finite, pressure, np.inf)
+    if not np.isfinite(candidate).any():
+        row, column = query_row, query_column
+    else:
+        row, column = np.unravel_index(int(np.argmin(candidate)), candidate.shape)
+    center_latitude = float(latitude[row])
+    center_longitude = float(longitude[column])
+    center_pressure = float(pressure[row, column])
+    center_delta_lon = ((lon_grid - center_longitude + 180.0) % 360.0) - 180.0
+    center_delta_lat = lat_grid - center_latitude
+    center_distance_deg = np.hypot(
+        center_delta_lat,
+        center_delta_lon * np.cos(np.deg2rad(center_latitude)),
+    )
+    annulus = (
+        (center_distance_deg >= 2.5)
+        & (center_distance_deg <= 6.0)
+        & np.isfinite(pressure)
+    )
+    environment = float(np.nanmedian(pressure[annulus])) if annulus.any() else center_pressure + 15.0
+    anomaly = np.maximum(environment - pressure, 0.0)
+    # Four degrees is a conservative upper bound for a pressure-derived
+    # tropical wind footprint on this coarse map.  Without it, a weak broad
+    # gradient would be misreported as an 800-km R34.
+    core = (center_distance_deg <= 4.0) & np.isfinite(anomaly)
+    peak_anomaly = float(np.nanmax(anomaly[core])) if core.any() else 0.0
+    radii: list[float] = []
+    # These are pressure-anomaly fractions used as a stable proxy for the
+    # R34/R50/R64 shape.  The learned radius output remains the absolute
+    # baseline; only its map-observed expansion/contraction is applied.
+    for fraction in (0.25, 0.50, 0.70):
+        for quadrant in ((1.0, 1.0), (1.0, -1.0), (-1.0, -1.0), (-1.0, 1.0)):
+            north_sign, east_sign = quadrant
+            quadrant_mask = core & (center_delta_lat * north_sign >= 0.0) & (center_delta_lon * east_sign >= 0.0)
+            threshold = peak_anomaly * fraction
+            valid = quadrant_mask & (anomaly >= threshold) if peak_anomaly > 0.0 else np.zeros_like(core)
+            if valid.any():
+                radii.append(float(np.nanmax(center_distance_deg[valid]) * 111.2))
+            else:
+                radii.append(float("nan"))
+    wind850 = float(np.hypot(fields[1, row, column], fields[2, row, column]) * 1.94384) if fields.shape[0] >= 3 else float("nan")
+    center_offset_km = float(distance_deg[row, column] * 111.2)
+    center_trusted = bool(center_offset_km <= 333.6 and (environment - center_pressure) >= 4.0)
+    offset_degrees = center_offset_km / 111.2
+    center_confidence = 1.0 if center_trusted else float(np.clip(1.0 - 0.75 * (offset_degrees - 3.0) / 3.0, 0.25, 0.75))
+    return {
+        "map_min_pressure_hpa": round(center_pressure, 2),
+        "map_query_pressure_hpa": round(query_pressure, 2) if np.isfinite(query_pressure) else None,
+        "map_environment_pressure_hpa": round(environment, 2),
+        "map_pressure_deficit_hpa": round(max(0.0, environment - center_pressure), 2),
+        "map_center_latitude": round(center_latitude, 3),
+        "map_center_longitude": round(center_longitude % 360.0, 3),
+        "map_center_offset_km": round(center_offset_km, 2),
+        "map_center_trusted": center_trusted,
+        "map_center_confidence": round(center_confidence, 3),
+        "map_wind850_kt": round(wind850, 2) if np.isfinite(wind850) else None,
+        "map_query_wind850_kt": round(query_wind850, 2) if np.isfinite(query_wind850) else None,
+        "map_pressure_radii_km": [round(value, 2) if np.isfinite(value) else None for value in radii],
+    }
+
+
+def couple_forecast_to_pressure_map(
+    structure_rows: list[dict],
+    pressure_states: np.ndarray,
+    field_states: np.ndarray,
+    latitude: np.ndarray,
+    longitude: np.ndarray,
+    base_latitude: float,
+    base_longitude: float,
+    forecast_points: list[dict],
+    current_wind: float,
+    current_pressure: float,
+) -> tuple[list[dict], dict]:
+    """Use the causal pressure-map trajectory to correct structure forecasts.
+
+    The correction is anchored to the observed current wind and pressure, so
+    coarse reanalysis cannot replace a known storm intensity.  Future changes
+    in the map minimum drive bounded pressure/wind changes, and changes in the
+    map's quadrant anomaly extent rescale the learned radii.  This is the same
+    forecast-state family used by the track route, not a future official field.
+    """
+
+    pressure_states = np.asarray(pressure_states, dtype="float32")
+    field_states = np.asarray(field_states, dtype="float32")
+    if pressure_states.ndim != 3 or field_states.ndim != 4 or field_states.shape[1] < 3:
+        raise ValueError(f"invalid map state shapes: {pressure_states.shape}, {field_states.shape}")
+    if len(structure_rows) != len(forecast_points) or len(pressure_states) < len(structure_rows) + 1:
+        raise ValueError("map states, route points, and structure rows have incompatible lengths")
+    if not np.isfinite(current_wind) or not np.isfinite(current_pressure):
+        return structure_rows, {
+            "enabled": False,
+            "reason": "current observed wind and pressure are unavailable",
+            "official_forecasts_used": False,
+        }
+
+    features = [_map_grid_feature(
+        pressure_states[index],
+        field_states[index],
+        latitude,
+        longitude,
+        base_latitude if index == 0 else float(forecast_points[index - 1]["lat"]),
+        base_longitude if index == 0 else float(forecast_points[index - 1]["lon"]),
+    ) for index in range(len(structure_rows) + 1)]
+    # Use a trusted nearby minimum when available.  Otherwise sample the map
+    # at the route point; this keeps another low/typhoon from hijacking the
+    # structure forecast merely because it is the strongest minimum nearby.
+    effective_minimum = np.asarray([
+        float(item["map_query_pressure_hpa"])
+        + float(item["map_center_confidence"]) * (
+            float(item["map_min_pressure_hpa"]) - float(item["map_query_pressure_hpa"])
+        )
+        for item in features
+    ], dtype="float32")
+    effective_deficit = np.asarray([
+        float(item["map_pressure_deficit_hpa"]) * float(item["map_center_confidence"])
+        for item in features
+    ], dtype="float32")
+    effective_wind850 = np.asarray([
+        float(item["map_query_wind850_kt"])
+        + float(item["map_center_confidence"]) * (
+            float(item["map_wind850_kt"]) - float(item["map_query_wind850_kt"])
+        )
+        for item in features
+    ], dtype="float32")
+    # A short causal smoother prevents a one-cell minimum handoff from making
+    # a six-hour intensity jump while retaining the map's lead-time trend.
+    smooth_minimum = effective_minimum.copy()
+    smooth_deficit = effective_deficit.copy()
+    smooth_wind850 = effective_wind850.copy()
+    for index in range(1, len(smooth_minimum)):
+        smooth_minimum[index] = 0.65 * smooth_minimum[index - 1] + 0.35 * effective_minimum[index]
+        smooth_deficit[index] = 0.65 * smooth_deficit[index - 1] + 0.35 * effective_deficit[index]
+        if np.isfinite(effective_wind850[index]) and np.isfinite(smooth_wind850[index - 1]):
+            smooth_wind850[index] = 0.65 * smooth_wind850[index - 1] + 0.35 * effective_wind850[index]
+        if np.isfinite(smooth_minimum[index - 1]) and np.isfinite(smooth_minimum[index]):
+            smooth_minimum[index] = min(
+                smooth_minimum[index],
+                smooth_minimum[index - 1] + MAP_PRESSURE_RECOVERY_LIMIT_HPA,
+            )
+    reference_radii = np.asarray([
+        float(value) if value is not None else np.nan
+        for value in features[0]["map_pressure_radii_km"]
+    ], dtype="float32")
+    corrected: list[dict] = []
+    map_weight = 0.35
+    for index, base in enumerate(structure_rows, start=1):
+        row = dict(base)
+        # A distant minimum is an environmental candidate, not a reliable
+        # storm-center intensity observation.  The previous floor kept more
+        # than one-fifth of the map correction active even when confidence
+        # had fallen to 0.25, which made another synoptic cell rewrite the
+        # central pressure and wind.  Let confidence directly control the
+        # intensity correction; the map remains available for diagnostics and
+        # trusted radius adjustments.
+        row_weight = map_weight * float(np.clip(features[index]["map_center_confidence"], 0.0, 1.0))
+        map_pressure = float(current_pressure + smooth_minimum[index] - smooth_minimum[0])
+        pressure_signal = float(np.clip(
+            0.75 * (smooth_minimum[0] - smooth_minimum[index])
+            + 0.25 * (smooth_deficit[index] - smooth_deficit[0]),
+            -30.0,
+            30.0,
+        ))
+        wind_signal = pressure_signal
+        if np.isfinite(smooth_wind850[index]) and np.isfinite(smooth_wind850[0]):
+            wind_signal += float(np.clip(0.18 * (smooth_wind850[index] - smooth_wind850[0]), -8.0, 8.0))
+        map_wind = float(current_wind + 0.70 * wind_signal)
+        row["central_pressure_hpa"] = round(float(np.clip(
+            (1.0 - row_weight) * float(base["central_pressure_hpa"]) + row_weight * map_pressure,
+            850.0,
+            1025.0,
+        )), 2)
+        row["pressure_hpa"] = row["central_pressure_hpa"]
+        row["vmax_kt"] = round(float(np.clip(
+            (1.0 - row_weight) * float(base["vmax_kt"]) + row_weight * map_wind,
+            0.0,
+            190.0,
+        )), 2)
+        row["pressure_spread_hpa"] = round(float(np.hypot(
+            float(base.get("pressure_spread_hpa", 0.0)),
+            row_weight * abs(map_pressure - float(base["central_pressure_hpa"])),
+        )), 2)
+        row["vmax_spread_kt"] = round(float(np.hypot(
+            float(base.get("vmax_spread_kt", 0.0)),
+            row_weight * abs(map_wind - float(base["vmax_kt"])),
+        )), 2)
+        map_radii = np.asarray([
+            float(value) if value is not None else np.nan
+            for value in features[index]["map_pressure_radii_km"]
+        ], dtype="float32")
+        base_radii = np.asarray(base["wind_radii_km"], dtype="float32")
+        if not features[0]["map_center_trusted"] or not features[index]["map_center_trusted"]:
+            map_radii[:] = np.nan
+        if np.isfinite(reference_radii).any() and np.isfinite(map_radii).any():
+            valid = np.isfinite(reference_radii) & np.isfinite(map_radii) & (reference_radii >= 20.0)
+            ratios = np.ones(12, dtype="float32")
+            ratios[valid] = np.clip(map_radii[valid] / reference_radii[valid], 0.60, 1.50)
+            if valid.any():
+                ratios[~valid] = float(np.clip(np.nanmedian(ratios[valid]), 0.60, 1.50))
+            radius_factor = 1.0 + 0.25 * (ratios - 1.0)
+            adjusted_radii = base_radii * radius_factor
+        else:
+            adjusted_radii = base_radii
+        adjusted_radii = np.clip(adjusted_radii, 0.0, 1000.0)
+        for quadrant in range(4):
+            adjusted_radii[4 + quadrant] = min(adjusted_radii[4 + quadrant], adjusted_radii[quadrant])
+            adjusted_radii[8 + quadrant] = min(adjusted_radii[8 + quadrant], adjusted_radii[4 + quadrant])
+        row["wind_radii_km"] = [round(float(value), 2) for value in adjusted_radii]
+        map_rmw_ratio = 1.0
+        if features[0]["map_center_trusted"] and features[index]["map_center_trusted"]:
+            ref_r64 = float(np.nanmedian(reference_radii[8:])) if np.isfinite(reference_radii[8:]).any() else np.nan
+            future_r64 = float(np.nanmedian(map_radii[8:])) if np.isfinite(map_radii[8:]).any() else np.nan
+            if np.isfinite(ref_r64) and np.isfinite(future_r64) and ref_r64 >= 20.0:
+                map_rmw_ratio = float(np.clip(future_r64 / ref_r64, 0.75, 1.25))
+                row["rmw_km"] = round(float(np.clip(
+                    float(base["rmw_km"]) * (1.0 + 0.15 * (map_rmw_ratio - 1.0)),
+                    0.0,
+                    300.0,
+                )), 2)
+        row["pressure_map_features"] = features[index]
+        corrected.append(row)
+    metadata = {
+        "enabled": True,
+        "method": "causal forecast pressure-map query plus confidence-weighted local-minimum/anomaly-radius coupling",
+        "map_weight": map_weight,
+        "minimum_confidence": "local minimum contribution decays directly with route-to-minimum confidence; untrusted minima have near-zero central-intensity weight",
+        "pressure_recovery_limit_hpa_per_6h": MAP_PRESSURE_RECOVERY_LIMIT_HPA,
+        "pressure_recovery_limit_source": "training-split 90th percentile of positive six-hour pressure changes",
+        "pressure_signal_weights": {
+            "tracked_map_minimum": 0.75,
+            "map_anomaly_extent": 0.25,
+        },
+        "wind_pressure_anchor": "observed current wind/pressure; map drives only future changes",
+        "radius_method": "learned radius baseline rescaled by trusted local quadrant pressure-anomaly extent; max four-degree footprint",
+        "map_features": features,
+        "official_forecasts_used": False,
+        "positive_lead_weather_product_used": False,
+    }
+    return corrected, metadata
+
+
+class Trackformer11IntensityEnsemble:
+    """Load frozen Trackformer1.1 experts and emit calibrated structure rows."""
+
+    def __init__(
+        self,
+        checkpoint_root: Path,
+        calibration_path: Path | None = None,
+        device: str | None = None,
+    ):
+        self.checkpoint_root = Path(checkpoint_root)
+        self.calibration_path = Path(calibration_path) if calibration_path else None
+        self.device = _device(device)
+        paths = sorted(self.checkpoint_root.glob("trackformer_1_1_intensity_seed*.pt"))
+        if len(paths) < 3:
+            raise FileNotFoundError(
+                f"expected three Trackformer1.1 intensity checkpoints in {self.checkpoint_root}; found {len(paths)}"
+            )
+        self.models: list[StructureSpatialExpert] = []
+        for path in paths[:3]:
+            payload = torch.load(path, map_location="cpu", weights_only=False)
+            config = payload["config"]
+            model = StructureSpatialExpert(
+                config["width"],
+                config["layers"],
+                config["heads"],
+                structure_residual=bool(config.get("structure_residual", False)),
+            )
+            model.load_state_dict(payload["model"])
+            self.models.append(model.to(self.device).eval())
+        self.calibration = {}
+        if self.calibration_path and self.calibration_path.exists():
+            self.calibration = json.loads(self.calibration_path.read_text(encoding="utf-8"))
+        self.structure_models: list[StructureSpatialExpert] = []
+        structure_root = self.calibration.get("structure_checkpoint_root")
+        if structure_root:
+            structure_root_path = self._resolve_root(structure_root)
+            structure_paths = sorted(structure_root_path.glob("trackformer_1_1_structure_seed*.pt"))
+            for path in structure_paths[:3]:
+                payload = torch.load(path, map_location="cpu", weights_only=False)
+                config = payload["config"]
+                model = StructureSpatialExpert(
+                    config["width"], config["layers"], config["heads"],
+                    structure_residual=bool(config.get("structure_residual", False)),
+                )
+                model.load_state_dict(payload["model"])
+                self.structure_models.append(model.to(self.device).eval())
+        self.temporal_models = []
+        temporal_root = self.calibration.get("temporal_checkpoint_root")
+        self.temporal_calibration = self.calibration
+        if temporal_root:
+            from trackformer_1_1_temporal import TemporalStructureSpatial
+
+            temporal_root_path = self._resolve_root(temporal_root)
+            temporal_paths = sorted(temporal_root_path.glob("trackformer_1_1_temporal_seed*.pt"))
+            for path in temporal_paths[:3]:
+                payload = torch.load(path, map_location="cpu", weights_only=False)
+                config = payload["config"]
+                model = TemporalStructureSpatial(
+                    config["width"], config["layers"], config["heads"]
+                )
+                model.load_state_dict(payload["model"])
+                self.temporal_models.append(model.to(self.device).eval())
+
+    @staticmethod
+    def _resolve_root(value: str | Path) -> Path:
+        path = Path(value)
+        return path if path.is_absolute() else Path(__file__).resolve().parent / path
+
+    @torch.no_grad()
+    def predict(
+        self,
+        track: np.ndarray,
+        field: np.ndarray,
+        current_wind: float,
+        current_pressure: float,
+        previous_wind: float,
+        previous_pressure: float,
+        current_structure: np.ndarray | None = None,
+        history_field: np.ndarray | None = None,
+        history_available: np.ndarray | None = None,
+    ) -> tuple[list[dict], dict]:
+        track = np.asarray(track, dtype="float32")
+        field = np.asarray(field, dtype="float32")
+        if track.shape != (9, 54):
+            raise ValueError(f"Trackformer1.1 track must have shape (9, 54), got {track.shape}")
+        if field.shape != (4, 17, 17):
+            raise ValueError(f"Trackformer1.1 field must have shape (4, 17, 17), got {field.shape}")
+        if history_field is not None:
+            history_field = np.asarray(history_field, dtype="float32")
+            if history_field.shape != (8, 17, 17):
+                raise ValueError(
+                    f"Trackformer1.1 history field must have shape (8, 17, 17), got {history_field.shape}"
+                )
+            if history_available is None:
+                history_available = np.ones(2, dtype="float32")
+            history_available = np.asarray(history_available, dtype="float32").reshape(-1)
+            if history_available.shape != (2,):
+                raise ValueError("Trackformer1.1 history availability must have shape (2,)")
+        if not np.isfinite(track).all() or not np.isfinite(field).all():
+            raise ValueError("Trackformer1.1 inputs contain non-finite values")
+        track_clip = self.calibration.get("track_input_clip", {})
+        lower = np.asarray(track_clip.get("lower", []), dtype="float32")
+        upper = np.asarray(track_clip.get("upper", []), dtype="float32")
+        if lower.shape == (track.shape[1],) and upper.shape == (track.shape[1],):
+            track = np.clip(track, lower[None, :], upper[None, :])
+        if current_structure is not None:
+            current_structure = np.asarray(current_structure, dtype="float32").reshape(-1)
+            if current_structure.shape != (13,):
+                raise ValueError(
+                    "Trackformer1.1 current structure must contain RMW plus twelve radii in native nautical miles"
+                )
+        structure_available = (
+            np.isfinite(current_structure).astype("float32")
+            if current_structure is not None
+            else None
+        )
+        current_available = float(np.isfinite(current_wind) and np.isfinite(current_pressure))
+        current_values = np.nan_to_num(
+            np.asarray([current_wind, current_pressure], dtype="float32") / TARGET_SCALE[2:4],
+            nan=0.0,
+        )
+        available = np.asarray([current_available, current_available], dtype="float32")
+        track_tensor = torch.from_numpy(track[None]).to(self.device)
+        field_tensor = torch.from_numpy(field[None]).to(self.device)
+        current_tensor = torch.from_numpy(current_values[None]).to(self.device)
+        available_tensor = torch.from_numpy(available[None]).to(self.device)
+        structure_tensor = None
+        structure_available_tensor = None
+        if current_structure is not None:
+            structure_tensor = torch.from_numpy(
+                np.nan_to_num(
+                    current_structure / TARGET_SCALE[4:],
+                    nan=0.0,
+                    posinf=0.0,
+                    neginf=0.0,
+                )[None]
+            ).to(self.device)
+            structure_available_tensor = torch.from_numpy(structure_available[None]).to(self.device)
+        states = np.stack([
+            model(
+                track_tensor,
+                field_tensor,
+                current_tensor,
+                available_tensor,
+                structure_tensor,
+                structure_available_tensor,
+            )[0][0].detach().cpu().numpy()
+            for model in self.models
+        ]).astype("float32")
+        states *= STRUCTURE_SCALE[None, None, :]
+        if self.structure_models:
+            structure_states = np.stack([
+                model(track_tensor, field_tensor, current_tensor, available_tensor)[0][0].detach().cpu().numpy()
+                for model in self.structure_models
+            ]).astype("float32") * STRUCTURE_SCALE[None, None, :]
+            expert_alpha = np.asarray(
+                self.calibration.get("structure_expert_alpha", []), dtype="float32"
+            )
+            if expert_alpha.shape != (LEADS, 13):
+                expert_alpha = np.zeros((LEADS, 13), dtype="float32")
+            for lead in range(LEADS):
+                states[:, lead, 2:] = (
+                    expert_alpha[lead][None, :] * states[:, lead, 2:]
+                    + (1.0 - expert_alpha[lead][None, :]) * structure_states[:, lead, 2:]
+                )
+        temporal_states = None
+        if self.temporal_models and history_field is not None and current_structure is not None:
+            history_tensor = torch.from_numpy(history_field[None]).to(self.device)
+            history_available_tensor = torch.from_numpy(history_available[None]).to(self.device)
+            temporal_states = np.stack([
+                model(
+                    track_tensor,
+                    field_tensor,
+                    current_tensor,
+                    available_tensor,
+                    structure_tensor,
+                    structure_available_tensor,
+                    history_tensor,
+                    history_available_tensor,
+                )[0][0].detach().cpu().numpy()
+                for model in self.temporal_models
+            ]).astype("float32") * STRUCTURE_SCALE[None, None, :]
+        if current_available:
+            calibrated_wind = _calibrated_wind(states, float(current_wind), self.calibration)
+            states[:, :, 1] = _calibrated_pressure(
+                states,
+                float(current_wind),
+                float(current_pressure),
+                float(previous_wind) if np.isfinite(previous_wind) else float(current_wind),
+                float(previous_pressure) if np.isfinite(previous_pressure) else float(current_pressure),
+                calibrated_wind,
+                self.calibration,
+            )
+            states[:, :, 0] = calibrated_wind
+            if temporal_states is not None:
+                temporal_alpha = self.calibration.get("temporal_wind_blend_alpha")
+                temporal_min_wind = float(self.calibration.get("temporal_wind_min_current_kt", 0.0))
+                if temporal_alpha and float(current_wind) >= temporal_min_wind:
+                    temporal_calibration = {"wind_blend_alpha": temporal_alpha}
+                    states[:, :, 0] = _calibrated_wind(
+                        temporal_states,
+                        float(current_wind),
+                        temporal_calibration,
+                    )
+        structure_alpha = np.asarray(
+            self.calibration.get("structure_blend_alpha", []), dtype="float32"
+        )
+        if current_structure is not None and structure_alpha.shape == (LEADS, 13):
+            available_structure = np.isfinite(current_structure)
+            anchor = np.nan_to_num(current_structure, nan=0.0, posinf=0.0, neginf=0.0)
+            for lead in range(LEADS):
+                alpha = np.clip(structure_alpha[lead], 0.0, 1.0)
+                for offset in np.flatnonzero(available_structure):
+                    channel = 2 + int(offset)
+                    states[:, lead, channel] = (
+                        alpha[int(offset)] * states[:, lead, channel]
+                        + (1.0 - alpha[int(offset)]) * anchor[int(offset)]
+                    )
+        states = _sanitize(states)
+        mean = states.mean(axis=0)
+        spread = states.std(axis=0)
+        model_label = (
+            "Trackformer1.1 residual-anchor spatial ensemble"
+            if self.models and self.models[0].structure_residual
+            else "frozen spatial structure ensemble"
+        )
+        rows = [_row(mean, spread, lead) for lead in range(LEADS)]
+        metadata = {
+            "model": f"{model_label} used as the Trackformer1.1 intensity head",
+            "checkpoint_count": len(self.models),
+            "calibration": str(self.calibration_path) if self.calibration_path and self.calibration_path.exists() else None,
+            "field_contract": "4x17x17 analysis patch, q/31.75 then clipped to [-4,4]",
+            "outputs": ["vmax_kt", "central_pressure_hpa", "rmw_km", "wind_radii_km"],
+            "native_structure_unit": "nautical_miles",
+            "output_distance_unit": "kilometres",
+            "ensemble_spread": "standard deviation across the three frozen spatial experts",
+            "structure_calibration": "lead- and component-wise validation blend with observed current RMW/radii when available",
+            "structure_expert_blend": bool(self.structure_models),
+            "temporal_wind_branch": bool(
+                self.temporal_models
+                and history_field is not None
+                and current_available
+                and float(current_wind) >= float(self.calibration.get("temporal_wind_min_current_kt", 0.0))
+            ),
+            "temporal_wind_branch_policy": "same-storm t-12/t-24 analysis patches; wind only; enabled above the validation-selected current-wind gate; base pressure calibration retained",
+            "pressure_anchor_alpha": self.calibration.get("pressure_anchor_alpha"),
+            "pressure_anchor_policy": self.calibration.get("pressure_anchor_policy"),
+            "track_input_policy": self.calibration.get("track_input_clip", {}).get("method"),
+            "official_forecasts_used": False,
+            "positive_lead_weather_used": False,
+            "device": str(self.device),
+        }
+        return rows, metadata

trackformer_1_1_route.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+"""Causal western-Pacific state and steering route.
+
+This module first extrapolates a bounded regional atmospheric state from the
+current, t-12, and t-24 analysis fields.  It then integrates the track using
+steering views that reach across the western Pacific rather than only a small
+storm-centered ring.  The pressure map and low-center diagnostics are derived
+from the same analysis-only state.
+
+No positive-lead weather field, official forecast track, or future observation
+is accepted as an input.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Sequence
+
+import numpy as np
+
+from trackformer_1_1_base_route import (
+    CURVATURE_VARIANTS,
+    SNAPSHOT_WEIGHTS,
+    TENDENCY_SCALES,
+    build_route,
+)
+
+
+VERSION = "Trackformer1.1-causal-western-Pacific-state-route"
+CAUSAL_ONLY = True
+PACIFIC_LON_RANGE = (100.0, 190.0)
+PACIFIC_LAT_RANGE = (0.0, 60.0)
+LEAD_HOURS = tuple(range(0, 121, 6))
+
+# The outer views make Japan, the East China Sea, Taiwan, the Philippines,
+# the subtropical ridge, and the western Pacific trough visible together.
+PACIFIC_ROUTE_VARIANTS = (
+    {"name": "inner_850", "level_weights": (1.0, 0.0, 0.0), "ring_degrees": (3.0, 6.0), "pressure_fraction": 0.05, "weight": 0.10},
+    {"name": "deep_inner", "level_weights": (0.269, 0.500, 0.231), "ring_degrees": (4.0, 10.0), "pressure_fraction": 0.10, "weight": 0.14},
+    {"name": "broad_850_ridge", "level_weights": (1.0, 0.0, 0.0), "ring_degrees": (8.0, 20.0), "pressure_fraction": 0.15, "weight": 0.18},
+    {"name": "pacific_850_environment", "level_weights": (1.0, 0.0, 0.0), "ring_degrees": (12.0, 32.0), "pressure_fraction": 0.18, "weight": 0.18},
+    {"name": "pacific_deep_environment", "level_weights": (0.269, 0.500, 0.231), "ring_degrees": (10.0, 30.0), "pressure_fraction": 0.22, "weight": 0.20},
+    {"name": "broad_500_trough", "level_weights": (0.0, 1.0, 0.0), "ring_degrees": (12.0, 34.0), "pressure_fraction": 0.16, "weight": 0.11},
+    {"name": "outer_200_jet", "level_weights": (0.0, 0.0, 1.0), "ring_degrees": (15.0, 35.0), "pressure_fraction": 0.08, "weight": 0.09},
+)
+
+
+def _clip_delta(values: np.ndarray) -> np.ndarray:
+    values = np.nan_to_num(np.asarray(values, dtype="float32"), copy=True)
+    for channel in range(values.shape[0]):
+        scale = float(np.nanpercentile(np.abs(values[channel]), 98.0))
+        if scale > 0.0 and math.isfinite(scale):
+            values[channel] = np.clip(values[channel], -2.0 * scale, 2.0 * scale)
+    return values
+
+
+def build_pacific_route(
+    fields: np.ndarray,
+    pressure: np.ndarray,
+    latitude: np.ndarray,
+    longitude: np.ndarray,
+    base_latitude: float,
+    base_longitude: float,
+    history_motion_km_per_6h: tuple[float, float] | None = None,
+) -> tuple[np.ndarray, np.ndarray, dict]:
+    """Build a broad-domain causal route from analysis-only inputs."""
+
+    members, weights, metadata = build_route(
+        fields,
+        latitude,
+        longitude,
+        base_latitude,
+        base_longitude,
+        pressure,
+        available=(1.0, 1.0),
+        route_variants=PACIFIC_ROUTE_VARIANTS,
+        curvature_variants=CURVATURE_VARIANTS,
+        snapshot_weights=SNAPSHOT_WEIGHTS,
+        tendency_scales=TENDENCY_SCALES,
+        history_motion_km_per_6h=history_motion_km_per_6h,
+    )
+    metadata = {
+        **metadata,
+        "version": VERSION,
+        "domain": {
+            "longitude_east": list(PACIFIC_LON_RANGE),
+            "latitude_north": list(PACIFIC_LAT_RANGE),
+            "steering_ring_max_degrees": 35.0,
+        },
+        "large_system_policy": "The route samples the complete analysis grid through broad 850/500/200-hPa and SLP-gradient views; nearby lows are represented by the same causal pressure field.",
+    }
+    return members, weights, metadata
+
+
+def forecast_pacific_state(
+    fields: np.ndarray,
+    pressure: np.ndarray,
+    lead_hours: Sequence[int] = LEAD_HOURS,
+) -> tuple[np.ndarray, np.ndarray, dict]:
+    """Return causal whole-domain pressure and multilevel states.
+
+    The forecast state is a bounded extrapolation of analysis tendency.  It is
+    deliberately not a claimed NWP forecast: no future weather product is
+    read, and no official forecast field is substituted.
+    """
+
+    fields = np.asarray(fields, dtype="float32")
+    pressure = np.asarray(pressure, dtype="float32")
+    if fields.shape[0] != 3 or pressure.shape[0] != 3:
+        raise ValueError(f"expected three causal snapshots, got {fields.shape} and {pressure.shape}")
+    recent_fields = fields[0] - fields[1]
+    older_fields = fields[1] - fields[2]
+    field_tendency = _clip_delta(0.6 * recent_fields + 0.4 * older_fields)
+    recent_pressure = pressure[0] - pressure[1]
+    older_pressure = pressure[1] - pressure[2]
+    pressure_tendency = _clip_delta(0.6 * recent_pressure[None, ...] + 0.4 * older_pressure[None, ...])[0]
+    scale = float(np.dot(np.asarray(TENDENCY_SCALES), np.asarray((0.15, 0.45, 0.40))))
+    state_fields = []
+    state_pressure = []
+    for hours in lead_hours:
+        progress = min(2.0, 0.5 * max(float(hours), 0.0) / 12.0)
+        state_fields.append(fields[0] + scale * progress * field_tendency)
+        state_pressure.append(pressure[0] + scale * progress * pressure_tendency)
+    return np.stack(state_fields).astype("float32"), np.stack(state_pressure).astype("float32"), {
+        "version": VERSION,
+        "causal_only": CAUSAL_ONLY,
+        "lead_hours": [int(value) for value in lead_hours],
+        "analysis_tendency_scale": scale,
+        "tendency_method": "0.6 * (current - t-12) + 0.4 * (t-12 - t-24), clipped per channel at the 98th percentile",
+        "input_policy": "current, t-12, and t-24 analysis fields only; no positive-lead or official forecast field",
+        "domain": {
+            "longitude_east": list(PACIFIC_LON_RANGE),
+            "latitude_north": list(PACIFIC_LAT_RANGE),
+        },
+    }
+
+
+def _distance_degrees(lat_a: float, lon_a: float, lat_b: float, lon_b: float) -> float:
+    delta_lon = ((lon_a - lon_b + 180.0) % 360.0) - 180.0
+    return math.hypot(lat_a - lat_b, delta_lon * math.cos(math.radians(0.5 * (lat_a + lat_b))))
+
+
+def detect_pressure_systems(
+    pressure: np.ndarray,
+    latitude: np.ndarray,
+    longitude: np.ndarray,
+    storm_latitude: float,
+    storm_longitude: float,
+    maximum: int = 8,
+) -> list[dict]:
+    """Find candidate closed lows from an analysis-only SLP field.
+
+    These are weather-field vortices, not labels imported from a typhoon
+    warning center.  They are used for diagnostics and route context.
+    """
+
+    try:
+        from scipy.ndimage import maximum_filter, minimum_filter
+    except ImportError:
+        return []
+    latitude = np.asarray(latitude, dtype="float32")
+    longitude = np.asarray(longitude, dtype="float32")
+    pressure = np.asarray(pressure, dtype="float32")
+    lat_mask = (latitude >= PACIFIC_LAT_RANGE[0]) & (latitude <= PACIFIC_LAT_RANGE[1])
+    lon_mask = (longitude >= PACIFIC_LON_RANGE[0]) & (longitude <= PACIFIC_LON_RANGE[1])
+    if not lat_mask.any() or not lon_mask.any():
+        return []
+    local = pressure[np.ix_(lat_mask, lon_mask)]
+    minimum = minimum_filter(local, size=13, mode="nearest")
+    surrounding_maximum = maximum_filter(local, size=41, mode="nearest")
+    threshold = float(np.nanpercentile(local, 18.0))
+    candidates = np.argwhere((local <= minimum + 0.05) & (local <= threshold) & ((surrounding_maximum - local) >= 2.0))
+    rows = []
+    lat_values = latitude[lat_mask]
+    lon_values = longitude[lon_mask]
+    for row, column in candidates:
+        lat = float(lat_values[row])
+        lon = float(lon_values[column])
+        if _distance_degrees(lat, lon, storm_latitude, storm_longitude) < 8.0:
+            continue
+        rows.append({
+            "latitude": round(lat, 3),
+            "longitude": round(lon, 3),
+            "pressure_hpa": round(float(local[row, column]), 2),
+            "local_low_prominence_hpa": round(float(surrounding_maximum[row, column] - local[row, column]), 2),
+            "kind": "analysis low/vortex candidate",
+        })
+    rows.sort(key=lambda item: (-item["local_low_prominence_hpa"], item["pressure_hpa"]))
+    selected = []
+    for row in rows:
+        if any(_distance_degrees(row["latitude"], row["longitude"], item["latitude"], item["longitude"]) < 4.0 for item in selected):
+            continue
+        selected.append(row)
+        if len(selected) >= maximum:
+            break
+    return selected
+
+
+__all__ = [
+    "VERSION",
+    "CAUSAL_ONLY",
+    "PACIFIC_LON_RANGE",
+    "PACIFIC_LAT_RANGE",
+    "LEAD_HOURS",
+    "PACIFIC_ROUTE_VARIANTS",
+    "build_pacific_route",
+    "forecast_pacific_state",
+    "detect_pressure_systems",
+]

trackformer_1_1_temporal.py

@@ -0,0 +1,92 @@
+"""Inference-only temporal branch used by Trackformer1.1.
+
+The training implementation is intentionally not part of the public model
+package. This module contains only the architecture needed to load the
+frozen temporal expert checkpoints.
+"""
+
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+
+from trackformer_1_1_intensity import StructureSpatialExpert
+
+
+class TemporalStructureSpatial(StructureSpatialExpert):
+    """Spatial expert augmented with same-storm t-12/t-24 analysis fields."""
+
+    def __init__(self, width: int, layers: int, heads: int):
+        super().__init__(width, layers, heads, structure_residual=True)
+        self.history_encoder = nn.Sequential(
+            nn.Conv2d(10, 64, 3, padding=1),
+            nn.GroupNorm(8, 64),
+            nn.SiLU(),
+            nn.Conv2d(64, width, 3, stride=2, padding=1),
+            nn.GroupNorm(8, width),
+            nn.SiLU(),
+        )
+        self.history_pool = nn.AvgPool2d(kernel_size=2, stride=2)
+        self.history_norm = nn.LayerNorm(width)
+        self.history_pos = nn.Parameter(torch.randn(1, 16, width) * 0.02)
+        self.history_out = nn.Conv2d(width, width, 1)
+        nn.init.zeros_(self.history_out.weight)
+        nn.init.zeros_(self.history_out.bias)
+
+    def forward(
+        self,
+        track: torch.Tensor,
+        field: torch.Tensor,
+        current: torch.Tensor,
+        available: torch.Tensor,
+        current_structure: torch.Tensor | None = None,
+        structure_available: torch.Tensor | None = None,
+        history: torch.Tensor | None = None,
+        history_available: torch.Tensor | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        track_tokens = self.track_encoder(
+            self.track_proj(track[:, :, self._thermo_cols]) + self.track_time
+        )
+        field_tokens = self.field_pool(self.field_encoder(field)).flatten(2).transpose(1, 2)
+        field_tokens = self.field_norm(field_tokens + self.field_pos)
+        if history is not None:
+            if history_available is None:
+                history_available = history.new_ones((history.shape[0], 2))
+            flags = history_available.view(-1, 2, 1, 1).expand(-1, 2, 17, 17)
+            history_tokens = self.history_pool(
+                self.history_encoder(torch.cat([history, flags], dim=1))
+            )
+            history_tokens = history_tokens + self.history_pos.permute(0, 2, 1).reshape(
+                1, history_tokens.shape[1], 4, 4
+            )
+            history_tokens = self.history_norm(history_tokens.flatten(2).transpose(1, 2))
+            history_tokens = history_tokens + self.history_out(
+                history_tokens.transpose(1, 2).reshape(
+                    history_tokens.shape[0], history_tokens.shape[2], 4, 4
+                )
+            ).flatten(2).transpose(1, 2)
+            field_tokens = field_tokens + history_tokens
+        memory = torch.cat([track_tokens, field_tokens], dim=1)
+        query = (self.query + self.lead_time).expand(track.shape[0], -1, -1)
+        hidden = self.decoder(query, memory)
+        state = self.state(hidden).clone()
+        state[:, :, :2] = state[:, :, :2] + (current * available)[:, None, :]
+        if current_structure is None or structure_available is None:
+            raise ValueError("Trackformer1.1 temporal expert requires current structure tensors")
+        state[:, :, 2:] = (
+            state[:, :, 2:]
+            + current_structure[:, None, :] * structure_available[:, None, :]
+        )
+        return state, self.log_scale(hidden)
+
+    @property
+    def _thermo_cols(self):
+        return (
+            [4, 5, 6, 7]
+            + list(range(8, 20))
+            + list(range(24, 40))
+            + [44, 45, 46, 47, 48, 49, 50, 51, 52, 53]
+        )
+
+
+__all__ = ["TemporalStructureSpatial"]

trackformer_v23.py

@@ -1,229 +0,0 @@
-"""Standalone TrackFormer v23 architecture — the best model in this project (434.96 km RMS track
-error, 10-seed ensemble, WP+EP 2020+ full-20-lead test set). Chain-of-thought (CoT) steering-flow
-prediction (v21) plus a temporal history of that steering representation (v23's addition).
-
-This file has zero notebook/exec tricks: every class below is copied verbatim from the training
-scripts that produced the released checkpoints (colab_train_v17.ipynb for TrackFormerV17, the "Base"
-that v21/v23 build on; colab_v26_train.py for TrackFormerCoT, v21's chain-of-thought forward pass;
-colab_v28_train.py for HistStem/TrackFormerHist, v23's temporal-history addition) -- so this module
-IS the architecture the checkpoints were trained with, not a reimplementation from memory. See
-run_v23.py for how to load a checkpoint and get a forecast, in either IBTrACS-only or full-steering
-mode.
-"""
-import math
-import torch
-import torch.nn as nn
-
-# ---- input column layout (54-dim per-6h track/thermo/env feature row) -----------------------
-KIN_COLS = [0, 1, 2, 3, 21, 22, 23, 40, 41, 42, 43]
-THERMO_COLS = [4, 5, 6, 7] + list(range(8, 20)) + list(range(24, 40)) + [44, 45, 46, 47]
-ENV_COLS = [48, 49, 50, 51, 52, 53]
-KIN_DIM, THERMO_DIM, ENV_DIM = len(KIN_COLS), len(THERMO_COLS), len(ENV_COLS)
-
-TARGET_SCALE = torch.tensor([100., 100., 35., 20., 50.] + [50.] * 12)
-
-# eval-only: this dict form is a leftover of the training scripts' exec-in-a-dict pattern
-# (TrackFormerCoT/TrackFormerHist index into it as G["..."], never as a bare global) -- kept as-is
-# rather than rewritten, since these classes are pasted in verbatim from the scripts that actually
-# produced the checkpoints. STEER_DROP only affects self.training branches, irrelevant at eval.
-G = {"KIN_COLS": KIN_COLS, "THERMO_COLS": THERMO_COLS, "ENV_COLS": ENV_COLS, "STEER_DROP": 0.0}
-STEER_DROP = 0.0     # bare-name fallback referenced by TrackFormerV17.forward (never actually
-                      # called for v21/v23 -- TrackFormerCoT overrides forward entirely -- kept
-                      # only so the class body is valid to define)
-USE_FLOW = 1
-USE_HIST = 1
-KM6H = 6 * 3600 / 1000.0
-
-_i, _j = torch.meshgrid(torch.arange(17) - 8, torch.arange(17) - 8, indexing="ij")
-_r = torch.hypot(_i.float(), _j.float()) * 2.5
-ANN = ((_r >= 3.0) & (_r <= 8.0)).float()          # 3-8 deg annulus mask matching the training target
-
-
-def sinusoidal(n, d):
-    p = torch.arange(n).unsqueeze(1).float()
-    dv = torch.exp(torch.arange(0, d, 2).float() * (-math.log(10000.0) / d))
-    e = torch.zeros(n, d); e[:, 0::2] = torch.sin(p * dv); e[:, 1::2] = torch.cos(p * dv)
-    return e
-
-
-def enc(d, h, ffn, dr, depth):
-    return nn.TransformerEncoder(nn.TransformerEncoderLayer(d, h, ffn, dr, batch_first=True,
-                                 norm_first=True, activation="gelu"), depth)
-
-
-def dec(d, h, ffn, dr, depth):
-    return nn.TransformerDecoder(nn.TransformerDecoderLayer(d, h, ffn, dr, batch_first=True,
-                                 norm_first=True, activation="gelu"), depth)
-
-
-class TrackFormerV17(nn.Module):
-    """Base architecture: track/thermo/env history encoders + steering-CNN + cross-attention
-    decoders. v21/v23 build on this but override forward() -- it is never called directly for v23,
-    kept here only because TrackFormerCoT inherits __init__ from it."""
-
-    def __init__(self, d=256, h=8, ffn=1024, dr=0.15, hist=9, leads=20):
-        super().__init__()
-        self.leads = leads
-        self.kin_proj = nn.Linear(KIN_DIM, d); self.thermo_proj = nn.Linear(THERMO_DIM, d)
-        self.env_proj = nn.Linear(ENV_DIM, d)
-        self.register_buffer("kin_time", sinusoidal(hist, d).unsqueeze(0))
-        self.register_buffer("thermo_time", sinusoidal(hist, d).unsqueeze(0))
-        self.register_buffer("env_time", sinusoidal(hist, d).unsqueeze(0))
-        self.kin_enc = enc(d, h, ffn, dr, 3); self.thermo_enc = enc(d, h, ffn, dr, 3)
-        self.env_enc = enc(d, h, ffn, dr, 2)
-        self.track_dec = dec(d, h, ffn, dr, 3); self.int_dec = dec(d, h, ffn, dr, 3)
-        self.track_q = nn.Parameter(torch.randn(1, leads, d) * 0.02)
-        self.int_q = nn.Parameter(torch.randn(1, leads, d) * 0.02)
-        self.register_buffer("qpos", sinusoidal(leads, d))
-        self.adapter = nn.Sequential(nn.Linear(d, d), nn.GELU(), nn.Linear(d, d))
-        nn.init.zeros_(self.adapter[-1].weight); nn.init.zeros_(self.adapter[-1].bias)
-        self.alpha = nn.Parameter(torch.zeros(leads)); self.rho = nn.Parameter(torch.ones(leads))
-        self.gturn = nn.Parameter(torch.zeros(leads))
-        self.steer_cnn = nn.Sequential(
-            nn.Conv2d(4, 24, 3, padding=1), nn.GELU(), nn.Dropout2d(0.10),
-            nn.Conv2d(24, 48, 3, stride=2, padding=1), nn.GELU(), nn.Dropout2d(0.10),
-            nn.Conv2d(48, d, 3, stride=2, padding=1), nn.GELU())
-        self.steer_pos = nn.Parameter(torch.zeros(1, 25, d))
-        self.track_res = nn.Linear(d, 2)
-        nn.init.zeros_(self.track_res.weight); nn.init.zeros_(self.track_res.bias)
-        self.int_state = nn.Linear(d, 15); self.int_logscale = nn.Linear(d, 15)
-
-    def forward(self, track, vpair, slp):
-        b = track.shape[0]
-        kin = self.kin_enc(self.kin_proj(track[:, :, KIN_COLS]) + self.kin_time)
-        thermo = self.thermo_enc(self.thermo_proj(track[:, :, THERMO_COLS]) + self.thermo_time)
-        env = self.env_enc(self.env_proj(track[:, :, ENV_COLS]) + self.env_time)
-        if self.training and STEER_DROP > 0:
-            keep = (torch.rand(b, 1, 1, 1, device=slp.device) >= STEER_DROP).float()
-            slp = slp * keep
-        st = self.steer_cnn(slp).flatten(2).transpose(1, 2) + self.steer_pos
-        tq = (self.track_q + self.qpos.unsqueeze(0)).expand(b, -1, -1)
-        h_track = self.track_dec(tq, torch.cat([kin, env, st], dim=1))
-        h_track = h_track + self.alpha.view(1, self.leads, 1) * self.adapter(thermo.mean(1).detach()).unsqueeze(1)
-        v0, vp = vpair[:, :2], vpair[:, 2:]
-        s0 = v0.norm(dim=1, keepdim=True).clamp(min=1e-3)
-        phi0 = torch.atan2(v0[:, 1], v0[:, 0])
-        dphi = phi0 - torch.atan2(vp[:, 1], vp[:, 0])
-        omega = torch.atan2(torch.sin(dphi), torch.cos(dphi))
-        phil = phi0.unsqueeze(1) + self.gturn.view(1, self.leads) * omega.unsqueeze(1)
-        speed = self.rho.view(1, self.leads) * s0
-        base = torch.stack([speed * torch.cos(phil), speed * torch.sin(phil)], dim=-1) / 100.0
-        motion = base + self.track_res(h_track)
-        iq = (self.int_q + self.qpos.unsqueeze(0)).expand(b, -1, -1)
-        h_int = self.int_dec(iq, torch.cat([thermo, env, kin.detach(), st.detach()], dim=1))
-        istate = self.int_state(h_int); ilog = self.int_logscale(h_int)
-        return torch.cat([motion, istate], -1), torch.cat([torch.zeros_like(motion), ilog], -1)
-
-
-class TrackFormerCoT(TrackFormerV17):
-    """v20's network, with the track derived from a predicted steering flow (v21)."""
-
-    def __init__(self, **kw):
-        super().__init__(**kw)
-        d = self.track_q.shape[-1]
-        self.flow_delta = nn.Linear(d, 2)
-        nn.init.zeros_(self.flow_delta.weight); nn.init.zeros_(self.flow_delta.bias)
-        self.A = nn.Parameter(torch.tensor([0.76, 0.91]))
-
-    def forward(self, track, vpair, slp):
-        b = track.shape[0]
-        KIN_COLS, THERMO_COLS, ENV_COLS = G["KIN_COLS"], G["THERMO_COLS"], G["ENV_COLS"]
-        STEER_DROP = G["STEER_DROP"]
-        kin = self.kin_enc(self.kin_proj(track[:, :, KIN_COLS]) + self.kin_time)
-        thermo = self.thermo_enc(self.thermo_proj(track[:, :, THERMO_COLS]) + self.thermo_time)
-        env = self.env_enc(self.env_proj(track[:, :, ENV_COLS]) + self.env_time)
-        if self.training and STEER_DROP > 0:
-            keep = (torch.rand(b, 1, 1, 1, device=slp.device) >= STEER_DROP).float()
-            slp = slp * keep
-        st = self.steer_cnn(slp).flatten(2).transpose(1, 2) + self.steer_pos
-        tq = (self.track_q + self.qpos.unsqueeze(0)).expand(b, -1, -1)
-        h_track = self.track_dec(tq, torch.cat([kin, env, st], dim=1))
-        h_track = h_track + self.alpha.view(1, self.leads, 1) * self.adapter(thermo.mean(1).detach()).unsqueeze(1)
-
-        w = ANN / ANN.sum()
-        sc = torch.as_tensor(DSC, device=slp.device, dtype=slp.dtype)
-        flow_now = (slp[:, 2:4] * w).sum((-2, -1)) * sc
-        fd = self.flow_delta(h_track)
-        flow_pred = flow_now.unsqueeze(1) + fd
-
-        v0, vp = vpair[:, :2], vpair[:, 2:]
-        s0 = v0.norm(dim=1, keepdim=True).clamp(min=1e-3)
-        phi0 = torch.atan2(v0[:, 1], v0[:, 0])
-        dphi = phi0 - torch.atan2(vp[:, 1], vp[:, 0])
-        omega = torch.atan2(torch.sin(dphi), torch.cos(dphi))
-        phil = phi0.unsqueeze(1) + self.gturn.view(1, self.leads) * omega.unsqueeze(1)
-        speed = self.rho.view(1, self.leads) * s0
-        base = torch.stack([speed * torch.cos(phil), speed * torch.sin(phil)], dim=-1) / 100.0
-        motion = base + self.track_res(h_track)
-        if USE_FLOW:
-            motion = motion + (self.A.view(1, 1, 2) * fd) * KM6H / 100.0
-        iq = (self.int_q + self.qpos.unsqueeze(0)).expand(b, -1, -1)
-        h_int = self.int_dec(iq, torch.cat([thermo, env, kin.detach(), st.detach()], dim=1))
-        istate = self.int_state(h_int); ilog = self.int_logscale(h_int)
-        return (torch.cat([motion, istate], -1),
-                torch.cat([torch.zeros_like(motion), ilog], -1), flow_pred)
-
-
-class HistStem(nn.Module):
-    """v17's steering stem, plus a zero-initialised residual carrying t-12h and t-24h (v23)."""
-
-    def __init__(self, base, ch):
-        super().__init__()
-        self.base = base
-        self.stem = nn.Sequential(
-            nn.Conv2d(10, 24, 3, padding=1), nn.GELU(), nn.Dropout2d(0.10),
-            nn.Conv2d(24, 48, 3, stride=2, padding=1), nn.GELU(), nn.Dropout2d(0.10),
-            nn.Conv2d(48, ch, 3, stride=2, padding=1), nn.GELU())
-        self.out = nn.Conv2d(ch, ch, 1)
-        nn.init.zeros_(self.out.weight); nn.init.zeros_(self.out.bias)
-        self.ctx = None
-
-    def forward(self, slp):
-        st = self.base(slp)
-        if USE_HIST and self.ctx is not None:
-            hist, have = self.ctx
-            hv = have.view(-1, 2, 1, 1).expand(-1, 2, hist.shape[-2], hist.shape[-1])
-            st = st + self.out(self.stem(torch.cat([hist, hv], 1)))
-        return st
-
-
-class TrackFormerHist(TrackFormerCoT):
-    """v23: v21 + a temporal history of the steering representation (t-12h, t-24h). This is the
-    class the released v23 checkpoints instantiate."""
-
-    def __init__(self, **kw):
-        super().__init__(**kw)
-        self.steer_cnn = HistStem(self.steer_cnn, self.steer_pos.shape[-1])
-
-    def forward(self, tr, vp, slp, hist=None, have=None):
-        sd = G["STEER_DROP"]
-        drop = self.training and sd > 0 and hist is not None
-        if drop:
-            keep = (torch.rand(tr.shape[0], 1, 1, 1, device=slp.device) >= sd).float()
-            slp = slp * keep
-            hist = hist * keep
-            have = have * keep.view(-1, 1)
-            G["STEER_DROP"] = 0.0
-        self.steer_cnn.ctx = (hist, have) if hist is not None else None
-        try:
-            return super().forward(tr, vp, slp)
-        finally:
-            self.steer_cnn.ctx = None
-            G["STEER_DROP"] = sd
-
-
-# ---- loaded at import time from the small companion norm-stats file --------------------------
-import os as _os
-import numpy as _np
-
-_stats = _np.load(_os.path.join(_os.path.dirname(__file__), "v23_norm_stats.npz"))
-TMEAN = _stats["tmean"]           # (54,) float32 -- per-column track/thermo/env feature mean
-TSTD = _stats["tstd"]             # (54,) float32 -- per-column std
-DSC = _stats["dsc"]               # (2,) float32 -- deep-layer-mean steering u/v de-normalization scale
-TARGET_SCALE = torch.from_numpy(_stats["target_scale"])   # (17,) -- motion(2)+intensity(15) scale
-
-
-def build_v23():
-    """Returns an uninitialized TrackFormerHist -- load_state_dict a v23_seed*.pt checkpoint,
-    call .eval()."""
-    return TrackFormerHist()

v23_seed0.pt

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

v23_seed3.pt

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

v23_seed4.pt

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

v23_seed5.pt

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

v23_seed6.pt

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

v23_seed7.pt

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

v23_seed8.pt

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

v23_seed9.pt

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