Generated banner for Earth2studio Deterministic Forecast
Generated logo for Earth2studio Deterministic Forecast

Earth2studio Deterministic Forecast

NVIDIAOfficialCreated by NVIDIA Earth-2 Team

  • Skill
  • Tool integration
  • Science and research
  • Apache-2.0
  • Medium risk
  • Has scripts

From the author

Build deterministic forecast scripts with Earth2Studio (model, data source, IO, inference). Do NOT use for ensemble, diagnostics, data-only fetch, or install.
— the description by NVIDIA Earth-2 Team

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured approach to creating single-member deterministic weather forecast scripts using Earth2Studio. It guides users through the selection of prognostic models, compatible data sources, and appropriate IO backends, while ensuring correct calculation of forecast steps and output configuration. The skill focuses exclusively on inference workflows, ensuring users follow best practices for model loading and data handling within the Earth2Studio ecosystem.

What it does

  • Selects appropriate prognostic models based on time horizon and region.
  • Verifies compatibility between model input requirements and data source lexicons.
  • Calculates the required number of inference steps based on forecast duration and model resolution.
  • Configures IO backends for saving forecast results.
  • Generates Python scripts utilizing the earth2studio.run.deterministic interface.
  • Provides a manual loop implementation path for custom inference requirements.

When to use it

  • When you need to run a single-member deterministic weather forecast.
  • When integrating specific prognostic models with Earth2Studio data sources.
  • When you need to automate the generation of inference scripts for weather modeling.
  • When you need to select the correct IO backend for your forecast output storage.

Advantages

  • Ensures compatibility between models and data sources through lexicon verification.
  • Standardizes the script generation process for deterministic inference.
  • Provides clear guidance on IO backend selection for different storage needs.
  • Reduces errors in step calculation and coordinate filtering.

Usage examples

“Create a 3-day deterministic forecast script using the Pangu model and GFS data.”
The agent will generate a Python script using earth2studio.run.deterministic, selecting the Pangu model class, GFS data source, and configuring the nsteps for a 72-hour forecast.
“How do I save only temperature and wind data from my forecast?”
The agent will provide the code to configure the output_coords parameter in the deterministic run function to filter for specific variables, reducing output file size.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/nvidia/earth2studio-deterministic-forecast/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip earth2studio-deterministic-forecast.zip -d .agents/skills

Documentation by NVIDIA Earth-2 Team

Earth2Studio Deterministic Forecast Skill

Guide users through building deterministic (single-member) weather forecast inference scripts using earth2studio.run.deterministic.

Prerequisites

  • Earth2Studio installed with CUDA-capable GPU

  • Python 3.10+, network access for model weights and data

Live Doc References

Fetch relevant docs to verify current APIs before recommending components:

Workflow

1. Gather Requirements (skip what's already provided)
  • Time horizon (hours/days/weeks)

  • Variables of interest (t2m, wind, geopotential, etc.)

  • Region (global or specific like CONUS)

  • GPU/VRAM available

2. Select Model

Fetch prognostic models page. Filter by time horizon, region, VRAM. Note model's:

  • Input variables (input_coords["variable"])

  • Time step size (output_coords["lead_time"])

3. Select Data Source

Data source must provide all model input variables. Verify via lexicon at earth2studio/lexicon/<source>.py. Common pairings: Global models → GFS/ARCO/IFS; Regional → HRRR.

4. Select IO Backend

Default: ZarrBackend. Use NetCDF4Backend for legacy tools, XarrayBackend for in-memory/small runs.

5. Calculate nsteps

nsteps = forecast_hours / model_step_hours

Example: 5-day forecast with 6h step → nsteps = 120 / 6 = 20

6. Decide: output_coords Filtering
  • Filter variables (output_coords) when user requests specific variables (e.g., "t2m and wind") - reduces output size

  • Save all variables (omit output_coords) when user says "all variables" or doesn't specify - preserves full model output

7. Generate Script
from collections import OrderedDict
import numpy as np
import torch
from earth2studio.models.px import <ModelClass>
from earth2studio.data import <DataSourceClass>
from earth2studio.io import <IOBackendClass>
from earth2studio.run import deterministic

model = <ModelClass>.load_model(<ModelClass>.load_default_package())
data = <DataSourceClass>()
io = <IOBackendClass>("<output_path>")

# Include output_coords ONLY if user requested specific variables
output_coords = OrderedDict({"variable": np.array(["t2m", "u10m"])})

io = deterministic(
    time=["YYYY-MM-DDTHH:MM:SS"],
    nsteps=<N>,
    prognostic=model,
    data=data,
    io=io,
    output_coords=output_coords,  # omit if saving all variables
    device=torch.device("cuda"),
)
8. Manual Loop Alternative

When user explicitly requests manual implementation (NOT using earth2studio.run.deterministic), follow this checklist in order:

  1. fetch_data - Get initial conditions: x, coords = fetch_data(data, time, model.input_coords, device)

  2. Setup total_coords - Build coordinate arrays for time and lead_time dimensions

  3. io.add_array - Initialize IO backend with total_coords before loop

  4. create_iterator - Create prognostic iterator: model_iter = model.create_iterator(x, coords)

  5. Loop through nsteps - for step, (x, coords) in enumerate(model_iter): if step >= nsteps: break

  6. map_coords - Filter output variables if needed: x_out, coords_out = map_coords(x, coords, output_coords)

  7. split_coords - Prepare for IO write: x_out, coords_out = split_coords(x_out, coords_out)

  8. io.write - Write each step to backend

9. Explain Next Steps
  • How to change forecast time or run multiple initializations

  • How to read output (xr.open_zarr(...))

  • Point to diagnostic workflow for post-processing

Ownership

Owns: Model selection, data source compatibility, IO backend selection, nsteps calculation, generating earth2studio.run.deterministic scripts.

Does not own: Ensemble workflows, diagnostics, data-only fetch, installation, model training.

Troubleshooting

See references/troubleshooting.md for common errors and solutions.

Reminders

  • Always fetch live docs before recommending models or data sources - APIs change between releases

  • Verify lexicon compatibility - Model input variables must exist in data source's VOCAB

  • Use load_default_package() - This is the standard pattern for loading model weights

  • Time format is ISO 8601 - Use "YYYY-MM-DDTHH:MM:SS" format for the time argument

  • Wind speed needs both components - If user asks for "wind speed", include both u10m and v10m

  • nsteps is integer division - nsteps = total_hours // model_step_hours

  • ZarrBackend is the default - Only suggest alternatives if user has specific requirements

  • GPU is required - All prognostic models require CUDA; CPU inference is not supported

Files

evals/evals.json

[
  {
    "id": "deterministic-eval-001-3day-t2m-wind",
    "question": "I want to forecast 2m temperature and 10m wind speed 3 days ahead from 2024-01-15 00Z. I have an A100 80GB GPU. Write me the full inference script.",
    "expected_skill": "earth2studio-deterministic-forecast",
    "expected_script": "evals/targets/eval_1_target.py",
    "ground_truth": "Selects a suitable medium-range prognostic model (e.g., AIFS, Pangu, GraphCast), a compatible data source (e.g., GFS, IFS, ARCO), calculates nsteps=12 for 3 days at 6h step, and generates a complete deterministic inference script using earth2studio.run.deterministic with output_coords filtering to t2m, u10m, v10m.",
    "expected_behavior": [
      "Selects a medium-range prognostic model (AIFS, Pangu, GraphCast, etc.)",
      "Selects a compatible data source (GFS, IFS, ARCO, etc.)",
      "Calculates correct nsteps for 3-day forecast (e.g., 12 steps at 6h)",
      "Generates script using earth2studio.run.deterministic",
      "Filters output to requested variables (t2m and both wind components)",
      "Sets CUDA device for GPU execution"
    ]
  },
  {
    "id": "deterministic-eval-002-5day-aifs-gfs",
    "question": "Create a 5-day global forecast script using AIFS with GFS initial conditions. Start from 2024-06-15 12Z. I want to save geopotential at 500hPa (z500) and mean sea level pressure (msl) to a Zarr file.",
    "expected_skill": "earth2studio-deterministic-forecast",
    "expected_script": "evals/targets/eval_2_target.py",
    "ground_truth": "Generates a script using AIFS model, GFS data source, ZarrBackend, 5-day run with nsteps=20 (6h step). Includes output_coords filtering to z500 and msl.",
    "expected_behavior": [
      "Uses AIFS model class",
      "Uses GFS data source",
      "Uses ZarrBackend for output",
      "Calculates nsteps=20 for 5 days at 6h step",
      "Filters output to z500 and msl variables",
      "Sets initialization time to 2024-06-15T12:00:00"
    ]
  },
  {
    "id": "deterministic-eval-003-graphcast-arco-10day",
    "question": "Generate a deterministic forecast script using GraphCast with ARCO ERA5 data. Initialize from 2023-09-01 00Z and run for 10 days. Save all output variables to Zarr.",
    "expected_skill": "earth2studio-deterministic-forecast",
    "expected_script": "evals/targets/eval_3_target.py",
    "ground_truth": "Generates a script using GraphCastOperational model, ARCO data source, ZarrBackend, 10-day run with nsteps=40. Does not include output_coords (saves all model outputs).",
    "expected_behavior": [
      "Uses GraphCastOperational or GraphCast model class",
      "Uses ARCO data source for ERA5 reanalysis",
      "Uses ZarrBackend for output",
      "Calculates nsteps=40 for 10 days at 6h step",
      "Saves all variables (no output_coords filtering)",
      "Sets initialization time to 2023-09-01T00:00:00"
    ]
  },
  {
    "id": "deterministic-eval-004-manual-loop",
    "question": "I want to build a deterministic forecast workflow from scratch without using earth2studio.run.deterministic. Write a complete script that manually fetches initial conditions, creates the model iterator, steps through it, and writes each step to the IO backend. Use Pangu for a 5-day forecast of z500 and t2m from 2024-03-01 00Z with GFS data and ZarrBackend output.",
    "expected_skill": "earth2studio-deterministic-forecast",
    "expected_script": "evals/targets/eval_4_target.py",
    "ground_truth": "Generates a complete script that reimplements the deterministic workflow loop manually: fetches data with fetch_data, sets up IO coordinates, creates the prognostic iterator, loops through steps writing output via split_coords, and uses map_coords for coordinate subsetting. Does NOT call earth2studio.run.deterministic.",
    "expected_behavior": [
      "Does NOT import or call earth2studio.run.deterministic",
      "Uses fetch_data to get initial conditions",
      "Creates prognostic iterator with model.create_iterator()",
      "Implements manual loop stepping through nsteps=20",
      "Uses map_coords or similar to filter z500 and t2m",
      "Writes output to ZarrBackend at each step"
    ]
  },
  {
    "id": "deterministic-eval-negative-001-install",
    "question": "How do I install earth2studio with all the model dependencies? I want to use Pangu and GraphCast.",
    "expected_skill": null,
    "expected_script": null,
    "ground_truth": "This is an installation question, not a forecast inference question. Should NOT activate earth2studio-deterministic-forecast skill. Should either activate earth2studio-install skill or provide general installation guidance.",
    "expected_behavior": [
      "Does NOT activate earth2studio-deterministic-forecast skill",
      "Provides installation guidance (pip install or uv add)",
      "May mention model extras like [pangu] or [graphcast]"
    ]
  },
  {
    "id": "deterministic-eval-negative-002-discover",
    "question": "What weather forecast models are available in earth2studio? I want to compare their accuracy and resolution.",
    "expected_skill": null,
    "expected_script": null,
    "ground_truth": "This is a discovery/comparison question, not a request to build an inference script. Should NOT activate earth2studio-deterministic-forecast skill. Should either activate earth2studio-discover skill or provide model comparison information.",
    "expected_behavior": [
      "Does NOT activate earth2studio-deterministic-forecast skill",
      "Lists available prognostic models",
      "May compare model characteristics (resolution, accuracy, VRAM)"
    ]
  }
]

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

What our scanner noticed· Medium risk

  • Large base64-encoded blobs
  • Instructions that use the network
  • Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
NVIDIA Earth-2 Team
Publisher
NVIDIA (Official)
Source
NVIDIA/skills · skills/earth2studio-deterministic-forecast · commit fce3cca
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE-APACHE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by NVIDIA Earth-2 Team or NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download earth2studio-deterministic-forecast.zip