# How Norm Conditioning Features Improve Weather Forecast Accuracy in WeatherNext

> Discover how norm conditioning features boost weather forecast accuracy in WeatherNext. Learn how normalized scalar context enhances climate regime adaptation for more precise predictions.

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

---

**Norm conditioning features improve forecast accuracy by providing globally-normalized scalar context (such as surface pressure norms or solar radiation indices) through a lightweight dense encoder, allowing the model to adapt its dynamics to large-scale climate regimes without learning these patterns from noisy spatial data alone.**

WeatherNext, Google DeepMind's state-of-the-art weather forecasting system, leverages **norm conditioning** to inject critical global information directly into its neural network pipeline. This technique addresses a fundamental challenge in data-driven weather modeling: local spatial patches often lack sufficient context to infer large-scale atmospheric states. By explicitly providing normalized scalar features as conditioning inputs, the model achieves more stable training and superior forecast skill across temperature, precipitation, and other target variables.

## What Norm Conditioning Features Are

Norm conditioning features are **globally-aggregated, pre-normalized scalar variables** extracted from the input dataset and processed separately from the main spatiotemporal fields. Unlike raw grid-point values, these features represent whole-field statistics or specific climate indices that characterize the overall atmospheric state.

Common examples include:

- `surface_pressure_norm` – normalized global surface pressure patterns
- `solar_radiation_norm` – normalized incoming solar radiation
- Learned "noise-level" encodings for generative model variants

These features are **mean-zero, unit-variance normalized** before injection, ensuring they contribute stable, comparable signals regardless of absolute magnitude variations.

## How Norm Conditioning Improves Forecast Accuracy

The mechanism delivers four concrete benefits that directly translate to improved predictive skill:

| Benefit | Mechanism | Impact on Accuracy |
|---------|-----------|------------------|
| **Global context provision** | Dense encoder summarizes climate-state information difficult to infer locally | Model adjusts dynamics to large-scale regimes (El Niño vs. neutral conditions) without reconstructing them from noisy patches |
| **Training stabilization** | Pre-normalized conditioning channels reduce covariate shift | Deeper GNN and Transformer layers focus capacity on learning spatial patterns rather than adaptive normalization |
| **Experimental flexibility** | New scalars added via configuration (`norm_conditioning_features` list) | Researchers can test climate indices (ENSO, MJO) for target-specific skill improvements |
| **Parameter efficiency** | Only a small MLP encodes conditioning; spatial model parameters unchanged | Quality gains with negligible compute overhead, suitable for operational deployment |

## Implementation Architecture

The norm conditioning pipeline operates across three core components in the WeatherNext codebase:

### 1. Feature Splitting ([`architecture_utils.py`](https://github.com/google-deepmind/weathernext/blob/main/architecture_utils.py))

The `split_norm_conditioning_features` function separates conditioning variables from the main dataset before model processing. This ensures spatial encoders receive only grid-based fields, while scalars route through dedicated pathways.

Location: [`weathernext/weathernext2/architecture_utils.py`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/weathernext2/architecture_utils.py) (lines 111-124)

```python
from weathernext.weathernext2 import architecture_utils as au

# Split conditioning variables from main inputs

norm_features = ("surface_pressure_norm", "solar_radiation_norm")
norm_data, main_data = au.split_norm_conditioning_features(inputs, norm_features)

```

### 2. Dense Encoding ([`architecture.py`](https://github.com/google-deepmind/weathernext/blob/main/architecture.py))

The model constructor receives `norm_conditioning_features` and instantiates a configurable **MLP encoder**. The encoded latent vector broadcasts to every spatial location, effectively tiling global context across the full grid.

Location: [`weathernext/weathernext2/architecture.py`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/weathernext2/architecture.py) (lines 64-70)

```python
from weathernext.weathernext2 import architecture

model = architecture.WeatherNext2(
    norm_conditioning_features=("surface_pressure_norm", "solar_radiation_norm"),
    norm_conditioning_latent_dense_kwargs=dict(
        hidden_dims=(64, 64),
        activation="relu"
    ),
)

```

### 3. Pipeline Injection ([`denoiser.py`](https://github.com/google-deepmind/weathernext/blob/main/denoiser.py))

In generative pipelines, conditioning features extract from input dictionaries, route through encoding, and concatenate back during forward computation. This preserves the conditioning signal through iterative denoising steps.

Location: [`weathernext/weathernext1_gen/denoiser.py`](https://github.com/google-deepmind/weathernext/blob/main/weathernext/weathernext1_gen/denoiser.py) (lines 171-177)

```python

# Inside generation pipeline

if self._norm_conditioning_features:
    norm_conditioning_inputs = inputs[list(self._norm_conditioning_features)]
    inputs = inputs.drop_vars(list(self._norm_conditioning_features))
    # Encoded vector re-injected in model forward pass

```

## Complete Working Example

The following demonstrates the full norm conditioning workflow as implemented in WeatherNext:

```python
import xarray as xr
from weathernext.weathernext2 import architecture_utils as au

# Load input dataset with mixed spatial and scalar variables

inputs: xr.Dataset = load_weather_data()  # Contains grids + norm scalars

# Define which scalars provide conditioning context

conditioning_vars = ("surface_pressure_norm", "solar_radiation_norm")

# Step 1: Split conditioning from spatial fields

norm_data, spatial_data = au.split_norm_conditioning_features(
    inputs, conditioning_vars
)

# Step 2: Encode with dense MLP

encoded_conditioning = au.encode_global_norm_conditioning_data(
    global_data_norm_conditioning=norm_data,
    dense_kwargs=dict(hidden_dims=(64, 64), activation="relu")
)

# Result: encoded_conditioning broadcasts to shape [batch, 64, height, width]

# and concatenates to spatial representation inside WeatherNext2

```

## Why This Approach Outperforms Alternatives

Norm conditioning improves upon implicit learning strategies in several ways:

- **Explicit vs. implicit context**: Rather than forcing convolutional or graph layers to implicitly aggregate global signals, conditioning provides direct access.
- **Decoupled normalization**: Pre-normalized features eliminate the need for adaptive normalization layers to discover stable global statistics during training.
- **Modular extensibility**: Adding new climate indices requires only configuration changes, not architecture modifications.

According to the WeatherNext source code, this design choice reflects operational requirements where forecast systems must incorporate known large-scale drivers (ENSO phase, seasonal solar forcing) without retraining entire spatial encoders.

## Summary

- Norm conditioning features are **globally-normalized scalars** that inject large-scale atmospheric context into WeatherNext's spatial processing pipeline
- The implementation spans three files: [`architecture_utils.py`](https://github.com/google-deepmind/weathernext/blob/main/architecture_utils.py) (splitting), [`architecture.py`](https://github.com/google-deepmind/weathernext/blob/main/architecture.py) (encoding), and [`denoiser.py`](https://github.com/google-deepmind/weathernext/blob/main/denoiser.py) (pipeline injection)
- Benefits include **improved regime adaptation**, **training stabilization**, **experimental flexibility**, and **parameter efficiency**
- Configuration via `norm_conditioning_features` and `norm_conditioning_latent_dense_kwargs` enables rapid experimentation with climate indices
- The dense encoder architecture (typically 2-layer MLP with 64-128 units) adds minimal compute overhead while delivering measurable forecast skill improvements

## Frequently Asked Questions

### What variables work best as norm conditioning features?

**Surface pressure norms and solar radiation indices are most commonly used**, as they capture dominant modes of atmospheric variability. The WeatherNext codebase demonstrates configuration through the `norm_conditioning_features` tuple, and researchers can experiment with additional climate indices (ENSO, MJO, QBO) by adding their normalized names to this list. Effectiveness varies by forecast target—precipitation forecasts may benefit more from moisture-related indices, while temperature forecasts respond strongly to large-scale circulation patterns.

### How much does norm conditioning improve forecast accuracy?

**The improvement is target-dependent but generally modest yet consistent**, with larger gains for variables strongly influenced by large-scale regimes. According to the WeatherNext implementation, the mechanism's primary value lies in **stabilizing training dynamics** and enabling deeper architectures rather than dramatic single-step accuracy jumps. The parameter-efficient design (small MLP vs. full spatial model) makes this a favorable trade-off for operational systems where reliability matters.

### Can I use norm conditioning with custom climate indices?

**Yes, through simple configuration changes**. Any scalar variable present in your input dataset can serve as a conditioning feature. Add its name to `norm_conditioning_features` and ensure it is pre-normalized (mean-zero, unit-variance). The `encode_global_norm_conditioning_data` function in [`architecture_utils.py`](https://github.com/google-deepmind/weathernext/blob/main/architecture_utils.py) handles arbitrary conditioning vectors without architecture modifications, supporting rapid experimentation with domain-specific indices.

### Why broadcast the encoded vector to every spatial location?

**Broadcasting ensures global context influences all local predictions equally**, preventing spatial fragmentation where distant grid points might interpret global state differently. In [`architecture.py`](https://github.com/google-deepmind/weathernext/blob/main/architecture.py), the encoded conditioning vector tiles across height and width dimensions before concatenation, maintaining translation-equivariant processing while injecting position-invariant global information. This design preserves the spatial model's inductive biases while enhancing representational capacity.