Publish Trackformer 1.2 announcement assets and matched DeepMind benchmark protocol

RELEASE_NOTES_TRACKFORMER_1_2.md

@@ -1,31 +1,41 @@
-# Trackformer 1.2 — research release
+# Trackformer 1.2 — pressure-field research model
 
-**[Download weights + code](https://github.com/yu314-coder/typhoon-predict/releases/download/trackformer-1.2/trackformer_1_2_field_20260929.tar.gz)** · **[Download the illustrated PDF](https://github.com/yu314-coder/typhoon-predict/releases/download/trackformer-1.2/trackformer.pdf)** · **[Hugging Face model card](https://huggingface.co/euler314/typhoon-predict)**
+**[Download weights + complete inference code](https://github.com/yu314-coder/typhoon-predict/releases/download/trackformer-1.2/trackformer_1_2_field_pressure_export_v2.tar.gz)** · **[Hugging Face](https://huggingface.co/euler314/typhoon-predict)** · **[Technical paper](https://github.com/yu314-coder/typhoon-predict/blob/main/paper/trackformer.pdf)**
 
-This release packages a verified moving-pressure-core model as **Trackformer 1.2**. It supersedes the withdrawn, unrelated route/scalar 1.2 candidate. Use `models/trackformer_1_2_field/predict.py`; the incompatible root-level candidate and example are no longer in the current source tree. Trackformer 1.1 remains available as a separate release.
+Trackformer 1.2 forecasts Western Pacific storm tracks, central pressure and evolving sea-level-pressure fields through +120 hours. A multiscale environmental-attention network conditions the moving pressure core; track and central pressure are read from that evolving field.
 
-The attached archive includes inference-only weights, exact source modules, an input wrapper, a data-contract/provenance manifest, detailed documentation, **1,473-daily-forecast / 270-storm benchmark bars**, the selected Fung-wong route-and-pressure example and recent **Surigae pressure maps with labelled isobars**. The training checkpoint was internally labelled version `1.2.73`, epoch 4; its SHA-256 is `f194a23d3f91ea76ad776dfad942fabd669eeae8b3fd665815463095367e9ee0`. The exported inference weights SHA-256 is `db49f36e85a3766defc4c172746897a1f783705d1ce8e6f9dfb8e87ae1d902cb`.
+## Direct detailed pressure-map output
 
-The README shows the user-selected **Fung-wong MP4** in place of Yagi; the interactive PRAPIROON showcase remains removed. The forecast starts 7 November 2025 at 00 UTC and uses actual saved 50-member mean pressure fields and routes through +120 h. Central-pressure MAE is 7.36 hPa against JMA best track from IBTrACS. The broad route is similar but not perfectly overlapping: mean geographic error is 130.9 km and +120 h error is 142.3 km. This is a selected development example, not typical skill. From +66 h the forecast centre leaves the regional patch; the video explicitly labels that only the saved coarse basin field is shown there. No detailed core is invented outside coverage.
+The current package exports all twenty six-hour leads with:
 
-The upgraded **illustrated technical paper** includes the detailed model architecture and equations, a module diagram, 1.2-versus-1.1 benchmark bars and lead-error curves, Fung-wong route and central-pressure curves, and the unmodified model-mean pressure field with 4 hPa isobars at +48 h. Its self-contained LaTeX embeds the saved figure data; `release_tools/build_paper_figures.py` reproduces the figure source from the published arrays. Selected examples are not representative performance, and the paper reports short-lead and pressure regressions. Model weights and implementation are unchanged.
+- Whole-WP basin pressure, the original fixed regional composite, and the actual **65×65 moving-core pressure field in physical hPa**.
+- Basin, regional and per-lead core latitude/longitude grids, coverage masks, issue time and exact valid times.
+- Original track/central-pressure outputs and an explicit **one-member** count.
+- Frozen weight/checkpoint identity and an optional PNG renderer: blue low pressure, red high pressure, labelled isobars.
 
-The Surigae illustration is a single forecast issued 2026-09-27 12 UTC, with 4 hPa isobars at +6/+24/+36 h. It is separate from the 50-member historical benchmark. Reproduction data and metric definitions are included. The model weights are unchanged in this documentation revision.
+```bash
+python models/trackformer_1_2_field/predict.py causal_issue_packet.npz forecast.npz --device cpu --pressure-map pressure_120h.png --map-lead 120
+python models/trackformer_1_2_field/plot_pressure.py forecast.npz pressure_24h.png --lead 24 --interval 2
+```
 
-This is not an operational warning service. Do not use for safety-critical decisions. A genuinely untouched storm-level holdout is still required before generalization claims.
+NumPy and PyTorch are required for inference; Matplotlib is optional for images. Use `--device mps` or `--device cuda` on a compatible system. Prepare the nine-analysis causal input packet using the [published schema](https://github.com/yu314-coder/typhoon-predict/blob/main/models/trackformer_1_2_field/README.md); this package does not fetch live weather automatically.
 
-## Completed daily benchmark and revised paper
+The core's 20-km spacing is a learned computational reconstruction, not new native observations. Invalid coverage remains masked. Fields are not shifted onto a route, and central pressure is not inserted as a display vortex. Ensemble members require geographic registration before physical-field averaging; this command is not the separate 50-member benchmark policy.
 
-All **1,473 daily forecasts across 270 distinct storms** completed at 2026-09-29T08:22:39Z. Every saved forecast SHA-256 was verified. Each storm has equal weight after its daily issues are averaged; all leads +6 through +120 h are included.
+**The learned modules, inference weights and forecast equations are unchanged.** The added export captures fields already produced by the released model. The original September 29 package remains available separately; use the pressure-export-v2 archive for the complete default output.
 
-| Equal-storm measure | 1.1 | 1.2 mean of 50 |
-| --- | ---: | ---: |
-| Mean track error | 798.4 km | 471.2 km |
-| +120 h track error | 1,646.4 km | 1,031.6 km |
-| Direction error | 51.58° | 34.96° |
-| Centred shape similarity | 0.7544 | 0.8837 |
-| Geographic path similarity | 0.5345 | 0.6560 |
+Inference weight SHA-256: `db49f36e85a3766defc4c172746897a1f783705d1ce8e6f9dfb8e87ae1d902cb`.
 
-This is a **41.0% reduction in mean track error** on a broader development cohort, not a certified untouched test. The 1.2-only central-pressure MAE is 12.62 hPa over 40 pressure-labelled storms; basin MSLP MAE is 2.72 hPa over 270 storms. There is no matched 1.1 pressure comparison. Retrospective analyses, different input pipelines, prior model selection and complete-five-day eligibility limit interpretation.
+## Matched development results
 
-The main README chart and redesigned eight-page paper now use these final equal-storm results. `evaluation/daily_storm_final.json` includes all storm scores; `release_tools/plot_daily_storm_final.py` reproduces the new bars. The paper includes the architecture, equations, lead-error chart, selected route/pressure curves and model isobars. **Weights and inference implementation are unchanged.**
+| Measure | 1.1 | 1.2 mean of 50 | Matched coverage |
+| --- | ---: | ---: | --- |
+| Mean track error | 798.4 km | 471.2 km | 1,473 daily starts / 270 storms |
+| Direction error | 51.58° | 34.96° | Same daily starts |
+| Central-pressure MAE against JMA | 13.53 hPa | 12.84 hPa | 134 common starts / 40 storms |
+
+Storms receive equal weight after valid leads and daily starts are averaged. The mean pressure reduction is small and its paired whole-storm uncertainty includes no improvement. These repeatedly inspected results are development evidence, not a certified untouched holdout. [Verified common-support metrics](https://github.com/yu314-coder/typhoon-predict/blob/main/evaluation/released_daily/released_daily_benchmark.json).
+
+The [model announcement](https://github.com/yu314-coder/typhoon-predict) includes the selected Mangkhut pressure-map animation and architecture. Selected examples are not representative skill. Auxiliary wind and pressure-derived radius diagnostics remain unvalidated; there is no native wind-radius forecast head in 1.2.
+
+This is a research model, not an operational warning service or a safety-critical forecast. Trackformer 1.1 remains a separate release. No historical archive, media, benchmark predictions or training run is modified by this exporter update.

models/trackformer_1_2_field/README.md

@@ -26,7 +26,40 @@ The `.npz` packet must contain exactly these arrays, with no object/pickle conte
 | `issue_time_ns` | scalar | Forecast issue timestamp in Unix nanoseconds. |
 | `history_time_ns` | `(9,)` | Nine consecutive six-hour timestamps ending at issue time. |
 
-Output `.npz` contains `lead_hours`, `track_lat_lon`, `central_pressure_hpa`, `basin_mslp_hpa` and `regional_mslp_hpa`. Pressure arrays are physical hPa. The regional grid is issue-relative and must be located using the static coordinate channels, not interpreted as a fixed global map.
+Output `.npz` contains twenty exact +6, +12, …, +120-hour forecasts. Pressure arrays are physical hPa. The moving core is exported by default, not just used internally for a central-pressure number:
+
+| Output | Shape | Meaning |
+| --- | --- | --- |
+| `basin_mslp_hpa` | `(20,25,33)` | Unchanged coarse Western Pacific pressure fields. |
+| `basin_latitude_deg`, `basin_longitude_deg` | `(25,33)` each | Basin geography from the actual input grid. |
+| `regional_mslp_hpa` | `(20,121,121)` | Unchanged fixed issue-relative pressure composites. |
+| `regional_latitude_deg`, `regional_longitude_deg` | `(121,121)` each | Fixed regional geography. |
+| `regional_valid` | `(20,121,121)` | Original model domain-support masks; not a guarantee of moving-core detail throughout this fixed patch. |
+| `core_mslp_hpa` | `(20,65,65)` | Actual learned moving-core fields, converted from model normalization to hPa. |
+| `core_latitude_deg`, `core_longitude_deg` | `(20,65,65)` each | Original moving-frame geographic coordinates at every forecast lead. |
+| `core_valid` | `(20,65,65)` | Original moving-core coverage masks. Mask false cells even when their stored pressure is finite. |
+| `track_lat_lon`, `central_pressure_hpa`, `track_valid` | `(20,2)`, `(20,)`, `(20,)` | Unchanged associated track and bilinear core-pressure readout, with domain support. |
+| `issue_time_ns`, `valid_time_ns` | scalar, `(20,)` | UTC Unix nanoseconds for the issue and each exact forecast lead. |
+| `issue_center_lat_lon`, `member_count` | `(2,)`, scalar | Initialization location and the honest count of one clean member. |
+| `pressure_export_json` | string scalar | Export schema, units, frozen checkpoint/weight hashes, reconstruction and coverage policy. |
+
+No field is shifted onto the forecast or observed route, and no central-pressure scalar is inserted into a display. The moving-core information spacing is **20 km computational reconstruction**, not new native high-resolution observations. Coordinates and masks must travel with the fields; an invalid cell is not a zero-pressure forecast. `central_pressure_hpa` is sampled from this same moving field at the associated centre, so it need not equal a discrete cell minimum or a labelled contour level.
+
+### Render a pressure map directly
+
+Install Matplotlib in your inference environment only if you want PNG rendering. NumPy and PyTorch suffice for the numerical export.
+
+```bash
+python models/trackformer_1_2_field/predict.py causal_issue_packet.npz forecast.npz --device cpu --pressure-map pressure_120h.png --map-lead 120 --isobar-interval 4
+```
+
+The optional image shows the whole Western Pacific basin and the actual moving core side by side, on one pressure colour scale: **blue low / red high**. It keeps original geography and masks unsupported core cells. To draw another saved lead without repeating inference:
+
+```bash
+python models/trackformer_1_2_field/plot_pressure.py forecast.npz pressure_24h.png --lead 24 --interval 2
+```
+
+All original track, central-pressure, basin/regional and auxiliary-wind outputs retain their existing definitions. The exporter verifies the downloaded weight SHA-256 against `manifest.json`; the learned model modules, weights and forward equations are unchanged.
 
 It also exposes the existing `maximum_wind_auxiliary_kt` scalar and experimental
 pressure-derived `pressure_wind_estimate_kt`, `rmw_estimate_km` and
@@ -47,4 +80,4 @@ The published 50-member mean is a separate evaluation policy: 50 deterministic s
 
 **Matched development evaluation:** the released 1.1 and 1.2 route comparison uses the same frozen **1,473 daily starts / 270 equal-weight storms**, +6 to +120 h. The completed native-pressure comparison has **134 common starts / 40 storms**; the other 1,339 starts lack valid frozen 1.1 intensity inputs and are not zero-scored. The Site defaults to central-pressure MAE: **13.53 / 12.84 hPa** against JMA and **12.84 / 12.55 hPa** against USA (1.1 / 1.2), slight mean improvements with paired whole-storm uncertainty including zero. The optional curve-similarity diagnostic is **(1 + centred cosine) / 2 at exact common valid times**, without time shifting or warping. JMA similarity is **0.7074 / 0.7118**; USA is **0.7237 / 0.6637** on 131 eligible non-flat curves. Removing level/amplitude makes this a shape diagnostic, not proof of correct pressure levels. Actual unshifted hPa timelines, agency masks and uncertainty remain separate. See the [shared snapshot](../../evaluation/released_daily/released_daily_benchmark.json), [verification receipt](../../evaluation/released_daily/released_daily_verification.json), [pressure protocol](../../docs/intensity_benchmark.md) and [public benchmark API](https://trackformer-weatherlab.rudin-euler-8253.chatgpt.site/api/benchmarks/released). A new matched WeatherNext Cyclones Mini run is in progress on these exact daily starts; results remain pending. See the [frozen protocol](../../docs/deepmind_daily_benchmark.md); no old scores are transferred.
 
-**Pressure-display coverage:** `regional_mslp_hpa` is the original fixed issue-relative composite, not an automatically extended moving-core map. When the forecast centre leaves that patch, a scalar central-pressure readout must not be inserted into the image to make it appear consistent. The Mangkhut film separately exports the actual moving model cores and registers member fields before averaging; [the current model card](https://huggingface.co/euler314/typhoon-predict) links the verified pressure arrays and links older fixed-patch films in a separate archive. The automatic History archive and its separate core recovery expose exact geography and coverage through [the public API](https://trackformer-weatherlab.rudin-euler-8253.chatgpt.site/history-api).
+**Pressure-display coverage:** `regional_mslp_hpa` remains the original fixed issue-relative composite. Use the separately exported `core_mslp_hpa` and its per-lead coordinates/mask when the storm moves away from that fixed patch. Do not extend it by inventing a vortex or moving it onto a route. If the moving core leaves supported basin geography, the corresponding masked cells remain unavailable. For an ensemble, register each physical member field onto a common geographic grid **before** averaging; do not average moving-frame array indices. The Mangkhut film uses that separate 50-member policy. Older fixed-patch films retain their original data in [the showcase archive](../../docs/showcase_archive.md). The automatic History archive and its separate core recovery expose geography and coverage through [the public API](https://trackformer-weatherlab.rudin-euler-8253.chatgpt.site/history-api).

models/trackformer_1_2_field/plot_pressure.py

@@ -0,0 +1,91 @@
+"""Plot the released model's saved geographic pressure fields without inference.
+
+The basin remains at 2.5 degrees. The moving core is the model's learned 20-km
+reconstruction, not extra native observations. Invalid coverage stays masked.
+"""
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+
+
+def render_pressure_map(data, output, lead=120, interval=4):
+    if not np.isfinite(interval) or interval <= 0:
+        raise ValueError("Isobar interval must be positive and finite")
+    indices = np.flatnonzero(np.asarray(data["lead_hours"]) == lead)
+    if len(indices) != 1:
+        raise ValueError("Choose a saved +6 to +120-hour forecast lead")
+    required = {"core_mslp_hpa", "core_latitude_deg", "core_longitude_deg", "core_valid",
+                "basin_latitude_deg", "basin_longitude_deg", "track_valid", "valid_time_ns", "member_count"}
+    if not required.issubset(data):
+        raise ValueError("This renderer requires the moving-core pressure export v2")
+    if int(np.asarray(data["member_count"])) != 1:
+        raise ValueError("This renderer accepts the clean one-member export, not unregistered ensemble cores")
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    i = int(indices[0])
+    basin = np.ma.masked_invalid(data["basin_mslp_hpa"][i])
+    core = np.ma.masked_where(~np.asarray(data["core_valid"][i], bool), data["core_mslp_hpa"][i])
+    core = np.ma.masked_invalid(core)
+    finite = np.concatenate((basin.compressed(), core.compressed()))
+    if not finite.size:
+        raise ValueError("No supported pressure field for this lead")
+    low = np.floor(finite.min() / interval) * interval
+    high = max(low + interval, np.ceil(finite.max() / interval) * interval)
+    levels = np.arange(low, high + interval * .5, interval)
+    fig, axes = plt.subplots(1, 2, figsize=(12, 5), layout="constrained")
+    plots = (
+        (basin, data["basin_longitude_deg"], data["basin_latitude_deg"], "Western Pacific · 2.5° basin field"),
+        (core, data["core_longitude_deg"][i], data["core_latitude_deg"][i], "Moving core · learned 20-km reconstruction"),
+    )
+    route = np.asarray(data["track_lat_lon"][:i + 1])
+    valid_route = np.asarray(data["track_valid"][:i + 1], bool)
+    for ax, (pressure, lon, lat, title) in zip(axes, plots):
+        ax.set_title(title, fontsize=11)
+        ax.set_xlabel("Longitude °E")
+        ax.set_ylabel("Latitude °N")
+        if pressure.count():
+            image = ax.pcolormesh(lon, lat, pressure, cmap="RdBu_r", vmin=low, vmax=high,
+                                  shading="auto", rasterized=True)
+            if pressure.max() > pressure.min():
+                lines = ax.contour(lon, lat, pressure, levels=levels, colors="#35424d", linewidths=.65)
+                ax.clabel(lines, levels[::2], fmt="%d", fontsize=7)
+        else:
+            ax.text(.5, .5, "Moving core outside supported basin coverage", ha="center", va="center", transform=ax.transAxes)
+        ax.plot(np.where(valid_route, route[:, 1], np.nan), np.where(valid_route, route[:, 0], np.nan),
+                color="#ad287b", linewidth=1.6)
+        if valid_route[i] and (ax is axes[0] or bool(np.asarray(data["core_valid"][i]).any())):
+            ax.scatter(route[i, 1], route[i, 0], s=25, c="#ad287b", edgecolors="white", zorder=4)
+        ax.grid(alpha=.2)
+    axes[0].set_xlim(100, 180)
+    axes[0].set_ylim(0, 60)
+    axes[1].set_xlim(float(np.min(plots[1][1])), float(np.max(plots[1][1])))
+    axes[1].set_ylim(float(np.min(plots[1][2])), float(np.max(plots[1][2])))
+    valid_time = datetime.fromtimestamp(int(np.asarray(data["valid_time_ns"])[i]) / 1e9, timezone.utc)
+    value = (f"{float(data['central_pressure_hpa'][i]):.1f} hPa" if valid_route[i] else "unavailable outside domain")
+    fig.suptitle(f"Trackformer 1.2 · +{lead:03d} h · {valid_time:%Y-%m-%d %H:%M UTC}\n"
+                 f"1 clean member · central pressure {value}", fontsize=12)
+    fig.colorbar(image, ax=axes, label="Model MSLP (hPa) · blue low / red high", shrink=.85)
+    fig.supxlabel(f"{interval:g} hPa isobars · original model geography · unsupported core cells masked; no pressure or route shifting", fontsize=9)
+    fig.savefig(Path(output), dpi=160)
+    plt.close(fig)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("forecast", type=Path)
+    parser.add_argument("output", type=Path)
+    parser.add_argument("--lead", type=int, default=120, choices=range(6, 121, 6))
+    parser.add_argument("--interval", type=float, default=4)
+    args = parser.parse_args()
+    with np.load(args.forecast, allow_pickle=False) as saved:
+        render_pressure_map({key: saved[key] for key in saved.files}, args.output, args.lead, args.interval)
+
+
+if __name__ == "__main__":
+    main()

models/trackformer_1_2_field/predict.py

@@ -6,6 +6,7 @@ must supply past/issue-time analyses on the exact grids in manifest.json.
 from __future__ import annotations
 
 import argparse
+import hashlib
 import json
 from pathlib import Path
 
@@ -27,6 +28,38 @@ INPUT_SHAPES = {
     "issue_mask": (2,),
 }
 
+PRESSURE_EXPORT_SCHEMA = "trackformer-1.2-pressure-fields-v2"
+
+
+def export_pressure_fields(outputs, inputs, contract, issue_time_ns):
+    """Capture existing forward outputs; never relocate or fit a display vortex."""
+    scale = float(contract["normalization"]["std"][0])
+    offset = float(contract["normalization"]["mean"][0])
+    global_static = inputs["global_static"][0].detach().cpu().numpy()
+    regional_static = inputs["regional_static"][0].detach().cpu().numpy()
+    leads = np.arange(6, 121, 6, dtype=np.int16)
+    if len(outputs) != len(leads):
+        raise ValueError("Detailed pressure export requires all twenty forecast leads")
+    return {
+        "core_mslp_hpa": torch.stack([
+            o["core"][0, 0] * scale + offset for o in outputs]).cpu().numpy(),
+        "core_latitude_deg": torch.stack([o["core_lat"][0] for o in outputs]).cpu().numpy(),
+        "core_longitude_deg": torch.stack([o["core_lon"][0] for o in outputs]).cpu().numpy(),
+        "core_valid": torch.stack([o["core_valid"][0, 0] for o in outputs]).cpu().numpy().astype(bool),
+        "basin_latitude_deg": global_static[0] * 90,
+        "basin_longitude_deg": (global_static[1] + 1) * 180,
+        "regional_latitude_deg": regional_static[0] * 90,
+        "regional_longitude_deg": (regional_static[1] + 1) * 180,
+        "regional_valid": torch.stack([
+            o["regional_valid"][0, 0] for o in outputs]).cpu().numpy().astype(bool),
+        "track_valid": torch.stack([o["track_valid"][0] for o in outputs]).cpu().numpy().astype(bool),
+        "issue_center_lat_lon": inputs["center"][0].detach().cpu().numpy(),
+        "issue_time_ns": np.asarray(issue_time_ns, dtype=np.int64),
+        "valid_time_ns": issue_time_ns + leads.astype(np.int64) * (3600 * 10**9),
+        "member_count": np.asarray(1, dtype=np.int16),
+        "core_information_spacing_km": np.asarray(20, dtype=np.float32),
+    }
+
 
 def load_packet(path: Path) -> dict[str, np.ndarray]:
     with np.load(path, allow_pickle=False) as packet:
@@ -54,7 +87,12 @@ def forecast(packet: Path, model_dir: Path, device: str = "cpu") -> dict[str, np
         raise ValueError("Unexpected public model version")
     contract = metadata["data_contract"]
     model = CoreForecaster(contract).to(device).eval()
-    state = torch.load(model_dir / "weights.pt", map_location="cpu", weights_only=True)
+    weights = model_dir / "weights.pt"
+    with weights.open("rb") as stream:
+        weight_sha256 = hashlib.file_digest(stream, "sha256").hexdigest()
+    if weight_sha256 != metadata["inference_weights_sha256"]:
+        raise ValueError("Weights do not match the released 1.2 manifest")
+    state = torch.load(weights, map_location="cpu", weights_only=True)
     model.load_state_dict(state, strict=True)
     inputs = {key: torch.from_numpy(value).to(device) for key, value in load_packet(packet).items()}
     with torch.inference_mode():
@@ -73,6 +111,9 @@ def forecast(packet: Path, model_dir: Path, device: str = "cpu") -> dict[str, np
         "regional_mslp_hpa": torch.stack([o["regional"][0, 0] for o in outputs]).cpu().numpy() * scale + offset,
         "maximum_wind_auxiliary_kt": torch.stack([o["vmax"][0] for o in outputs]).cpu().numpy(),
     }
+    with np.load(packet, allow_pickle=False) as source:
+        issue_time_ns = int(source["issue_time_ns"])
+    result.update(export_pressure_fields(outputs, inputs, contract, issue_time_ns))
     diagnostics = [summarize_members(diagnose_outputs(o, contract)) for o in outputs]
     result['maximum_wind_auxiliary_kt_valid'] = np.asarray(
         [d['estimates']['maximum_wind_auxiliary_kt']['mean'] is not None for d in diagnostics], dtype=bool)
@@ -84,6 +125,24 @@ def forecast(packet: Path, model_dir: Path, device: str = "cpu") -> dict[str, np
     if not all(np.isfinite(value).all() for value in result.values()):
         raise ValueError("Non-finite forecast")
     result['wind_estimation_json'] = np.asarray(json.dumps(diagnostics, allow_nan=False))
+    result['pressure_export_json'] = np.asarray(json.dumps({
+        "schema": PRESSURE_EXPORT_SCHEMA,
+        "public_version": "1.2",
+        "architecture": metadata["architecture"],
+        "inference_weights_sha256": weight_sha256,
+        "source_checkpoint_sha256": metadata["source_checkpoint_sha256"],
+        "members": 1,
+        "units": {"pressure": "hPa", "latitude": "degrees_north", "longitude": "degrees_east"},
+        "core_information_spacing_km": 20,
+        "core_method": "unchanged learned moving pressure field; physical hPa with original geographic coordinates",
+        "native_high_resolution_observations": False,
+        "native_detail_history_available": bool(inputs["detail_available"][0, 0].item()),
+        "regional_grid": "fixed issue-relative composite; outside moving-core coverage only basin information remains",
+        "coverage_policy": "apply core_valid, regional_valid and track_valid; invalid finite storage is not a supported forecast",
+        "central_pressure_policy": "existing bilinear moving-core readout at the associated forecast centre; not an independently inserted scalar",
+        "ensemble_policy": "one clean member; register physical fields on common geographic coordinates before any ensemble average",
+        "forecast_equations_changed": False,
+    }, allow_nan=False))
     return result
 
 
@@ -92,10 +151,17 @@ def main() -> None:
     parser.add_argument("packet", type=Path, help="Causal normalized .npz issue packet")
     parser.add_argument("output", type=Path, help="Output .npz path")
     parser.add_argument("--device", default="cpu", choices=("cpu", "mps", "cuda"))
+    parser.add_argument("--pressure-map", type=Path, help="Optional PNG of basin and actual moving-core pressure (requires Matplotlib)")
+    parser.add_argument("--map-lead", type=int, default=120, choices=range(6, 121, 6))
+    parser.add_argument("--isobar-interval", type=float, default=4, help="Pressure contour interval in hPa")
     args = parser.parse_args()
     result = forecast(args.packet, Path(__file__).resolve().parent, args.device)
     np.savez_compressed(args.output, **result)
     print(f"Saved 20 six-hour forecasts to {args.output}")
+    if args.pressure_map:
+        from plot_pressure import render_pressure_map
+        render_pressure_map(result, args.pressure_map, args.map_lead, args.isobar_interval)
+        print(f"Saved pressure map to {args.pressure_map}")
 
 
 if __name__ == "__main__":

release_tools/sync_public_model_cards.py

@@ -29,9 +29,13 @@ SYNC_FILES = (
     'models/trackformer_1_2_field/README.md',
     'models/trackformer_1_2_field/WIND_ESTIMATION.md',
     'models/trackformer_1_2_field/predict.py',
+    'models/trackformer_1_2_field/plot_pressure.py',
     'models/trackformer_1_2_field/wind_estimation.py',
     'release_tools/sync_public_model_cards.py',
     'release_tools/test_public_model_cards.py',
+    'release_tools/test_pressure_field_export.py',
+    'release_tools/verify_pressure_field_export.py',
+    'RELEASE_NOTES_TRACKFORMER_1_2.md',
     'release_tools/build_release_benchmark.py',
     'release_tools/plot_release_pressure_benchmark.py',
     'release_tools/plot_daily_storm_final.py',

release_tools/test_pressure_field_export.py

@@ -0,0 +1,111 @@
+"""Regression checks for the capture-only released 1.2 pressure export."""
+import hashlib
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+import numpy as np
+import torch
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "models/trackformer_1_2_field"))
+from predict import export_pressure_fields
+from plot_pressure import render_pressure_map
+
+
+class PressureFieldExportTest(unittest.TestCase):
+    def setUp(self):
+        self.contract = {"normalization": {"std": [40], "mean": [1000]}}
+        lat, lon = torch.meshgrid(torch.linspace(60, 0, 25), torch.linspace(100, 180, 33), indexing="ij")
+        rlat, rlon = torch.meshgrid(torch.linspace(30, 10, 121), torch.linspace(120, 140, 121), indexing="ij")
+        static = lambda y, x: torch.stack((y/90, x/180-1, torch.zeros_like(y), torch.zeros_like(y)))[None]
+        self.inputs = {"global_static": static(lat, lon), "regional_static": static(rlat, rlon),
+                       "center": torch.tensor([[20., 130.]])}
+        self.outputs = []
+        for i in range(20):
+            y, x = torch.meshgrid(torch.linspace(25, 15, 65), torch.linspace(125+i*.5, 135+i*.5, 65), indexing="ij")
+            core = -torch.exp(-((x-(130+i*.5))**2+(y-20)**2)/3)[None, None]
+            mask = torch.ones_like(core, dtype=torch.bool)
+            mask[:, :, :, 0] = False
+            self.outputs.append({"core": core, "core_lat": y[None], "core_lon": x[None], "core_valid": mask,
+                "regional_valid": torch.ones((1,1,121,121),dtype=torch.bool), "track_valid": torch.tensor([True]),
+                "pressure": torch.tensor([800.])})
+        self.issue = 1536624000 * 10**9
+
+    def test_core_units_geography_and_every_valid_time(self):
+        result = export_pressure_fields(self.outputs, self.inputs, self.contract, self.issue)
+        self.assertEqual(result["core_mslp_hpa"].shape, (20,65,65))
+        self.assertEqual(result["core_latitude_deg"].shape, (20,65,65))
+        self.assertEqual(result["core_longitude_deg"].shape, (20,65,65))
+        self.assertEqual(result["core_valid"].dtype, np.dtype(bool))
+        self.assertEqual(result["regional_valid"].shape, (20,121,121))
+        np.testing.assert_array_equal(result["valid_time_ns"], self.issue+np.arange(6,121,6,dtype=np.int64)*3600*10**9)
+        self.assertEqual(int(result["member_count"]), 1)
+        self.assertEqual(float(result["core_information_spacing_km"]), 20)
+        self.assertAlmostEqual(float(result["core_mslp_hpa"][0,32,32]),960)
+        np.testing.assert_array_equal(result["core_longitude_deg"][19], self.outputs[19]["core_lon"][0].numpy())
+        self.assertFalse(result["core_valid"][:,:,0].any())
+
+    def test_capture_preserves_tensors_and_never_inserts_scalar_pressure(self):
+        before = [{k:v.clone() for k,v in o.items()} for o in self.outputs]
+        result = export_pressure_fields(self.outputs, self.inputs, self.contract, self.issue)
+        self.assertGreater(float(result["core_mslp_hpa"].min()), float(self.outputs[0]["pressure"][0]))
+        for old, new in zip(before, self.outputs):
+            for key in old:
+                self.assertTrue(torch.equal(old[key], new[key]), key)
+
+    def test_a_moving_core_can_leave_the_original_fixed_patch(self):
+        result = export_pressure_fields(self.outputs, self.inputs, self.contract, self.issue)
+        fixed_east = float(result["regional_longitude_deg"].max())
+        self.assertGreater(float(result["core_longitude_deg"][-1].max()), fixed_east)
+        np.testing.assert_array_equal(result["regional_longitude_deg"], (self.inputs["regional_static"][0,1].numpy()+1)*180)
+
+    def test_incomplete_rollout_is_rejected(self):
+        with self.assertRaisesRegex(ValueError, "twenty"):
+            export_pressure_fields(self.outputs[:-1], self.inputs, self.contract, self.issue)
+
+    def plot_data(self):
+        result = export_pressure_fields(self.outputs, self.inputs, self.contract, self.issue)
+        result.update(lead_hours=np.arange(6,121,6), basin_mslp_hpa=np.stack([
+            1005+self.inputs["global_static"][0,0].numpy()*10+i*.1 for i in range(20)]),
+            central_pressure_hpa=np.full(20,960),
+            track_lat_lon=np.column_stack((np.full(20,20),130+np.arange(20)*.5)))
+        return result
+
+    def test_renderer_accepts_real_geography_and_distinct_leads(self):
+        with tempfile.TemporaryDirectory(prefix="pressure-export-test-") as folder:
+            first, last = Path(folder)/"first.png", Path(folder)/"last.png"
+            data = self.plot_data()
+            render_pressure_map(data, first, 6, 4)
+            render_pressure_map(data, last, 120, 4)
+            self.assertGreater(first.stat().st_size, 10000)
+            self.assertNotEqual(hashlib.sha256(first.read_bytes()).digest(), hashlib.sha256(last.read_bytes()).digest())
+
+    def test_missing_core_is_masked_not_filled_from_scalar(self):
+        data = self.plot_data()
+        data["core_valid"][:] = False
+        original = data["core_mslp_hpa"].copy()
+        with tempfile.TemporaryDirectory(prefix="pressure-export-test-") as folder:
+            render_pressure_map(data, Path(folder)/"masked.png", 120)
+        np.testing.assert_array_equal(data["core_mslp_hpa"], original)
+
+    def test_invalid_contour_interval_and_unregistered_ensemble_are_rejected(self):
+        for interval in (0,-1,np.nan):
+            with self.assertRaisesRegex(ValueError, "interval"):
+                render_pressure_map(self.plot_data(), "unused.png", interval=interval)
+        data = self.plot_data()
+        data["member_count"] = np.array(50)
+        with self.assertRaisesRegex(ValueError, "one-member"):
+            render_pressure_map(data, "unused.png")
+
+    def test_released_neural_source_hashes_are_unchanged(self):
+        directory = ROOT/"models/trackformer_1_2_field"
+        manifest = json.loads((directory/"manifest.json").read_text())
+        for name, expected in manifest["source_module_sha256"].items():
+            self.assertEqual(hashlib.sha256((directory/name).read_bytes()).hexdigest(), expected, name)
+
+
+if __name__ == "__main__":
+    unittest.main()

release_tools/verify_pressure_field_export.py

@@ -0,0 +1,120 @@
+"""CPU-only export regression using an existing causal batched issue packet.
+
+This checks packaging/field consistency, not forecast skill. It never calls MPS,
+changes neural weights, or writes into historical archive/training directories.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import shutil
+import sys
+from pathlib import Path
+from unittest.mock import patch
+
+import numpy as np
+import torch
+
+ROOT = Path(__file__).resolve().parents[1]
+MODEL = ROOT / "models/trackformer_1_2_field"
+sys.path.insert(0, str(MODEL))
+import predict
+from model import CoreForecaster
+from baseline_model import base
+from plot_pressure import render_pressure_map
+
+
+def sha(path):
+    with Path(path).open("rb") as stream:
+        return hashlib.file_digest(stream, "sha256").hexdigest()
+
+
+def verify(batched_packet, weights, work):
+    work = work.resolve()
+    if not work.is_relative_to(Path("/Volumes/D")):
+        raise ValueError("Diagnostic artifacts must remain on D")
+    work.mkdir(parents=True, exist_ok=True)
+    directory = work / "inference"
+    directory.mkdir(exist_ok=True)
+    for source in MODEL.iterdir():
+        if source.is_file() and source.suffix in (".py", ".md", ".json"):
+            shutil.copy2(source, directory / source.name)
+    shutil.copy2(weights, directory / "weights.pt")
+    metadata = json.loads((directory / "manifest.json").read_text())
+    for name, expected in metadata["source_module_sha256"].items():
+        if sha(directory / name) != expected:
+            raise ValueError("Frozen neural module changed: " + name)
+    with np.load(batched_packet, allow_pickle=False) as source:
+        arrays = {key: np.asarray(source[key])[0] for key in predict.INPUT_SHAPES}
+        arrays["history_time_ns"] = np.asarray(source["history_time_ns"], dtype=np.int64)
+        arrays["issue_time_ns"] = np.asarray(arrays["history_time_ns"][-1], dtype=np.int64)
+    packet = work / "causal_issue_packet.npz"
+    np.savez_compressed(packet, **arrays)
+    captured, origins = [], []
+
+    class CapturingModel(CoreForecaster):
+        def step(self, state):
+            next_state, out = super().step(state)
+            captured.append(out)
+            origins.append(next_state["origin"])
+            return next_state, out
+
+    torch.set_num_threads(2)
+    torch.set_num_interop_threads(1)
+    with patch.object(predict, "CoreForecaster", CapturingModel):
+        result = predict.forecast(packet, directory, "cpu")
+    contract = metadata["data_contract"]
+    scale, offset = contract["normalization"]["std"][0], contract["normalization"]["mean"][0]
+    reference = {
+        "track_lat_lon": torch.stack([o["center"][0] for o in captured]).numpy(),
+        "central_pressure_hpa": torch.stack([o["pressure"][0] for o in captured]).numpy(),
+        "basin_mslp_hpa": torch.stack([o["global"][0,0] for o in captured]).numpy()*scale+offset,
+        "regional_mslp_hpa": torch.stack([o["regional"][0,0] for o in captured]).numpy()*scale+offset,
+        "maximum_wind_auxiliary_kt": torch.stack([o["vmax"][0] for o in captured]).numpy(),
+    }
+    for key, expected in reference.items():
+        np.testing.assert_array_equal(result[key], expected, err_msg="Original readout changed: " + key)
+    alignment = []
+    for i, (out, origin) in enumerate(zip(captured, origins)):
+        # The original model's own geographic sampler, not a centre/minimum fit.
+        grid = CoreForecaster.core_grid(None, out["center"][:,0,None,None], out["center"][:,1,None,None], origin)
+        sampled = base.sample_field(torch.from_numpy(result["core_mslp_hpa"][i])[None,None], grid)[0,0,0,0]
+        alignment.append(abs(float(sampled) - float(result["central_pressure_hpa"][i])))
+        np.testing.assert_array_equal(result["core_latitude_deg"][i], out["core_lat"][0].numpy())
+        np.testing.assert_array_equal(result["core_longitude_deg"][i], out["core_lon"][0].numpy())
+        np.testing.assert_array_equal(result["core_valid"][i], out["core_valid"][0,0].numpy())
+    if max(alignment) > 1e-3:
+        raise ValueError("Exported core does not reproduce its original central-pressure readout")
+    np.savez_compressed(work / "forecast.npz", **result)
+    for lead in (6, 120):
+        render_pressure_map(result, work / f"pressure_{lead:03d}h.png", lead, 4)
+    receipt = {
+        "state": "verified_cpu_export_regression",
+        "scientific_benchmark": False,
+        "model": "Trackformer 1.2", "members": 1,
+        "device": "cpu", "forecast_steps": 20,
+        "issue_time_ns": int(result["issue_time_ns"]),
+        "core_shape": list(result["core_mslp_hpa"].shape),
+        "core_min_hpa": float(result["core_mslp_hpa"][result["core_valid"]].min()),
+        "core_max_hpa": float(result["core_mslp_hpa"][result["core_valid"]].max()),
+        "central_pressure_alignment_max_error_hpa": max(alignment),
+        "original_outputs_bit_identical": list(reference),
+        "coordinates_and_masks_match_forward_outputs": True,
+        "inference_weights_sha256": sha(weights),
+        "source_packet_sha256": sha(batched_packet),
+        "forecast_sha256": sha(work / "forecast.npz"),
+        "native_detail_history_available": bool(arrays["detail_available"][0]),
+        "core_is_learned_reconstruction_not_native_observations": True,
+    }
+    (work / "verification.json").write_text(json.dumps(receipt, indent=2) + "\n")
+    print(json.dumps(receipt, indent=2))
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--batched-packet", type=Path, required=True)
+    parser.add_argument("--weights", type=Path, required=True)
+    parser.add_argument("--work", type=Path, required=True)
+    args = parser.parse_args()
+    verify(args.batched_packet, args.weights, args.work)