QWE AI Academy You’ll deploy a production-grade AI weather forecasting system using Google’s GraphCast. Not a toy notebook – an actual model that pulls live atmospheric data, generates 10-day global forecasts at 0.25° resolution, and runs locally on hardware you can access today. Then we’ll walk backward through why each piece works the way it does.
Why start here? Because understanding what breaks in deployment teaches you more than theory ever will.
What You’re Actually Building
By the end, you’ll have a working pipeline: fetch initialization data from ECMWF’s Copernicus Climate Data Store, feed it to a pre-trained GraphCast model, generate a 10-day forecast in under 2 minutes (on GPU), and output standard GRIB files that any meteorological tool can read.
The output matches what ECMWF runs operationally alongside its traditional HRES model. You’re not simulating this – you’re running the same architecture that Google DeepMind’s GraphCast beat ECMWF’s flagship model on 90% of verification targets in their December 2023 Science paper.
Install the ECMWF AI-Models Framework
Skip the from-scratch implementations. ECMWF developed a standardized interface that lets you run GraphCast, Pangu-Weather, or FourCastNet with the same commands.
pip install ai-models-graphcast
pip install ai-models # Core framework
This framework handles model weight downloads, input preprocessing, and output formatting. The alternative – manually wrangling ONNX runtimes, NetCDF conversions, and grid projections – will cost you days.
Check your GPU setup now. Run nvidia-smi. If you see your GPU listed, you’re good. If not, you’ll hit the first gotcha later.
Fetch Initialization Data (The Hard Part)
AI weather models need current atmospheric state to predict forward. You have two options: ECMWF’s MARS archive or the Copernicus Climate Data Store (CDS). MARS requires ECMWF member state credentials; CDS is free but slower.
For CDS access: create an account at cds.climate.copernicus.eu, grab your API key from your profile, and drop it in ~/.cdsapirc:
url: https://cds.climate.copernicus.eu/api/v2
key: YOUR_UID:YOUR_API_KEY
Now run your first forecast:
ai-models --download-assets --input cds --date 20260410 --time 0000 graphcast
This downloads GraphCast’s trained weights (happens once, cached locally), fetches initialization data for April 10, 2026 at 00:00 UTC, and generates a 10-day forecast.
Watch the logs. On GPU, FourCastNet completes a 10-day forecast in 2 minutes. GraphCast is similar. On CPU? About 3:15 minutes per 6-hour step – multiply that by 40 steps for 10 days and you’re waiting over 2 hours.
The GPU Detection Trap Nobody Warns You About
Here’s the edge case that killed my first three attempts: ONNX runtime may fail to detect your GPU even when nvidia-smi shows it’s there. The ai-models framework doesn’t expose a diagnostic for this.
Symptom: Your forecast starts, logs say “Using device ‘CPU'”, and you’re stuck in slow-motion inference. The fix depends on your CUDA version and onnxruntime-gpu package alignment. Run:
python -c "import onnxruntime as ort; print(ort.get_available_providers())"
If CUDAExecutionProvider isn’t listed, reinstall onnxruntime-gpu matching your CUDA version. The ai-models package doesn’t pin this dependency tightly enough.
Pro tip: Before debugging ONNX, verify your model choice. FourCastNet v2 has better GPU detection in my tests than the original. GraphCast is rock-solid. Pangu-Weather is the pickiest.
What the Model Actually Predicts (And What It Doesn’t)
GraphCast outputs temperature, wind (u/v components), geopotential height, specific humidity, and mean sea-level pressure at multiple atmospheric levels. Standard meteorological variables. All the same outputs as traditional NWP: 6-hour intervals out to 10 days.
But here’s what the documentation buries: GraphCast deliberately excludes precipitation from its evaluation scope because ERA5 precipitation has known biases. The model still outputs precipitation, but the developers themselves say don’t trust it for validation.
Most tutorials skip this. They’ll show you gorgeous precipitation maps from GraphCast without mentioning the model wasn’t optimized for that variable. If you need rainfall forecasts, use Google’s MetNet-3 (regional, 24-hour) or stick with traditional NWP for now.
Read the Output Files
The forecast lands in GRIB format (meteorology’s standard). Open it with xarray:
import xarray as xr
import cfgrib
ds = xr.open_dataset('graphcast_output.grib', engine='cfgrib')
print(ds)
You’ll see variables like t2m (2-meter temperature), u10 / v10 (10-meter wind), msl (mean sea-level pressure). Each has lat/lon coordinates and time steps.
Plot a single timestep:
import matplotlib.pyplot as plt
import cartopy.crs as ccrs
fig = plt.figure(figsize=(12, 6))
ax = plt.axes(projection=ccrs.PlateCarree())
ds['t2m'].isel(time=0).plot(ax=ax, transform=ccrs.PlateCarree())
ax.coastlines()
plt.show()
This is surface temperature for the first forecast step. Increase time index to see later predictions.
The Extreme Event Problem (Why This Isn’t Production-Ready Yet)
AI weather models have a fatal flaw that affects operational use: they can’t extrapolate beyond their training distribution. A University of Chicago study published in PNAS (May 2025) found that neural networks trained without Category 3-5 hurricanes always underestimated Category 5 storms – predicting them as Category 2.
This isn’t a tuning problem. It’s architectural. Neural networks trained on historical data learn patterns, not physics. When the atmosphere does something unprecedented, the model defaults to the strongest analog it’s seen before.
The February 2026 blizzard that hit New York – 20 inches in Central Park, ninth-biggest storm on record – was predicted days in advance by traditional GFS but AI models were less certain. That’s a gray swan event: rare enough to be underrepresented in training data.
Does this mean AI models are useless? No. But it means you can’t deploy them alone. Which brings us to the approach nobody tutorials cover.
Build a Hybrid Ensemble (The Real Production Strategy)
Here’s what NOAA actually runs operationally: HGEFS, a 62-member hybrid ensemble that combines 31 AI forecasts (AIGEFS) with 31 traditional physics forecasts (GEFS) – and it consistently outperforms both pure AI and pure physics systems.
You can replicate this locally on a smaller scale. Run GraphCast, run a traditional model (ECMWF HRES if you have access, or NOAA GFS via Open-Meteo), and compare outputs.
Open-Meteo is the easiest free source for traditional NWP forecasts. No API key required, combines multiple global models (NOAA GFS, ECMWF IFS, DWD ICON).
import requests
url = "https://api.open-meteo.com/v1/forecast"
params = {
"latitude": 40.7128,
"longitude": -74.0060,
"hourly": "temperature_2m,wind_speed_10m",
"forecast_days": 10
}
response = requests.get(url, params=params)
data = response.json()
print(data['hourly'])
Now you have two forecasts for the same location: one from GraphCast (pure AI, trained on 40 years of ERA5 reanalysis), one from Open-Meteo (ensemble of traditional NWP models). When they diverge, that’s your uncertainty signal.
Model disagreement itself is information – it flags forecast uncertainty and prompts closer analysis. If GraphCast says 15°C and GFS says 8°C for the same day, something interesting is happening in the atmospheric setup.
Automate Forecast Comparisons
Extract matching grid points from both sources and compute divergence:
import numpy as np
# GraphCast extracted for specific lat/lon
graphcast_temps = ds['t2m'].sel(latitude=40.7, longitude=-74.0, method='nearest').values
# Open-Meteo temps (already fetched above)
open_meteo_temps = np.array(data['hourly']['temperature_2m'])
# Compare
diff = np.abs(graphcast_temps - open_meteo_temps)
print(f"Max divergence: {diff.max():.2f}K at hour {diff.argmax()}")
Large divergence at short lead times (24-48 hours) is rare and worth investigating. Large divergence at long lead times (7-10 days) is normal – that’s chaos theory at work.
When NOT to Use AI Weather Models
Three scenarios where traditional NWP still wins:
- Sub-kilometer resolution: AI models operate at 0.25° (~25km). If you need street-level forecasts, you’re stuck with regional NWP downscaling or nowcasting (MetNet, not GraphCast).
- Precipitation intensity: As noted earlier, GraphCast’s precip is undertrained. AI models underperform in extreme rainfall events specifically.
- Real-time data assimilation: Traditional models continuously ingest live observations (weather balloons, satellites, radar). Current AI models still depend on NWP for initialization data – they’re not end-to-end replacements yet.
The first fully data-driven model (raw observations → forecast, no NWP initialization) is in research. Aardvark, mentioned in a 2025 ScienceDirect survey, aims to replace the entire pipeline. It’s not operational.
Track Model Improvements in Real Time
The field moves fast. ECMWF runs the AI Weather Quest competition with 42 teams submitting forecasts since September 2025. New models drop every few months.
Where to monitor:
- CIRA’s real-time AI weather model visualization – see live GraphCast, Pangu-Weather, FourCastNet outputs
- Awesome-LWMs GitHub repo – curated list of Large Weather Models with paper links
- ECMWF Science Blog – operational deployment announcements
The next breakthrough won’t be a single model. Canada’s launching a hybrid AI model in spring 2026 that makes 6-day forecasts as accurate as current 5-day physics forecasts – that’s the equivalent of gaining an extra day of warning for severe weather.
Your move: deploy the baseline (GraphCast via ai-models), run it for a month, log where it diverges from traditional forecasts, and document the failure modes for your region. That dataset is worth more than any tutorial.
Frequently Asked Questions
Do I need a supercomputer to run GraphCast locally?
No. A single consumer GPU (RTX 3080 or better) generates a 10-day global forecast in under 2 minutes. GraphCast runs in under 1 minute on a single TPU, but Google Cloud TPU access costs money. Stick with local GPU for learning. CPU-only works but takes 2+ hours.
Can AI models predict hurricanes better than NOAA’s official forecasts?
For track (path), sometimes yes – GraphCast accurately predicted Hurricane Lee’s Nova Scotia landfall 9 days in advance. For intensity (wind speed), no – NOAA’s AIGFS v1.0 shows degraded tropical cyclone intensity forecasts, which future versions will address. Operational forecasters use AI for track guidance but still rely on traditional models for intensity. The University of Chicago study found AI models systematically underestimate extreme hurricane intensity if the training data lacks similar events.
Which AI weather model should I start with in 2026?
GraphCast if you want stability and the most extensive validation (published in Science, operationally tested by ECMWF). Pangu-Weather if you need the absolute fastest inference (runs 10,000x faster than ensemble NWP in benchmarks). NVIDIA Earth-2 (launched January 26, 2026) if you want the first fully open software stack with pretrained weights, customization recipes, and inference libraries all in one package. For pure experimentation, Earth-2 gives you the most flexibility. For replicating published research, GraphCast. For production speed, Pangu-Weather – but be aware it ranks lower than FengWu and FuXi in recent Eastern Asia evaluations.