Simulation / Modeling / Design

Turn Your Latest Observations Into Timely Weather Decisions With NVIDIA Earth-2

Sep 21, 2026
By Alberto Carpentieri, Georg Ertl, Jussi Leinonen, Stefan Weissenberger, Niall Robinson and Farah Hariri
Discuss (0)

AI-Generated Summary
  • NVIDIA Earth-2 AI data assimilation tools process observations from proprietary or third-party sources to issue forecasts more frequently and align estimates with real-time conditions.
  • Score-Based Data Assimilation (SDA) constrains diffusion models such as StormCast and CorrDiff with point observations, reducing wind-speed RMSE by 54% in a CorrDiff-COSMO downscaling example and by an average of 7.2% across six StormCast-CONUS forecast steps.
  • HealDA estimates the global atmospheric state in seconds by mapping heterogeneous remote-sensing and in situ observations onto a 1° HEALPix grid using an observation encoder and vision transformer backbone.
  • Earth2Studio data sources provide unified access to gridded satellite and radar data, conventional observation archives, and operational observation streams for developing and validating weather models.

Next Steps

Powered by NVIDIA Nemotron. AI-generated content may summarize information incompletely. Verify important information. Learn more

Weather-sensitive industries increasingly have access to observations that offer an earlier, more local view of changing conditions. Energy companies collect measurements across wind and solar assets, emergency management teams rely on radar and local sensors, and satellite providers continuously observe the Earth. This data helps organizations understand and manage physical risk across sectors such as capital markets, insurance, agriculture, and logistics.

With the AI data assimilation tools in NVIDIA Earth-2, you can process these observations more efficiently. By incorporating proprietary or third-party data, you can use these tools to issue forecasts more frequently, keep estimates aligned with real-time conditions, and tailor your forecasting pipeline to specific regions and applications.

This tutorial covers two techniques:

  • Constraining diffusion models with point observations, typically used for regional models.
  • Assimilating disparate datasets into a consistent state, typically used for global models.

Prerequisites

For this tutorial, you will need:

  • A development environment with Earth2Studio installed
  • An NVIDIA RTX PRO or data center GPU
  • A basic knowledge of Python
  • Approximately 30 minutes

Improve regional forecasts with observations

You might run a regional weather forecasting pipeline for managing energy production and demand, drawing observations from wind and solar parks, transmission corridors, or densely populated areas. With AI data assimilation, you can use these observations to constrain your forecast where local accuracy matters most, helping you improve operational decisions. The same techniques can support other sectors using observations from production sites, event venues, logistics networks, or other assets where local conditions directly drive decisions.

You can use Score-Based Data Assimilation (SDA) to incorporate observations into diffusion-based AI downscaling and forecasting models such as CorrDiff and StormCast. SDA guides the model toward predictions that are consistent with your observations without requiring to retrain the model.

Figure 1, below, shows how the process works under the hood. Diffusion models generate high-resolution predictions through a sequence of denoising steps. At each step, SDA compares the intermediate prediction with your observations and nudges the model in the right direction. The output of SDA is probabilistic, with less uncertainty near observation locations and a wider spread further away, where predictions are increasingly governed by the other model inputs and the underlying AI simulations.

Diagram of the SDA process. Two inputs enter the model from the left: a stack of weather fields at the top and point observations represented by scattered colored dots at the bottom. The top row illustrates the diffusion process in six steps, progressing from noisy, static-like fields to a clear, high-resolution weather field. The bottom row shows the corresponding SDA steps as six bar charts with progressively decreasing bar heights, representing the diminishing difference between the point observations and the diffusion states. The process produces a stack of high-resolution weather fields, shown on the right.
Figure 1. SDA leverages the multi-step denoising process of diffusion models. At each step, the intermediate result is compared with observations to guide the next denoising step. The final output is an observation-informed, high-resolution weather prediction

To nudge the model, you define an observation operator, which maps the model output to the quantity you would expect to observe at each measurement location. This is particularly straightforward for in situ measurements of physical quantities such as temperature or wind speed. In this case, the simplest form of an operator interpolates nearby grid values to each observation location. It is also possible to create operators for proxy measurements or observed impacts. For example, the power output of a wind turbine can act as a proxy measurement of wind speed.

SDA unlocks two major capabilities:

  • Update forecasts more rapidly. Numerical analyses require substantial processing time and are released on fixed schedules. SDA enables you to incorporate observations continuously. Figure 2, below, shows a concrete example of a pipeline forecasting at one-hour intervals and depending on a global analysis with a six-hour dissemination schedule.
  • Incorporate proprietary, regional or domain-specific observations. Numerical analyses draw on a broad range of observations. SDA lets you incorporate data from your own sources to focus your forecast on specific asset locations or downstream applications.

The effectiveness of SDA depends on several factors: the number, spatial distribution, and accuracy of your observations; the characteristic length scales of the field you are predicting; and the quality and well-posedness of the observation operator.

Flowchart of an example SDA pipeline across five hourly time steps, from the time of the latest analysis to one step beyond the current time. The top row shows the low-resolution global forecast (FCN3 + interpolation), which conditions the high-resolution forecast in the middle row. The bottom row shows observations, which are available for the first four time steps in the past but not for the final time step in the future. SDA is applied in two parts of the pipeline: to downscale the analysis at the first time step (CorrDiff + SDA) and to inform the high-resolution forecast at time steps two through four (StormCast + SDA). At the final, future time step and beyond, the high-resolution forecast proceeds without observations (StormCast).
Figure 2. Example pipeline using SDA for downscaling (CorrDiff + SDA) and high-resolution forecasting (StormCast + SDA). CorrDiff creates the high-resolution initial conditions for StormCast. SDA bridges the gap between the analysis reference time and current time by incorporating observations into downscaling and forecast steps that lie in the past

How to run CorrDiff-SDA in Earth2Studio

CorrDiff is a technique for AI-based downscaling. Earth2Studio provides a CorrDiff model pretrained over Europe that turns 0.25° weather fields into 2.2-km predictions. Using AI data assimilation, you can improve these predictions with observations where local accuracy matters. With the refined outputs, you can then initialize a regional forecast or create a reanalysis dataset for calibrating downstream models.

Start by loading the pretrained model. We limit the domain to a part of the Netherlands and northwestern Germany and choose to assimilate 10-meter wind speeds.

from datetime import datetime
from earth2studio.data import GHCNHourly
from earth2studio.models.da import CorrDiffCosmoEra5SDA

domain = dict(lat_min=50.2, lat_max=53.8, lon_min=4.6, lon_max=10.4)
sda = CorrDiffCosmoEra5SDA.load_model(
    CorrDiffCosmoEra5SDA.load_default_package(),
    assimilate_variables=("u10m", "v10m"),
    resolution="rea2",
    domain=domain,
    number_of_samples=1,
    sampler_steps=12,
    amp=True,          
).to("cuda")

Fetch the ERA5 data for low-resolution conditioning and GHCN wind observations over the domain.

# Fetch and regrid ERA5 inputs onto the high resolution regional grid
# Follow the link to the example below for the full implementation
init_time = datetime(2024, 1, 26)
x = fetch_and_regrid_era5(init_time, domain)

# Fetch GHCN hourly 10-m wind observations over the model domain
lat, lon = sda.model.lat_output_numpy, sda.model.lon_output_numpy
bbox = lat.min(), lon.min(), lat.max(), lon.max()
ghcn = GHCNHourly(stations=GHCNHourly.get_stations_bbox(bbox))
obs = ghcn(init_time, ["u10m", "v10m"]).dropna(subset=["observation"])

Lastly, run the model with the input data. We perform two runs to measure how the additional observations affect the results.

prior = sda(x)  # free downscaling, no observations
analysis = sda(x, obs)  # guide the diffusion toward the observations

For a complete implementation, see the example in Earth2Studio, from which the code above was adapted.

Three side-by-side maps of the Netherlands and northwestern Germany showing an example of wind-speed downscaling with and without SDA. The left panel shows the prior, obtained by downscaling ERA5 with CorrDiff-COSMO without additional observations. The middle panel shows the observation-guided analysis produced with SDA using observations from GHCN-Hourly stations. Wind speed in the left and middle panels is shown on a blue-to-yellow color scale ranging from 0 to approximately 10 meters per second. In the middle panel, 57 assimilated stations are marked by black dots and 24 held-out stations by white dots. The effect of SDA is most apparent in the northwest, over the North Sea, where SDA predicts higher wind speeds. The right panel shows the difference between the SDA and no-SDA experiments on a blue-to-red color scale, with red areas in the northwest indicating higher wind speeds with SDA. At held-out station locations, green upward triangles indicate reduced error and orange downward triangles indicate increased error. Triangle size is proportional to the magnitude of the change in error.
Figure 3. CorrDiff-COSMO downscaling with and without SDA. In this example, SDA reduces the wind-speed RMSE at held-out stations by 54%. Left: wind speed downscaled without SDA. Middle: wind speed downscaled with SDA using GHCN-Hourly station observations. Right: difference in wind speed between the SDA and no-SDA experiments

How to run StormCast-SDA in Earth2Studio

StormCast is a technique similar to CorrDiff but designed for high-resolution, regional forecasting. Earth2Studio includes a StormCast model pretrained over the contiguous U.S. (CONUS) that is initialized with HRRR and makes predictions at a 3-km resolution. The computation and dissemination of a new HRRR analysis takes some time, but you can use SDA to combine the currently available analysis with the latest observations to update your forecast.

Start by loading the pretrained model. We limit the domain to the central U.S.

import numpy as np
from earth2studio.data import GHCNHourly
from earth2studio.models.px import StormCastCONUS

# Limit the domain to the central U.S.
hrrr_lat_lim, hrrr_lon_lim  = (305, 785), (595, 1203)
model = StormCastCONUS.load_model(
    StormCastCONUS.load_default_package(),
    hrrr_lat_lim=hrrr_lat_lim,  # comment out for full CONUS domain
    hrrr_lon_lim=hrrr_lon_lim,  # comment out for full CONUS domain
    num_diffusion_steps=18,
    num_sda_diffusion_steps=96,  # more steps for SDA for better stability
    sda_std_obs=0.15,
    sda_gamma=1e-3,
).to("cuda")

Next, fetch the HRRR analysis for model initialization and define the observation data source over the model domain.

# Fetch HRRR initial conditions
# Follow the link to the example below for the full implementation
init_time = datetime(2026, 4, 17, 18)
x, coords = fetch_hrrr(init_time)

# Define GHCN hourly data source for the model domain
lat, lon = model.lat, model.lon
bbox = lat.min(), lon.min(), lat.max(), lon.max()
ghcn = GHCNHourly(
    stations=GHCNHourly.get_stations_bbox(bbox),
    time_tolerance=timedelta(minutes=15),
)

We can now run the model using observations during the initial rollout steps before transitioning to forecasting without additional observations. Similar to the illustration in Figure 2, above, this approach uses observations to bridge the gap between the latest analysis and current conditions, after which the forecast proceeds independently.

For a pipeline initialized with HRRR, only one SDA-informed step is typically relevant before a new analysis arrives. When using a global analysis for initialization, multiple rollout steps can benefit from SDA.

# Initialize generator and get the first output (analysis passthrough)
gen = model.create_generator(x.clone(), coords.copy())
x, coords = next(gen)

# Run the first part of the rollout with SDA
for step in range(nsteps_sda):
    valid_time = np.array(
        [coords["time"][0] + coords["lead_time"][0] + np.timedelta64(1, "h")]
    )
    obs = ghcn(valid_time, ["u10m", "v10m", "t2m"])
    x, coords = gen.send(obs)  # advance one step with observations

# Run the remaining rollout without SDA
for step in range(nsteps_non_sda):
    x, coords = next(gen)  # advance one step without observations

You can find a full implementation of the example in the Earth2Studio example library.

Six maps arranged in two rows and three columns over the central U.S., showing an example of wind-speed forecasting with and without SDA. The top and bottom rows show the 3-hour and 6-hour forecast steps, respectively. The left column shows the prior, obtained by running StormCast-CONUS without additional observations. The middle column shows the observation-guided output produced with SDA using observations from GHCN-Hourly station observations. Wind speed in the left and middle columns is shown on a blue-to-yellow color scale ranging from 0 to approximately 12 meters per second. In the middle column, 70% of the stations are assimilated and marked by black dots, while the remaining 30% are held out and marked by white dots. The right column shows the difference between the SDA and no-SDA experiments on a blue-to-red color scale. The largest differences occur along the Central Lowlands across Oklahoma, Kansas, and Missouri. At held-out station locations, green upward triangles indicate reduced error and orange downward triangles indicate increased error. Triangle size is proportional to the magnitude of the change in error.
Figure 4. StormCast-CONUS forecasts with and without SDA. In this example, SDA reduces the wind-speed RMSE at held-out stations by an average of 7.2% across six time steps. The top and bottom rows show the 3- and 6-hour forecasts, respectively. Left: wind-speed prediction without SDA. Middle: wind-speed prediction with SDA using GHCN-Hourly station observations. Right: difference in wind speed between the SDA and no-SDA predictions

How to use SDA with your own model

You can assimilate observations with a custom model by extending its Earth2Studio model wrapper. To do this, use the diffusion utilities in PhysicsNeMo. We start with x0_predictor, a pre-trained denoising diffusion model that takes a noisy sample and its noise level as inputs and predicts a noise-free sample. Without SDA, the diffusion sampling for the model would be implemented like this:

from physicsnemo.diffusion.noise_schedulers import EDMNoiseScheduler
from physicsnemo.diffusion.samplers import sample

# Construct diffusion scheduler
sigma_min, sigma_max = 0.01, 100
scheduler = EDMNoiseScheduler(sigma_min=sigma_min, sigma_max=sigma_max)

# Get denoiser from scheduler
denoiser = scheduler.get_denoiser(x0_predictor=x0_predictor)

# Generate sample
latents = sigma_max * torch.randn(shape)
sample(denoiser, latents, noise_scheduler=scheduler, num_steps=num_steps)

To use SDA, we transform the x0_predictor into a score-predicting model with SDA guidance. We use DataConsistencyDPSGuidance, which associates each masked pixel with a corresponding observed value. You can use it to assimilate observations from weather stations, proprietary sensors, or similar point-based sources.

from physicsnemo.diffusion.guidance import (
    DataConsistencyDPSGuidance,
    DPSScorePredictor,
)

# Setup SDA guidance
guidance = DataConsistencyDPSGuidance(
    mask=mask,  # binary mask that identifies pixels with observations
    y=y_obs,  # gridded observations
    std_y=sda_std_obs,  # the remaining parameters are SDA settings
    norm=sda_dps_norm,
    gamma=sda_gamma,
    sigma_fn=scheduler.sigma,
    alpha_fn=scheduler.alpha,
)

# Convert x0_predictor to score predictor
score_predictor = DPSScorePredictor( 
    x0_predictor=x0_predictor,
    x0_to_score_fn=scheduler.x0_to_score,
    guidances=guidance,
)
denoiser = scheduler.get_denoiser(score_predictor=score_predictor)

# Generate sample (identical to non-SDA example)
latents = sigma_max * torch.randn(shape)
sample(denoiser, latents, noise_scheduler=scheduler, num_steps=num_steps)

For more advanced SDA pipelines, use ModelConsistencyDPSGuidance to derive simulated observations from multiple grid points. This approach requires you to provide a PyTorch model that maps each sample to the corresponding simulated observations. With a custom PyTorch model, you can also assimilate observed impacts. For example, you can use a wind power model to assimilate turbine output measurements. 

For a complete implementation, have a look at the StormCast CONUS wrapper in Earth2Studio, on which the example above is based. 

Compute the global weather from observations

Most global weather forecasting pipelines are initialized with an estimate of the current weather derived through numerical data assimilation. Numerical data assimilation is computationally demanding, which reduces the timeliness and refresh rate of forecasts and makes it harder to integrate custom observations.

With an AI-based technique called HealDA, you can estimate the state of the global atmosphere in a matter of seconds. This allows you to issue forecasts closer to current conditions or compute a custom reanalysis.

HealDA maps remote-sensing and in situ observations within a time window to a global gridded atmospheric state. It consists of two main components: an observation encoder and a vision transformer (ViT) backbone. The encoder ingests heterogeneous observations as point clouds, embedding each scalar value into a token together with metadata such as geolocation and time. These tokens are then aggregated onto the target grid and processed by the ViT backbone.

Diagram of HealDA. Input observations are shown on the left as a stack of globes containing satellite swaths and point observations. The observations are passed to the observation encoder, which consists of separate sensor embedders followed by a sensor-fusion step. The resulting representation is passed to a ViT backbone. The final analysis output is shown on the right as a stack of globes containing dense weather fields.
Figure 5. HealDA combines in situ and remote-sensing observations from different platforms to provide a consistent estimate of the global weather. The observation encoder treats each data stream as a point cloud in space and time and transforms the measurements into tokens, which are processed by a ViT backbone

You can use a pretrained global data assimilation model as a starting point. If you have custom conventional observations, you can typically incorporate them without modifying the model.

For proprietary satellite data, you can adapt the encoder to support your data sources. This flexibility lets you tailor the data assimilation system to your region or application. You can use the same technique to train a regional instead of a global system. To get started, see the HealDA training pipeline in the open-source Python library PhysicsNeMo.

How to run HealDA in Earth2Studio

Earth2Studio provides a pretrained global data assimilation model for research purposes. It integrates data from microwave sounders, radio occultation, surface stations, aircraft, buoys, and other sources onto a 1° HEALPix grid (HPX64).

First, load the model.

from datetime import timedelta

import numpy as np
from earth2studio.data import UFSObsConv, UFSObsSat, fetch_dataframe
from earth2studio.models.da import HealDA

model = HealDA.load_model(
    HealDA.load_default_package(),
    lat_lon=True,  # regrid from HEALPix to regular lat/lon
).to("cuda")

Next, fetch the input observations from the NOAA UFS replay repository. We use conventional and satellite observations.

# HealDA was trained on the UFS replay window: 21h before to 3h after analysis time
time_tolerance = (timedelta(hours=-21), timedelta(hours=3))
analysis_time = np.array([np.datetime64("2024-01-01T00:00")])

# input_coords() returns the schemas the two observation DataFrames must satisfy
conv_schema, sat_schema = model.input_coords()

# fetch_dataframe attaches the request_time metadata the model needs
conv_df = fetch_dataframe(
    UFSObsConv(time_tolerance=time_tolerance),
    time=analysis_time,
    variable=np.array(conv_schema["variable"]),
    fields=np.array(list(conv_schema.keys())),
)
sat_df = fetch_dataframe(
    UFSObsSat(time_tolerance=time_tolerance),
    time=analysis_time,
    variable=np.array(sat_schema["variable"]),
    fields=np.array(list(sat_schema.keys())),
)

Then call the model with the observation data frames.

# stateless model - call it directly for a one-shot analysis, or use
# create_generator for cycled assimilation
analysis = model(conv_obs=conv_df, sat_obs=sat_df)

You can find an extended example for running HealDA in the Earth2Studio example library.

Access observational data with Earth2Studio

Earth2Studio gives you access to a broad range of data sources for developing, initializing, and validating weather models, including observations from different platforms and sensor types.

Among these are gridded data from geostationary satellites (GOES, Himawari, Meteosat) and radar networks (MRMS, OPERA), which you can use directly to train and rapidly update regional, high-resolution forecasting models such as StormScope. These sources are especially useful when you want to forecast quantities that depend on insolation or precipitation, like solar power production, cooling processes, and reservoir inflows.

For developing and benchmarking a data assimilation system, Earth2Studio also lets you access archives of conventional observations like GHCN/ISD, NNJA, and UFS, as well as operational observations from GDAS and ASOS. These sources provide variables such as temperature and wind speed as data frames. Observations from polar-orbiting satellite systems, including MetOp and JPSS, are also available.

Earth2Studio provides a unified interface across all data sources. You instantiate a data source object and call it with a list of timesteps and variable names. Forecast data sources also accept a list of lead times. This consistent interface makes it easy to combine multiple data sources within the same workflow or connect your own observations to a pipeline.

era5 = NCAR_ERA5()
da_era5 = era5(datetime(2025, 7, 15), ["t2m", "z500"])
print(da_era5.shape)  # (1, 2, 721, 1440)

ifs = IFS_FX()
da_ifs = ifs(datetime(2026, 7, 15), timedelta(hours=48), ["t2m"])
print(da_ifs.shape)  # (1, 1, 1, 721, 1440)

goes = GOES(satellite="goes19", scan_mode="C")
da_goes = goes(datetime(2026, 7, 15), ["abi01c", "abi02c", "abi03c"])
print(da_goes.shape)  # (1, 3, 1500, 2500)

ghcn = GHCNHourly(stations=["USW00013301"])
df_ghcn = ghcn(datetime(2026, 6, 15), ["t2m", "ws10m"])
print(df_ghcn.shape)  # (10, 7)

For the full list of supported data sources, see the API reference in the user guide.

Get started with Earth2Studio

Explore end-to-end AI data assimilation examples in the Earth2Studio example library. To connect your own observations to a pipeline, follow the custom data source example.

AI data assimilation lets you issue more accurate, timely forecasts by incorporating the observations that matter to your region or organization.

Visit the Earth2Studio user guide to get started with AI data assimilation and explore the broader capabilities of AI weather models.

Discuss (0)

Tags

Data Science | Developer Tools & Techniques | Simulation / Modeling / Design | Energy | PhysicsNeMo | Intermediate Technical | Tutorial | Climate / Weather / Ocean Modeling | Earth-2

About the Authors

Avatar photo
About Alberto Carpentieri
Alberto Carpentieri holds a PhD from ETH Zurich in AI applied to atmospheric science, with a background in applied mathematics through his degree in Data Science from the University of Padova. His doctoral research advanced short-term high resolution forecasting, with applications to accelerating photovoltaic energy adoption and supporting climate resilience. He has developed expertise in applying modern neural network methods to atmospheric science problems. He joined NVIDIA in May 2025 as a solutions architect, where he contributes to customer applications within the Earth-2 project, bridging machine learning and weather forecasting.
Avatar photo
About Georg Ertl
Georg Ertl is a solution architect for NVIDIA Earth-2, where he designs AI-driven weather solutions for business challenges across industries such as energy and risk management. With a dual background in meteorology (University of Hamburg) and industrial engineering (Karlsruhe Institute of Technology), he connects atmospheric science with business challenges, converting weather data into practical solutions for enhanced operational resilience and competitive advantage.
Avatar photo
About Jussi Leinonen
Jussi Leinonen has a background in atmospheric physics and data science. He has a doctorate in physics from Aalto University and worked at NASA Jet Propulsion Laboratory and MeteoSwiss before joining NVIDIA. For the last several years, he has been working to apply modern neural network methods to weather and climate problems. He developed some of the first generative AI models for atmospheric science problems, including a generative downscaling model in 2020. He joined NVIDIA in October 2023 to work as a senior solutions architect on customer applications of the Earth-2 project.
Avatar photo
About Stefan Weissenberger
Stefan Weissenberger is a senior solutions architect working with users of NVIDIA Earth-2. He helps developers build scalable AI systems for weather and climate applications, from model development to production deployment. He has a background in computer science and several years of experience applying AI to real-world challenges across the public and private sectors. He is particularly interested in turning advances in geospatial AI into practical tools for scientific and operational decision-making.
Avatar photo
About Niall Robinson
Niall Robinson is the developer relationship manager for Earth-2, NVIDIA’s platform for weather and climate. He collaborates with partners to develop innovative new solutions using Earth-2. Before NVIDIA, Niall worked at the U.K. Met Office, applying emerging technologies to solve problems. He started his career as a climate scientist working in decadal forecasting and air-quality science. He has a Ph.D. in atmospheric science from Manchester University.
Avatar photo
About Farah Hariri
Dr. Farah Hariri leads the solutions architects team for NVIDIA AI Physics technologies, including the Earth-2 platform, as well as industry-focused solution architect teams for energy and financial services. Farah brings a broad technical background spanning theoretical and nuclear physics, climate and energy transition technologies, numerical modeling, and artificial intelligence. Prior to joining NVIDIA, she worked on climate and energy policy frameworks and led multiple projects at the European Organization for Nuclear Research (CERN), the Swiss Federal Institute of Technology (EPFL), and the French Alternative Energies and Atomic Energy Commission (CEA).

Comments