# WeatherNext2 vs WeatherNext Cyclones: Key Differences in Model Checkpoints Explained

> Explore WeatherNext2 vs WeatherNext Cyclones model checkpoints. Discover key differences in their transformer backbones and cyclone-specific forecasting capabilities for tropical weather.

- Repository: [Google DeepMind/weathernext](https://github.com/google-deepmind/weathernext)
- Tags: deep-dive
- Published: 2026-08-12

---

**Both checkpoints share the same mesh-based transformer backbone, but WeatherNext Cyclones adds 13 cyclone-specific output variables and a points-to-mesh GNN sub-module for tropical cyclone forecasting.**

WeatherNext2 and WeatherNext Cyclones are two specialized checkpoints built atop DeepMind's *Weather-Next* architecture—a mesh-based transformer that predicts atmospheric fields from input variables. While they leverage identical core parameters, these checkpoints diverge in their **target variables**, **model heads**, and **training data** to serve distinct forecasting needs.

## Target Variables: 31 Standard Fields vs 44 Total Fields

The most visible difference lies in what each model predicts:

- **WeatherNext2** ([`weathernext/weathernext2/configs/WeatherNext2.json`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/weathernext2/configs/WeatherNext2.json)): Outputs **31 standard atmospheric variables** including temperature, geopotential, wind components (u/v), specific humidity, and 6-hour total precipitation. The `target_variables` tuple contains no cyclone-specific entries.

- **WeatherNext Cyclones** ([`weathernext/weathernext2/configs/WeatherNextCyclones.json`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/weathernext2/configs/WeatherNextCyclones.json)): Outputs the **same 31 atmospheric variables plus 13 cyclone-specific fields**. These include:
  - `cyclone_exists_gaussian_unit_mode` — cyclone presence probability
  - `cyclone_all_wind_disc` — wind field disc representation
  - `cyclone_usa_r34_ne_radius_disc` — radius of 34-knot winds (northeast quadrant)
  - Additional quadrant-specific wind radii and intensity indicators

Lines ~400–440 of [`WeatherNextCyclones.json`](https://github.com/google-deepmind/weathernext/blob/main/WeatherNextCyclones.json) append these cyclone fields to the base `target_variables` tuple.

## Architecture: Single Latent-Dense Block vs Points-to-Mesh GNN

Beyond output labels, the cyclones checkpoint introduces specialized neural network components:

| Component | WeatherNext2 | WeatherNext Cyclones |
|-----------|-----------|----------------------|
| **Core predictor** | `noisy_function_kwargs.latent_dense_kwargs` → output-dense block | Same base, **plus** `noisy_function_kwargs.points_to_mesh_model_ctor` |
| **Cyclone geometry encoding** | None | Points-to-mesh GNN with edge encoder and spatial edge-feature generators |
| **Implementation files** | Standard `weathernext/weathernext2/` modules | [`weathernext/cyclones/cyclone_utils.py`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/cyclones/cyclone_utils.py) for mesh-compatible cyclone data conversion |

The **points-to-mesh GNN** explicitly encodes cyclone-specific geometry—converting point-based cyclone track data into the model's native mesh representation.

## Training Data: ERA5 Only vs ERA5 + IBTrACS Cyclone Catalogue

Data sources determine what each model learns to predict:

- **WeatherNext2**: Trained exclusively on global **ERA-Interim/ERA5 reanalysis** covering standard atmospheric fields.

- **WeatherNext Cyclones**: Trained on the same atmospheric data **augmented with the IBTrACS cyclone catalogue**. The [`weathernext/cyclones/ibtracs_processing_utils.py`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/cyclones/ibtracs_processing_utils.py) module parses IBTrACS NetCDF files, extracts historical cyclone tracks, and converts them into the model's training label format.

This dual-source training enables the cyclones checkpoint to learn relationships between large-scale atmospheric conditions and tropical cyclone evolution.

## Loading and Inspecting Checkpoints in Code

Both checkpoints use the same loader API from [`weathernext/utils/checkpoint.py`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/utils/checkpoint.py):

```python
from weathernext.utils import checkpoint

# Load WeatherNext2 (standard atmospheric forecast)

ckpt2 = checkpoint.load_checkpoint(
    "gs://weather-next/checkpoints/WeatherNext2.ckpt")

# Load WeatherNext Cyclones (cyclone-aware forecast)

ckpt_cyclones = checkpoint.load_checkpoint(
    "gs://weather-next/checkpoints/WeatherNextCyclones.ckpt")

```

### Inspecting target variable differences

```python
def list_targets(cfg):
    return [v["value"] for v in cfg["objects"]["tuple_2"]["items"]]

# Compare output sets

targets2 = list_targets(ckpt2.config)
targets_cyc = list_targets(ckpt_cyclones.config)

print(f"WeatherNext2: {len(targets2)} variables")
print(f"WeatherNext Cyclones: {len(targets_cyc)} variables")
print(f"Added cyclone fields: {set(targets_cyc) - set(targets2)}")

```

## Running Cyclone-Specific Forecasts

To leverage the cyclone outputs, use the `direct_tracker` inference pipeline:

```python
from weathernext.cyclones import direct_tracker

# initial_state must include atmospheric inputs + cyclone conditioning

forecast = direct_tracker.run_forecast(
    checkpoint=ckpt_cyclones,
    initial_state=initial_state,
    lead_time_hours=72  # 3-day cyclone track forecast

)

```

The `direct_tracker` module ([`weathernext/cyclones/direct_tracker.py`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/cyclones/direct_tracker.py)) coordinates the forward pass through both the atmospheric transformer and the cyclone-specific output heads.

## Key Source Files Reference

| File Path | Purpose |
|-----------|---------|
| [`weathernext/weathernext2/configs/WeatherNext2.json`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/weathernext2/configs/WeatherNext2.json) | Base configuration for standard atmospheric forecasting |
| [`weathernext/weathernext2/configs/WeatherNextCyclones.json`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/weathernext2/configs/WeatherNextCyclones.json) | Extended configuration with cyclone targets and GNN sub-modules |
| [`weathernext/cyclones/cyclone_utils.py`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/cyclones/cyclone_utils.py) | Cyclone-to-mesh data conversion utilities |
| [`weathernext/cyclones/ibtracs_processing_utils.py`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/cyclones/ibtracs_processing_utils.py) | IBTrACS catalogue parsing and label generation |
| [`weathernext/cyclones/direct_tracker.py`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/cyclones/direct_tracker.py) | Inference wrapper for cyclone forecasting |
| [`weathernext/utils/checkpoint.py`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/utils/checkpoint.py) | Unified checkpoint loading for both model variants |

## Model Size and Computational Equivalence

Despite their functional differences, **parameter counts and FLOPs are essentially identical** between the two checkpoints. The cyclone-specific additions (points-to-mesh GNN, expanded output head) contribute negligible overhead relative to the core transformer backbone. Both checkpoints use the same mesh resolution, attention mechanisms, and latent representations—differing only in the final output layer structure and training supervision signals.

## Summary

- **WeatherNext2** is a pure atmospheric forecast model with 31 standard output variables, suitable for general weather prediction tasks.

- **WeatherNext Cyclones** extends the same architecture with 13 additional cyclone-specific outputs and a points-to-mesh GNN, enabling explicit tropical cyclone track and intensity forecasting.

- **Shared infrastructure**—checkpoint loading, core transformer weights, and inference APIs—makes switching between variants straightforward.

- **Training data differentiation** (ERA5 only vs ERA5 + IBTrACS) is the fundamental distinction that enables cyclone-aware predictions without altering base model capacity.

## Frequently Asked Questions

### Can I use WeatherNext2 checkpoint to predict cyclone tracks?

No. The WeatherNext2 checkpoint lacks both the cyclone-specific output variables and the points-to-mesh GNN sub-module required to encode cyclone geometry. While the base transformer might implicitly capture some cyclone-related patterns in its atmospheric outputs, explicit cyclone forecasting requires the WeatherNext Cyclones checkpoint with its specialized training on IBTrACS data.

### Do I need different input data formats for each checkpoint?

Both checkpoints accept the same core atmospheric input variables from ERA5. However, WeatherNext Cyclones optionally accepts additional cyclone conditioning information (e.g., current IBTrACS position) through the `initial_state` passed to `direct_tracker.run_forecast()`. For pure atmospheric forecasting without cyclone initialization, inputs remain identical.

### Is the cyclone GNN active during standard atmospheric inference?

The points-to-mesh GNN only participates in forward passes when cyclone-specific targets are requested. When loading WeatherNext Cyclones for standard 31-variable atmospheric prediction, the additional cyclone heads are not computed. The architecture uses conditional computation paths based on the requested output subset.

### How do I convert between checkpoint formats?

Direct conversion is not supported—the checkpoints differ in their output layer dimensions and GNN sub-module parameters. However, both share frozen transformer backbone weights, so transfer learning or fine-tuning from WeatherNext2 to cyclone prediction would require re-initializing and re-training the output heads with IBTrACS supervision, essentially reproducing the WeatherNext Cyclones training pipeline.