Skip to content

Running DLESyM Inference

Basic deterministic inference workflow for the DLESyM model.

This example will demonstrate how to run a simple inference workflow with the DLESyM model, which differs from other prognostic models in earth2studio. DLESyM performs global earth system modeling, including atmosphere and ocean components which evolve on different timescales (different temporal resolution). Internally, the model uses a HEALPix nside=64 (approximately 1 degree) resolution grid for the physical variables of interest. The model also uses some derived input variables which are not provided by standard data sources but can be computed from the standard variables.

In this example you will learn:

  • How to instantiate the DLESyM model
  • How to use the model API to generate a forecast
  • How to use the output selection and regridding methods to select appropriate data
  • How to use the DLESyMLatLon model with earth2studio workflows

Set Up

The first step is fetching appropriate input data for the model. The ERA5 data sources in earth2studio provide data on the lat/lon grid, so have two options:

  • Use the earth2studio.models.px.DLESyMLatLon model. This version of DLESyM accepts inputs on the lat/lon grid and regrids them to the HEALPix grid internally, before returning the output regridded back to the lat/lon grid. This is the recommended approach for most users as it can be used directly with earth2studio data sources and workflows, since it performs regridding and pre-processing internally.
  • Use the earth2studio.models.px.DLESyM model, and handle the regridding of input lat/lon data ourselves. Since the model uses some derived variables which are not provided by the data source, we would also need to prepare these derived variables ourselves.

Let's load both of these models and inspect the expected input coordinates for each. Also note the input and output variable set for each model.

import os

os.makedirs("outputs", exist_ok=True)
from dotenv import load_dotenv

load_dotenv()  # TODO: make common example prep function
import numpy as np
import torch

from earth2studio.data import ARCO
from earth2studio.data.utils import fetch_data
from earth2studio.models.px.dlesym import DLESyM, DLESyMLatLon

device = "cuda"
if not torch.cuda.is_available():
    raise RuntimeError("GPU/CUDA required for DLESyM")

# Create the data source
data = ARCO()

# Load the default model package which downloads the check point from NGC
# We will instantiate both versions of the model to demonstrate usage of each.
package = DLESyMLatLon.load_default_package()
model_ll = DLESyMLatLon.load_model(package).to(device)
package = DLESyM.load_default_package()
model_hpx = DLESyM.load_model(package).to(device)

in_coords_ll = model_ll.input_coords()
in_coords_hpx = model_hpx.input_coords()
print(
    "DLESyM LatLon input coord shapes: ",
    [(k, v.shape) for k, v in in_coords_ll.items()],
)
print(
    "DLESyM HPX input coord shapes: ", [(k, v.shape) for k, v in in_coords_hpx.items()]
)
print("Lat-lon input variable names: ", in_coords_ll["variable"])
print(
    "Lat-lon output variable names: ", model_ll.output_coords(in_coords_ll)["variable"]
)
print("HEALPix input variable names: ", in_coords_hpx["variable"])
print(
    "HEALPix output variable names: ",
    model_hpx.output_coords(in_coords_hpx)["variable"],
)
Console output47 lines
/__w/earth2studio/earth2studio/.venv/lib/python3.13/site-packages/torch/cuda/__init__.py:64: FutureWarning: The pynvml package is deprecated. Please install nvidia-ml-py instead. If you did not install pynvml directly, please report this to the maintainers of the package that installed pynvml for you.
  import pynvml  # type: ignore[import]
WARNING[XFORMERS]: xFormers can't load C++/CUDA extensions. xFormers was built for:
    PyTorch 2.10.0+cu128 with CUDA 1208 (you have 2.13.0+cu130)
    Python  3.10.19 (you have 3.13.13)
  Please reinstall xformers (see https://github.com/facebookresearch/xformers#installing-xformers)
  Memory-efficient attention, SwiGLU, sparse and more won't be available.
  Set XFORMERS_MORE_DETAILS=1 for more details
CuPy distance computation test failed with error: cuVS >= 24.12 or pylibraft < 24.12 should be installed to use this feature

Downloading config.yaml: 0%|          | 0.00/1.36k [00:00<?, ?B/s]
Downloading config.yaml: 100%|██████████| 1.36k/1.36k [00:00<00:00, 13.8kB/s]
Downloading config.yaml: 100%|██████████| 1.36k/1.36k [00:00<00:00, 13.7kB/s]

Downloading atmos_model_0.mdlus: 0%|          | 0.00/37.6M [00:00<?, ?B/s]
Downloading atmos_model_0.mdlus: 27%|██▋       | 10.0M/37.6M [00:00<00:02, 13.3MB/s]
Downloading atmos_model_0.mdlus: 53%|█████▎    | 20.0M/37.6M [00:00<00:00, 25.3MB/s]
Downloading atmos_model_0.mdlus: 80%|███████▉  | 30.0M/37.6M [00:01<00:00, 31.8MB/s]
Downloading atmos_model_0.mdlus: 100%|██████████| 37.6M/37.6M [00:01<00:00, 35.6MB/s]
Downloading atmos_model_0.mdlus: 100%|██████████| 37.6M/37.6M [00:01<00:00, 29.2MB/s]

Downloading ocean_model_0.mdlus: 0%|          | 0.00/2.97M [00:00<?, ?B/s]
Downloading ocean_model_0.mdlus: 100%|██████████| 2.97M/2.97M [00:00<00:00, 5.74MB/s]
Downloading ocean_model_0.mdlus: 100%|██████████| 2.97M/2.97M [00:00<00:00, 5.68MB/s]

Downloading hpx_lat.npy: 0%|          | 0.00/384k [00:00<?, ?B/s]
Downloading hpx_lat.npy: 100%|██████████| 384k/384k [00:00<00:00, 914kB/s]
Downloading hpx_lat.npy: 100%|██████████| 384k/384k [00:00<00:00, 911kB/s]

Downloading hpx_lon.npy: 0%|          | 0.00/384k [00:00<?, ?B/s]
Downloading hpx_lon.npy: 100%|██████████| 384k/384k [00:00<00:00, 855kB/s]
Downloading hpx_lon.npy: 100%|██████████| 384k/384k [00:00<00:00, 852kB/s]

Downloading land_sea_mask.npy: 0%|          | 0.00/192k [00:00<?, ?B/s]
Downloading land_sea_mask.npy: 100%|██████████| 192k/192k [00:00<00:00, 312kB/s]
Downloading land_sea_mask.npy: 100%|██████████| 192k/192k [00:00<00:00, 312kB/s]

Downloading topography.npy: 0%|          | 0.00/192k [00:00<?, ?B/s]
Downloading topography.npy: 100%|██████████| 192k/192k [00:00<00:00, 560kB/s]
Downloading topography.npy: 100%|██████████| 192k/192k [00:00<00:00, 558kB/s]
DLESyM LatLon input coord shapes:  [('batch', (0,)), ('time', (0,)), ('lead_time', (9,)), ('variable', (11,)), ('lat', (721,)), ('lon', (1440,))]
DLESyM HPX input coord shapes:  [('batch', (0,)), ('time', (0,)), ('lead_time', (9,)), ('variable', (9,)), ('face', (12,)), ('height', (64,)), ('width', (64,))]
Lat-lon input variable names:  ['z500' 'z1000' 't2m' 'tcwv' 't850' 'z250' 'sst' 'u10m' 'v10m' 'z300'
 'z700']
Lat-lon output variable names:  ['z500' 'tau300-700' 'z1000' 't2m' 'tcwv' 't850' 'z250' 'ws10m' 'sst']
HEALPix input variable names:  ['z500' 'tau300-700' 'z1000' 't2m' 'tcwv' 't850' 'z250' 'ws10m' 'sst']
HEALPix output variable names:  ['z500' 'tau300-700' 'z1000' 't2m' 'tcwv' 't850' 'z250' 'ws10m' 'sst']

Making Predictions, Regridding, and Selecting Outputs

Let's now pull some example data and make predictions with the model. As the data source provides lat/lon data, we can use the earth2studio.models.px.DLESyMLatLon model.

In addition, we demonstrate how to use the regridding utilities provided by DLESyMLatLon to regrid onto the HEALPix grid. The earth2studio.models.px.DLESyM model can then be used directly with the HEALPix data.

Finally, a key aspect of the DLESyM model is that it makes predictions for the atmosphere and ocean components at different timesteps, because the atmosphere is faster-evolving than the ocean. The atmosphere is predicted every 6 hours, while the ocean is only predicted every 48 hours. Thus, not all output lead times are valid for the ocean component. For convenience, we can use a method that selects only the valid outputs for each of the atmosphere and ocean components.

ic_date = np.datetime64("2021-06-15")

# Fetch some example data
x, coords = fetch_data(
    source=data,
    time=np.array([ic_date]),
    variable=np.array(in_coords_ll["variable"]),
    lead_time=in_coords_ll["lead_time"],
    device=device,
)

# Can call the `DLESyMLatLon` model directly with the input lat/lon data
y, y_coords = model_ll(x, coords)

# Or, we can use the pre-processing and regridding utilities to regrid the data onto
# the HEALPix grid, and then run directly with `DLESyM`, which expects HEALPix data
x_prep, coords_prep = model_ll._prepare_derived_variables(x, coords)
x_hpx, coords_hpx = model_ll.to_hpx(x_prep), model_ll.coords_to_hpx(coords_prep)
y_hpx, y_coords_hpx = model_hpx(x_hpx, coords_hpx)

# Retrieve the valid outputs for atmos/ocean components from the predictions
y_atmos, y_atmos_coords = model_ll.retrieve_valid_atmos_outputs(y, y_coords)
y_ocean, y_ocean_coords = model_ll.retrieve_valid_ocean_outputs(y, y_coords)

print(
    "Atmosphere outputs (variables, lead_time [hrs]):",
    y_atmos_coords["variable"],
    y_atmos_coords["lead_time"].astype("timedelta64[h]"),
)
print(
    "Ocean outputs (variables, lead_time [hrs]):",
    y_ocean_coords["variable"],
    y_ocean_coords["lead_time"].astype("timedelta64[h]"),
)
Console output54 lines
Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  14%|█▍        | 1/7 [00:00<00:00,  9.57it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:01<00:00,  3.53it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  3.47it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  3.59it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  14%|█▍        | 1/7 [00:00<00:01,  5.62it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:01<00:00,  3.75it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  3.84it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  3.87it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  14%|█▍        | 1/7 [00:00<00:00,  7.67it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:01<00:00,  3.56it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  3.48it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  3.58it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  14%|█▍        | 1/7 [00:00<00:01,  3.98it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:01<00:00,  4.35it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  4.58it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  4.49it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  14%|█▍        | 1/7 [00:00<00:00,  6.35it/s]
Fetching ARCO data:  71%|███████▏  | 5/7 [00:00<00:00, 14.63it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  3.69it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  4.44it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  14%|█▍        | 1/7 [00:00<00:00,  6.23it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:01<00:00,  4.26it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  3.58it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  3.80it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  14%|█▍        | 1/7 [00:00<00:01,  5.25it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:01<00:00,  3.34it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  3.95it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  14%|█▍        | 1/7 [00:00<00:00,  6.51it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:01<00:00,  3.05it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:02<00:00,  2.90it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:02<00:00,  3.01it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  14%|█▍        | 1/7 [00:00<00:01,  4.80it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:01<00:00,  4.57it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  3.67it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:01<00:00,  3.89it/s]
Atmosphere outputs (variables, lead_time [hrs]): ['z500' 'tau300-700' 'z1000' 't2m' 'tcwv' 't850' 'z250' 'ws10m'] [ 6 12 18 24 30 36 42 48 54 60 66 72 78 84 90 96]
Ocean outputs (variables, lead_time [hrs]): ['sst'] [48 96]

Model Iteration for Longer Forecasts

Similar to other models in earth2studio, we can use the model iterator to loop over forecasted outputs. A single step of the DLESyM model produces predictions over 4 days (96 hours), so to make a sub-seasonal forecast we can take 15 steps for a total of 60 days.

n_steps = 16
model_iter_ll = model_ll.create_iterator(x, coords)

for i in range(n_steps):
    x, x_coords = next(model_iter_ll)
    if i > 0:  # Don't retrieve the first step as it is the initial condition
        x_atmos, x_atmos_coords = model_ll.retrieve_valid_atmos_outputs(x, x_coords)
        x_ocean, x_ocean_coords = model_ll.retrieve_valid_ocean_outputs(x, x_coords)

print(f"Completed forecast with {n_steps} steps")
Console output1 line
Completed forecast with 16 steps

Using Built-in Deterministic Workflow

Because the DLESyMLatLon model permits usage of data coming directly from an earth2studio data source, we can use the built-in deterministic workflow to generate a forecast as well. The only caveat is we need to explitcitly specify the output lead time coordinates that will be generated by the model, since it has different input and output lead time dimensions.

import earth2studio.run as run
from earth2studio.io import KVBackend

io = KVBackend()

output_coords = model_ll.output_coords(coords)
inp_lead_time = model_ll.input_coords()["lead_time"]
out_lead_times = [
    output_coords["lead_time"] + output_coords["lead_time"][-1] * i
    for i in range(n_steps)
]
output_coords["lead_time"] = np.concatenate([inp_lead_time, *out_lead_times])
io = run.deterministic(
    [ic_date], n_steps, model_ll, data, io, output_coords=output_coords
)

ds = io.to_xarray()
print(ds)
Console output97 lines
2026-08-15 05:56:20.456 | INFO     | earth2studio.run:deterministic:85 - Running simple workflow!
2026-08-15 05:56:20.457 | INFO     | earth2studio.run:deterministic:92 - Inference device: cuda

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:00<00:00, 20.64it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:00<00:00, 23.77it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:00<00:00, 17.08it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:00<00:00, 19.65it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:00<00:00, 18.87it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:00<00:00, 21.57it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:00<00:00, 20.95it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:00<00:00, 22.73it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:00<00:00, 19.12it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:00<00:00, 22.11it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:00<00:00, 21.74it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:00<00:00, 23.69it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:00<00:00, 22.88it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:00<00:00, 26.34it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:00<00:00, 21.18it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:00<00:00, 22.98it/s]

Fetching ARCO data:   0%|          | 0/7 [00:00<?, ?it/s]
Fetching ARCO data:  86%|████████▌ | 6/7 [00:00<00:00, 21.99it/s]
Fetching ARCO data: 100%|██████████| 7/7 [00:00<00:00, 25.33it/s]
2026-08-15 05:56:24.882 | SUCCESS  | earth2studio.run:deterministic:154 - Fetched data from ARCO
2026-08-15 05:56:24.884 | INFO     | earth2studio.run:deterministic:162 - Inference starting!


Running inference:   0%|          | 0/17 [00:00<?, ?it/s]

Running inference:   6%|▌         | 1/17 [00:00<00:13,  1.21it/s]

Running inference:  12%|█▏        | 2/17 [00:01<00:15,  1.03s/it]

Running inference:  18%|█▊        | 3/17 [00:03<00:15,  1.09s/it]

Running inference:  24%|██▎       | 4/17 [00:04<00:14,  1.13s/it]

Running inference:  29%|██▉       | 5/17 [00:05<00:13,  1.17s/it]

Running inference:  35%|███▌      | 6/17 [00:06<00:12,  1.16s/it]

Running inference:  41%|████      | 7/17 [00:07<00:11,  1.16s/it]

Running inference:  47%|████▋     | 8/17 [00:09<00:10,  1.15s/it]

Running inference:  53%|█████▎    | 9/17 [00:10<00:09,  1.15s/it]

Running inference:  59%|█████▉    | 10/17 [00:11<00:08,  1.15s/it]

Running inference:  65%|██████▍   | 11/17 [00:12<00:06,  1.15s/it]

Running inference:  71%|███████   | 12/17 [00:13<00:05,  1.16s/it]

Running inference:  76%|███████▋  | 13/17 [00:14<00:04,  1.15s/it]

Running inference:  82%|████████▏ | 14/17 [00:15<00:03,  1.15s/it]

Running inference:  88%|████████▊ | 15/17 [00:17<00:02,  1.16s/it]

Running inference:  94%|█████████▍| 16/17 [00:18<00:01,  1.18s/it]

Running inference: 100%|██████████| 17/17 [00:19<00:00,  1.17s/it]
Running inference: 100%|██████████| 17/17 [00:19<00:00,  1.15s/it]
2026-08-15 05:56:44.364 | SUCCESS  | earth2studio.run:deterministic:189 - 
Inference complete
<xarray.Dataset> Size: 10GB
Dimensions:     (time: 1, lead_time: 265, lat: 721, lon: 1440)
Coordinates:
  * time        (time) datetime64[s] 8B 2021-06-15
  * lead_time   (lead_time) timedelta64[ns] 2kB -2 days +00:00:00 ... 64 days...
  * lat         (lat) float64 6kB 90.0 89.75 89.5 89.25 ... -89.5 -89.75 -90.0
  * lon         (lon) float64 12kB 0.0 0.25 0.5 0.75 ... 359.0 359.2 359.5 359.8
Data variables:
    z500        (time, lead_time, lat, lon) float32 1GB 5.253e+04 ... 4.784e+04
    tau300-700  (time, lead_time, lat, lon) float32 1GB 5.85e+04 ... 5.457e+04
    z1000       (time, lead_time, lat, lon) float32 1GB 890.4 890.4 ... -859.3
    t2m         (time, lead_time, lat, lon) float32 1GB 273.7 273.7 ... 225.4
    tcwv        (time, lead_time, lat, lon) float32 1GB 8.898 8.898 ... 0.3585
    t850        (time, lead_time, lat, lon) float32 1GB 265.6 265.6 ... 242.9
    z250        (time, lead_time, lat, lon) float32 1GB 9.844e+04 ... 9.048e+04
    ws10m       (time, lead_time, lat, lon) float32 1GB 0.0292 0.0292 ... 4.117
    sst         (time, lead_time, lat, lon) float32 1GB 271.5 271.5 ... 272.1

Plotting the Outputs

Let's plot some of the forecasted outputs for the atmosphere and ocean components.

import cartopy.crs as ccrs
import cartopy.feature as cfeature
import matplotlib.pyplot as plt

# lat = x_atmos_coords["lat"]
# lon = x_atmos_coords["lon"]
atmos_var, atmos_units = "ws10m", "m/s"
ocean_var, ocean_units = "sst", "K"
# atmos_var_idx = list(x_atmos_coords["variable"]).index(atmos_var)
# ocean_var_idx = list(x_ocean_coords["variable"]).index(ocean_var)
lead_time = ds.lead_time.values[-1]

plt.close("all")
# Create a Robinson projection
projection = ccrs.Robinson()

# Create a figure and axes with the specified projection
fig, axs = plt.subplots(1, 2, subplot_kw={"projection": projection}, figsize=(15, 6))

# Plot the field using pcolormesh
im = axs[0].pcolormesh(
    ds.lon.values,
    ds.lat.values,
    ds[atmos_var].sel(time=ic_date, lead_time=lead_time).values,
    transform=ccrs.PlateCarree(),
    cmap="cividis",
)

# Set title
axs[0].set_title(
    f"Initialization: {ic_date} - Lead time: {lead_time.astype('timedelta64[h]')}"
)

# Add coastlines and gridlines
axs[0].coastlines()
axs[0].gridlines()

cbar = fig.colorbar(im, ax=axs[0], orientation="horizontal", pad=0.05)
cbar.set_label(f"{atmos_var} [{atmos_units}]")

# Plot the ocean component
im = axs[1].pcolormesh(
    ds.lon.values,
    ds.lat.values,
    ds[ocean_var].sel(time=ic_date, lead_time=lead_time).values,
    transform=ccrs.PlateCarree(),
    cmap="Spectral_r",
)

axs[1].set_title(
    f"Initialization: {ic_date} - Lead time: {lead_time.astype('timedelta64[h]')}"
)

# Add coastlines and gridlines
axs[1].add_feature(cfeature.LAND, color="grey", zorder=100)
axs[1].coastlines()
axs[1].gridlines()

cbar = fig.colorbar(im, ax=axs[1], orientation="horizontal", pad=0.05)
cbar.set_label(f"{ocean_var} [{ocean_units}]")

plt.tight_layout()
plt.savefig("outputs/14_ws10m_sst_prediction.png")

Output from Running DLESyM Inference

Download Python sourceDownload Jupyter notebookexecuted in 130.4s
Execution profile

Runtime telemetry

Total runtime2m 10s

Execution environment

CPUAMD EPYC 7313P 16-Core Processor
GPUNVIDIA H100 PCIe · 79.6 GiB
System RAM58.5 GiB
PlatformLinux 6.8.0-136-generic
Python3.13.13
GPU driver / CUDADriver 595.84 · CUDA support 13.2