MicroWeather-Bench is a benchmark for station-level weather downscaling over the contiguous United States (CONUS): predicting the hourly conditions observed at a weather station from a coarse reanalysis. It is built around one question: which description of a station's surroundings, an embedding from an Earth-observation foundation model or raw terrain, land-cover and satellite patches, best helps a downscaling model capture station micro-climate.

The dataset has three components, all for the same 11,849 stations:

hourly station observations for 2020 to 2023 from the Meteorological Assimilation Data Ingest System (MADIS) of the US National Oceanic and Atmospheric Administration (NOAA);
ERA5, the reanalysis of the European Centre for Medium-Range Weather Forecasts (ECMWF), on its 0.25-degree grid and interpolated to the stations;
static per-station node features (each station is a node of the station network): embeddings from four foundation models (AlphaEarth, SatCLIP, TESSERA, TerraMind) and patches of terrain, land cover and Sentinel-2 imagery.

Two fixed station splits divide the stations into backbone, train, val and test groups, and the recommended protocol trains on 2020 to 2022 and scores the held-out year 2023 (see Task and protocol).

At a glance

Property	Value
Region	CONUS. Stations lie within 24.554 to 49.000 N and 124.490 to 67.013 W; the ERA5 grid window is 23 to 51 N, 127 to 65 W
Period	Observations and ERA5: 2020-01-01 to 2023-12-31, hourly (35,064 hours). Node features are static and date from 2019 to 2024, see Provenance
Stations	11,849 in four fixed groups, 8,180 backbone, 2,260 train, 854 val, 555 test, under two alternative splits: by station quality or by ERA5 grid cell
Variables	t2m and d2m (2 m temperature and dew point, K); u10 and v10 (eastward and northward 10 m wind, m/s); observed and ERA5
Access	Gated; access requests are approved manually, see Access and loading
Format	21 Zarr stores (Zarr format 3) plus three station files; 21.89 GB in 506 files
Station-hours (the `n` of `size_categories`)	11,849 stations x 35,064 hours = 415,473,336

Repository layout:

stations/
  locations.geojson                  station points, ids STN00001 to STN11849
  quality_splits.json                station groups by station quality: backbone, train, val, test
  era5_cell_splits.json              the same four groups drawn by ERA5 grid cell
madis-hourly/
  2020-2023-CONUS.zarr               station observations with observed/interpolated flags
era5-hourly/
  2020-2023-CONUS-gridded.zarr       ERA5 on the 0.25-degree CONUS grid
  2020-2023-CONUS-interpolated.zarr  ERA5 interpolated to the stations
node-features/
  foundation-model-embeddings/       9 stores, one embedding vector per station
  land-cover/                        1 store, 48 x 48 patches
  satellite/seasonal/                4 stores, 48 x 48 patches, one per season
  terrain/                           4 stores, 16 x 16 patches

Every station-indexed store (all except the gridded ERA5 store) uses the same station_id list in the same order as stations/locations.geojson.

Path	Content	Dims (shape)	dtype	Size
`stations/locations.geojson`	station points with ids	11,849 Point features	GeoJSON	2.7 MB
`stations/quality_splits.json`	station groups, quality split	4 lists of ids	JSON	0.2 MB
`stations/era5_cell_splits.json`	station groups, ERA5-cell split	4 lists of ids	JSON	0.2 MB
`madis-hourly/2020-2023-CONUS.zarr`	observed t2m, d2m, u10, v10 and `<var>_qc` observed/interpolated flags	(station_id 11849, time 35064)	float64, flags uint8	4.92 GB
`era5-hourly/2020-2023-CONUS-gridded.zarr`	ERA5 t2m, d2m, u10, v10 on the grid, plus a scalar `crs`	(time 35064, latitude 113, longitude 249)	float32	10.03 GB
`era5-hourly/2020-2023-CONUS-interpolated.zarr`	ERA5 t2m, d2m, u10, v10 at the stations	(station_id 11849, time 35064)	float32	5.68 GB
`node-features/foundation-model-embeddings/GOOGLE_SATELLITE_EMBEDDING_V1_ANNUAL_2019_30m-CONUS.zarr`	AlphaEarth embedding, 2019, read at 30 m (the published Marmot model's input)	(station_id 11849, band 64, y 1, x 1)	float32	2.9 MB
`node-features/foundation-model-embeddings/GOOGLE_SATELLITE_EMBEDDING_V1_ANNUAL_2024_10m-CONUS.zarr`	AlphaEarth embedding, 2024, read at 10 m	(11849, 64, 1, 1)	float32	1.2 MB
`node-features/foundation-model-embeddings/SatCLIP_ResNet18_L40-CONUS.zarr`	SatCLIP location embedding	(11849, 256, 1, 1)	float32	11.4 MB
`node-features/foundation-model-embeddings/TESSERA_V1_1_ANNUAL_2019-CONUS.zarr`	TESSERA 1.1 embedding, 2019; plus a per-station status variable	(11849, 128, 1, 1)	float32	5.2 MB
`node-features/foundation-model-embeddings/TESSERA_V1_1_ANNUAL_2024-CONUS.zarr`	the same for 2024	(11849, 128, 1, 1)	float32	5.2 MB
`node-features/foundation-model-embeddings/TerraMind_v1_base_S2L2A_DEM_LULC_WINDOW_ANNUAL_2019-CONUS.zarr`	TerraMind embedding from Sentinel-2, elevation and land-cover windows, 2019; plus three per-station masked-pixel variables	(11849, 768, 1, 1)	float32	33.7 MB
`node-features/foundation-model-embeddings/TerraMind_v1_base_S2L2A_DEM_LULC_WINDOW_ANNUAL_2024-CONUS.zarr`	the same for 2024	(11849, 768, 1, 1)	float32	33.7 MB
`node-features/foundation-model-embeddings/TerraMind_v1_base_S2_RGB_SEASONAL_PATCH_ANNUAL_2019-CONUS.zarr`	TerraMind embedding from seasonal Sentinel-2 RGB patches, 2019; plus the masked-pixel variables	(11849, 768, 1, 1)	float32	33.8 MB
`node-features/foundation-model-embeddings/TerraMind_v1_base_S2_RGB_SEASONAL_PATCH_ANNUAL_2024-CONUS.zarr`	the same for 2024	(11849, 768, 1, 1)	float32	33.8 MB
`node-features/land-cover/ESA_WorldCover_10m_v200-CONUS.zarr`	7 land-cover class-group layers	(11849, 7, 48, 48)	uint8	29.7 MB
`node-features/satellite/seasonal/S2_Seasonal_Winter_2024-CONUS.zarr`	Sentinel-2 winter median composite, bands B2, B3, B4, B8	(11849, 4, 48, 48)	float32	253 MB
`node-features/satellite/seasonal/S2_Seasonal_Spring_2024-CONUS.zarr`	Sentinel-2 spring median composite, same bands	(11849, 4, 48, 48)	float32	249 MB
`node-features/satellite/seasonal/S2_Seasonal_Summer_2024-CONUS.zarr`	Sentinel-2 summer median composite, same bands	(11849, 4, 48, 48)	float32	249 MB
`node-features/satellite/seasonal/S2_Seasonal_Autumn_2024-CONUS.zarr`	Sentinel-2 autumn median composite, same bands	(11849, 4, 48, 48)	float32	248 MB
`node-features/terrain/COPERNICUS_DEM_GLO30_DEM-CONUS.zarr`	digital elevation model (DEM) elevation	(11849, 1, 16, 16)	float32	15.0 MB
`node-features/terrain/COPERNICUS_DEM_GLO30_Slope-CONUS.zarr`	slope	(11849, 1, 16, 16)	float32	15.0 MB
`node-features/terrain/COPERNICUS_DEM_GLO30_Aspect-CONUS.zarr`	aspect as Eastness and Northness	(11849, 2, 16, 16)	float32	24.8 MB
`node-features/terrain/JAXA_ALOS_AW3D30_V3_2-CONUS.zarr`	digital surface model (DSM)	(11849, 1, 16, 16)	float32	9.7 MB

Task and protocol

Task. For a target station and hour, predict the observed t2m, d2m, u10 and v10 from (a) ERA5 at the station and on the surrounding grid, (b) contemporaneous observations at neighbouring backbone stations, and (c) the station's static node features.

Station groups. Every station belongs to exactly one of four groups. Two fixed assignments are provided, with the same group sizes but different stations; use one as it is, do not re-draw it, and state which one you used:

stations/quality_splits.json, the quality split: the groups drawn by the maintainers according to station quality. Neighbouring stations can fall in different groups: 1,277 of the 4,741 ERA5 grid cells that contain stations hold stations of more than one group.
stations/era5_cell_splits.json, the ERA5-cell split: every station is assigned to its nearest ERA5 0.25-degree grid node and all stations of a node share one group, so a test station never has a train, val or backbone station in its own cell. This is the split the published Marmot model was trained and evaluated with.

The two assignments agree only at chance level, so results under one split are not comparable with results under the other.

Group	Stations	Role
backbone	8,180	context stations whose observations are model inputs
train	2,260	target stations for fitting
val	854	target stations for model selection
test	555	target stations for final scoring

Recommended protocol. The split files fix only the station groups, not the years. The maintainers' protocol also holds out a year: fit on 2020 to 2022 at the train stations, select models on 2020 to 2022 at the val stations, and report final scores on 2023 at the test stations. Both hourly station stores cover all 11,849 stations for all four years, so backbone observations are available as inputs in every year.

Group	Stations	Years	Hours	Station-hours
train	2,260	2020 to 2022	26,304	59.4 M
val	854	2020 to 2022	26,304	22.5 M
test	555	2023	8,760	4.86 M

These counts include interpolated hours; use only hours whose observed/interpolated flag is 1 as targets (see Station observations). Comparisons between node-feature representations keep the task, the groups and the years fixed and vary only the node features. The repository fixes the data and the split, not an error metric: state the metric and the aggregation you use when you report results.

Access and loading

Access. The dataset is gated with manual approval. Request access in the browser while logged in to a Hugging Face Hub account: on the dataset page click "Agree and send request to access repo", which shares your Hub username and email address with the maintainers. After approval, authenticate on your machine with hf auth login (or from huggingface_hub import login; login() in a notebook).

Requirements. Reading needs zarr 3 or later and a recent xarray; reading directly from the Hub needs huggingface_hub and a recent fsspec; the lazy example below uses dask. The examples were run with huggingface_hub 1.9, xarray 2025.7, zarr 3.1, fsspec 2026.3 and dask 2025.7.

pip install "huggingface_hub>=0.34" "xarray>=2025.1.1" "zarr>=3.0.2" "fsspec>=2024.12" dask
hf auth login

Lazy access from the Hub. xarray opens a store through its hf:// URL (resolved by the HfFileSystem of huggingface_hub) and only fetches the chunks you index.

import json
import xarray as xr
from huggingface_hub import HfFileSystem

REPO = "hf://datasets/Giezi/MicroWeather-Bench"

# Station groups: one small JSON file, read directly from the Hub
fs = HfFileSystem()
with fs.open(f"{REPO}/stations/quality_splits.json") as f:
    splits = json.load(f)
print({k: len(v) for k, v in splits.items()})

# Station observations: lazy open, then load one station for one day
obs = xr.open_zarr(f"{REPO}/madis-hourly/2020-2023-CONUS.zarr", consolidated=True)
print(obs)
day = obs[["t2m", "t2m_qc"]].sel(station_id="STN00001", time="2023-07-01").load()
print(day["t2m"].values[:6], day["t2m_qc"].values[:6])

# ERA5 on the grid: one day of t2m in a 1-degree window around STN00001
era5 = xr.open_zarr(f"{REPO}/era5-hourly/2020-2023-CONUS-gridded.zarr", consolidated=True)
lat = float(obs["latitude"].sel(station_id="STN00001"))
lon = float(obs["longitude"].sel(station_id="STN00001"))
win = era5["t2m"].sel(time="2023-07-01", latitude=slice(lat - 0.5, lat + 0.5), longitude=slice(lon - 0.5, lon + 0.5)).load()
print(win.shape)

# Node features: the 64-d AlphaEarth vector of one station
ae = xr.open_zarr(f"{REPO}/node-features/foundation-model-embeddings/GOOGLE_SATELLITE_EMBEDDING_V1_ANNUAL_2024_10m-CONUS.zarr", consolidated=True)
vec = ae["band_data"].sel(station_id="STN00001").squeeze().load()
print(vec.shape, vec.values[:4])

The first print gives {'backbone': 8180, 'train': 2260, 'val': 854, 'test': 555}; the day of t2m comes back as 24 values in K with their flags; the ERA5 window has shape (24, 4, 4) (the four grid points on each side that fall within half a degree of the station); the vector has shape (64,).

Download. For training it is faster to download the stores you need and open them from local disk. Partial downloads are possible at shard granularity (see Storage layout). To make results reproducible, pin the data revision with --revision <commit> (the commit list is under "Files and versions", "History: N commits"); the hf:// URLs accept the same pin as hf://datasets/Giezi/MicroWeather-Bench@<commit>/....

# station files (about 3.1 MB)
hf download Giezi/MicroWeather-Bench --repo-type dataset --include "stations/*" --local-dir MicroWeather-Bench

# all node features (about 1.25 GB)
hf download Giezi/MicroWeather-Bench --repo-type dataset --include "node-features/*" --local-dir MicroWeather-Bench

# one hourly store (4.92 GB); drop --include to fetch everything (21.89 GB)
hf download Giezi/MicroWeather-Bench --repo-type dataset --include "madis-hourly/*" --local-dir MicroWeather-Bench

# the 2023 test year only: everything except shards 0 and 1 of each variable
# station observations (about 2.4 GB)
hf download Giezi/MicroWeather-Bench --repo-type dataset --include "madis-hourly/*" --exclude "madis-hourly/*/c/0/[01]" --local-dir MicroWeather-Bench
# ERA5 at the stations (about 2.8 GB)
hf download Giezi/MicroWeather-Bench --repo-type dataset --include "era5-hourly/2020-2023-CONUS-interpolated.zarr/*" --exclude "era5-hourly/*/c/0/[01]" --local-dir MicroWeather-Bench
# ERA5 on the grid (about 5.0 GB); the grid store's shard paths are <var>/c/<shard>/0/0
hf download Giezi/MicroWeather-Bench --repo-type dataset --include "era5-hourly/2020-2023-CONUS-gridded.zarr/*" --exclude "era5-hourly/*/c/[01]/0/0" --local-dir MicroWeather-Bench

In such a partial copy the hours of the missing shards read back as fill values (NaN for the variables, 0 for the flags) rather than raising an error, so select the 2023 hours explicitly.

import xarray as xr
obs = xr.open_zarr("MicroWeather-Bench/madis-hourly/2020-2023-CONUS.zarr", consolidated=True)
obs_2023 = obs.sel(time="2023")

Storage layout

Every store is Zarr format 3 with consolidated metadata and Zstd (level 3) compression. Every array-valued data variable (the hourly variables, their flags and band_data) uses the Zarr v3 sharding codec; the scalar crs and the coordinate arrays are ordinary, unsharded arrays. The chunk shapes below are the inner chunks that xarray and dask see, while the objects stored in the repository (what the file tree shows and what hf download fetches) are shards.

Inside each shard the hourly stores are chunked along time by day: [11849, 24] in the two station stores and [24, 113, 249] in the grid store, so one day for all stations, or the full grid for one day, is one inner chunk per variable, while one station's full series touches all 1,461 daily chunks per variable. A lazy read of one day through HfFileSystem fetches the shard's index plus one byte range, as in the example above; a tool without HTTP range reads pulls the whole shard. Each hourly variable has four shards of up to 8,784 hours, which are not aligned to calendar years after 2020:

Shard	Hours covered	Station-store object	Grid-store object
0	2020-01-01T00 to 2020-12-31T23	`<var>/c/0/0`	`<var>/c/0/0/0`
1	2021-01-01T00 to 2022-01-01T23	`<var>/c/0/1`	`<var>/c/1/0/0`
2	2022-01-02T00 to 2023-01-02T23	`<var>/c/0/2`	`<var>/c/2/0/0`
3	2023-01-03T00 to 2023-12-31T23	`<var>/c/0/3`	`<var>/c/3/0/0`

Shard sizes: about 230 to 360 MB for the observation store's float variables, 5 to 6 MB for each flag variable, 320 to 385 MB for the station-interpolated ERA5 store and 585 to 670 MB for the grid store. The 2023 test year needs shards 2 and 3 of each variable.

Node-feature stores keep all 11,849 stations in one inner chunk and, for patches, one pixel per inner chunk ([11849, 8, 1, 1] for the embeddings, [11849, 2, 1, 1] for land cover and terrain, [11849, 4, 1, 1] for Sentinel-2), so reading one station's full patch touches every chunk. Each band_data array is one shard, except the 7-band land-cover array, which is four shards of 2, 2, 2 and 1 bands. Load whole node-feature stores (1.2 MB to 253 MB each) and index in memory.

Stations and splits

11,849 stations with ids STN00001 to STN11849 (a zero-padded five-digit index). Station elevation, from the observation store, ranges from -29 to 3,522 m.
stations/locations.geojson: a GeoJSON FeatureCollection of Point features in plain longitude/latitude degrees (CRS84). Each feature carries the properties station_id, latitude and longitude.
stations/quality_splits.json and stations/era5_cell_splits.json: each a JSON object with the four keys backbone, train, val and test, each key a list of station ids. In each file the four lists are disjoint and together cover all 11,849 ids; the two files assign the stations differently (see Task and protocol).

{
  "backbone": ["STN00001", "STN00002", "STN00003", "..."],
  "train":    ["STN00016", "STN00020", "STN00024", "..."],
  "val":      ["STN00012", "STN00021", "STN00069", "..."],
  "test":     ["STN00008", "STN00138", "STN00226", "..."]
}

Station observations (MADIS)

Store madis-hourly/2020-2023-CONUS.zarr, dims (station_id: 11849, time: 35064), Climate and Forecast (CF) conventions 1.10, source MADIS, institution NOAA. The store's history attribute holds only the creation date (2026-03-03); the processing from raw MADIS files, including the interpolation of non-observed hours, is not documented in the store.

Variable	standard_name	long_name	Units	dtype	Flag variable
`t2m`	air_temperature	2 metre temperature	K	float64	`t2m_qc`
`d2m`	dew_point_temperature	2 metre dewpoint temperature	K	float64	`d2m_qc`
`u10`	eastward_wind	10 metre U wind component	m s-1	float64	`u10_qc`
`v10`	northward_wind	10 metre V wind component	m s-1	float64	`v10_qc`

<var>_qc (uint8, flag_values [0, 1], flag_meanings "interpolated observed") is 1 where the value was observed and 0 where it was interpolated; the CF ancillary_variables attribute links each flag to its variable. Despite the suffix, it is an observed/interpolated flag, not a MADIS quality-control level.
Non-observed hours are filled and flagged rather than left as NaN (the float variables use NaN as _FillValue). Interpolated stretches can cover whole days: on 2023-07-01, for example, 17% of the t2m values carry flag 0, 1,472 stations are flagged interpolated for all 24 hours, and no value is NaN.
The flags are per variable and do not always coincide: on the same day 19% of the d2m values are flagged interpolated against 17% for t2m, u10 and v10, so mask each variable with its own flag.
The flag arrays have Zarr fill value 0, so an unwritten flag chunk reads as interpolated.

Use only hours with flag 1 as targets and for scoring.

Coordinates: latitude and longitude (float64, degrees_north and degrees_east), elevation (float64, metres; the store carries no units attribute), station_id (object, cf_role: timeseries_id), time (datetime64[ns]).
Time axis: hourly from 2020-01-01T00:00 to 2023-12-31T23:00, 35,064 steps with no gaps. No store, observations or ERA5, records a time zone for the hourly axis.

ERA5 reanalysis

Both stores: CF-1.10; source "ERA5 hourly data on single levels (ECMWF)"; institution ECMWF; reference 10.24381/cds.adbb2d47; the same 35,064-step hourly time axis as the observations.

Gridded store era5-hourly/2020-2023-CONUS-gridded.zarr, dims (time: 35064, latitude: 113, longitude: 249).

Regular 0.25-degree latitude/longitude grid: latitude 23.0 to 51.0 N, stored in increasing order (the coordinate carries a stored_direction: decreasing attribute inherited from the source files that does not describe the stored array); longitude -127.0 to -65.0 E.
Variables t2m, d2m, u10, v10 (float32, NaN fill) with the same standard names and units as the observations. The original GRIB attributes are kept on each variable; they mark the fields as instantaneous analysis values.
A scalar crs variable (int32) holds the grid mapping: grid_mapping_name: latitude_longitude on the ERA5 sphere (semi-major axis 6,371,229 m, inverse flattening 0), with a crs_wkt string.
History: subset to the CONUS window and converted from ERA5's native GRIB files with the cfgrib reader, created 2026-03-03.

Station-interpolated store era5-hourly/2020-2023-CONUS-interpolated.zarr, dims (station_id: 11849, time: 35064).

The same four variables (float32, NaN fill) interpolated to the station locations; the store's history attribute records bicubic interpolation to the MADIS station locations, applied to the subset and reformatted fields, created 2026-03-03.
Coordinates latitude and longitude per station (float32), station_id (cf_role: timeseries_id), time.

Node features

All node-feature stores share one layout: a single data variable band_data with dims (station_id, band, y, x), a 1-based integer band coordinate, latitude (station_id, y) and longitude (station_id, x) coordinates, and the common station_id list. CF-1.10 conventions; the stores were created 2026-03-10, except the 2019 embedding stores, the two TerraMind 2024 stores and the TESSERA 2024 store, created in October 2026 (each store's history attribute carries its date).

Embedding stores hold one vector per station: y = x = 1, band indexes the embedding dimension. The four TerraMind stores also carry three per-station variables along station_id (masked_fraction, masked_months or masked_seasons, blank_months or blank_seasons) and the two TESSERA stores a status variable, see Foundation-model embeddings.
Patch stores hold a square window centred on the station (the station point lies at the patch centre to within 1 m in latitude). Rows run north to south. The x and y coordinate values are window indices, not positions: 24 to 71 for the 48-pixel patches and 8 to 23 for the 16-pixel patches, which means the stored patch is the central part of a larger extraction window.
Use the latitude and longitude coordinates to georeference pixels: the latitude step is constant and the longitude step widens with latitude, so pixels stay about 10 m (30 m) wide on the ground, and both patch sizes cover about 480 m (48 pixels at about 10 m, 16 pixels at about 30 m). The stores do not record whether a coordinate value marks a pixel's centre or its edge (band_data carries GDAL's AREA_OR_POINT: Area), and the station lies midway between the two central coordinate values, so georeferencing is accurate to about half a pixel.
The patch stores carry no coordinate reference system variable (the grid_mapping: spatial_ref attribute on band_data points to a variable that is not present); the coordinates are plain geographic degrees. Patch stores with several bands carry a band_name coordinate.

Foundation-model embeddings

Store (`node-features/foundation-model-embeddings/`)	Model	Dim	Year	Reference
`GOOGLE_SATELLITE_EMBEDDING_V1_ANNUAL_2019_30m-CONUS.zarr`	AlphaEarth Foundations Satellite Embedding V1 Annual (Google and Google DeepMind)	64	2019 annual, read at 30 m	https://developers.google.com/earth-engine/datasets/catalog/GOOGLE_SATELLITE_EMBEDDING_V1_ANNUAL
`GOOGLE_SATELLITE_EMBEDDING_V1_ANNUAL_2024_10m-CONUS.zarr`	AlphaEarth Foundations Satellite Embedding V1 Annual (Google and Google DeepMind)	64	2024 annual, read at 10 m	https://developers.google.com/earth-engine/datasets/catalog/GOOGLE_SATELLITE_EMBEDDING_V1_ANNUAL
`SatCLIP_ResNet18_L40-CONUS.zarr`	SatCLIP location encoder, ResNet18 L40 (Microsoft Research)	256	nominal (see below)	https://doi.org/10.48550/arXiv.2311.17179
`TESSERA_V1_1_ANNUAL_{2019,2024}-CONUS.zarr`	TESSERA version 1.1 (Cambridge Centre for Earth Observation)	128	2019 and 2024 annual, one store each	https://doi.org/10.48550/arXiv.2506.20380
`TerraMind_v1_base_S2L2A_DEM_LULC_WINDOW_ANNUAL_{2019,2024}-CONUS.zarr`	TerraMind 1.0 base, `terramind_v1_base` (IBM and the European Space Agency, ESA), window variant	768	2019 and 2024, one store each	https://doi.org/10.48550/arXiv.2504.11171
`TerraMind_v1_base_S2_RGB_SEASONAL_PATCH_ANNUAL_{2019,2024}-CONUS.zarr`	TerraMind 1.0 base, `terramind_v1_base` (IBM and ESA), RGB-patch variant	768	2019 and 2024, one store each	https://doi.org/10.48550/arXiv.2504.11171

All embedding stores are float32. How the vectors were computed, from each store's history attribute and, for AlphaEarth and TerraMind, from the generation scripts (kept in the maintainers' Marmot code repository under Embedding-Generation/):

AlphaEarth: the 64 channels (A00 to A63) of the annual embedding at the pixel containing the station. The 2024 store reads the image at its native 10 m; the 2019 store reads the 2019 image exported from Earth Engine at 30 m (the mean of the 10 m pixels) and holds exactly the vectors the published Marmot model was trained with. The scale is in the store name and in the spatial_resolution attribute.
SatCLIP: embeddings generated for the station locations. SatCLIP encodes latitude and longitude only, so the temporal_coverage: 2024 attribute is nominal.
TESSERA: version 1.1, read from the published 10 m map (dataset v1.1-dclimate, the complete global run for 2017 to 2025, served on Source Cooperative and AWS Open Data) with geotessera 0.11: the vector of the pixel containing the station. One station, STN06825, lies in a small unwritten hole of the map in both years and holds the nearest written pixel, 20 to 30 m away; the status variable along station_id says valid or nearest_3px for every station. Version 1.0 and 1.1 embeddings come from different model runs and do not correspond; the earlier 1.0 store was removed.
TerraMind, S2L2A DEM LULC window: 12 monthly Sentinel-2 Level-2A surface-reflectance composites (12 bands, median of the scenes of the month after Cloud Score+ masking), the Copernicus GLO-30 DEM and the Esri 10 m annual land cover of the year, as 224 x 224 windows at 10 m (2.24 km) centred on the station; terramind_v1_base tokens per month; median over the 4 centre patches, then over the 12 months.
TerraMind, S2 RGB seasonal patch: the red, green and blue bands of the central 16 x 16 pixels (160 m) of 4 seasonal Sentinel-2 composites, stretched to a true-colour image; one terramind_v1_base token per season; averaged over the seasons.

Cloud-masked pixels in the TerraMind inputs. A composite pixel that was cloudy in every scene of its month or season has no value. Such pixels are filled with TerraMind's band mean (0 after normalisation) before the model runs, so every station has a vector, and stations without masked pixels are unaffected. What was filled is recorded per station: masked_fraction (share of the input values filled), masked_months / masked_seasons (periods with at least one filled pixel) and blank_months / blank_seasons (periods filled everywhere, where the model saw a flat image). In the window stores 6,049 (2019) and 5,071 (2024) stations have filled pixels and 1,393 and 1,172 have a month filled everywhere; in the RGB stores 13 and 11 stations have filled crop pixels. Filter or down-weight by these variables if that matters for your model. The land-cover input of the window variant uses the Esri classes remapped to 1 to 9, while TerraMind's land-cover tokenizer was trained on the ESA WorldCover legend; the model accepts the input, but the classes do not carry their trained meaning.

Patch features

Store (`node-features/`)	Bands (`band_name`)	Patch	Pixel	Source
`land-cover/ESA_WorldCover_10m_v200-CONUS.zarr`	7 class-group layers, uint8	48 x 48	about 10 m	ESA WorldCover 10 m 2021 v200, https://doi.org/10.5281/zenodo.7254221
`satellite/seasonal/S2_Seasonal_{Winter,Spring,Summer,Autumn}_2024-CONUS.zarr`	B2, B3, B4, B8, float32	48 x 48	about 10 m	Harmonized Sentinel-2 MultiSpectral Instrument (MSI) Level-2A surface reflectance, median composite per season, https://dataspace.copernicus.eu/data-collections/copernicus-sentinel-missions/sentinel-2
`terrain/COPERNICUS_DEM_GLO30_DEM-CONUS.zarr`	1 band, DEM elevation, float32	16 x 16	about 30 m	Copernicus DEM GLO-30, https://doi.org/10.5069/G9028PQB
`terrain/COPERNICUS_DEM_GLO30_Slope-CONUS.zarr`	1 band, slope, float32	16 x 16	about 30 m	derived from the Copernicus GLO-30 DEM
`terrain/COPERNICUS_DEM_GLO30_Aspect-CONUS.zarr`	2 bands, Eastness and Northness, float32	16 x 16	about 30 m	derived from the Copernicus GLO-30 DEM
`terrain/JAXA_ALOS_AW3D30_V3_2-CONUS.zarr`	1 band, DSM, float32	16 x 16	about 30 m	JAXA ALOS World 3D 30 m (AW3D30) v3.2, https://www.eorc.jaxa.jp/ALOS/en/dataset/aw3d30/aw3d30_e.htm

Land cover: the seven layers are Tree cover & Mangroves; Grassland & Herbaceous wetland & Moss/Lichen; Shrubland; Cropland; Bare/sparse vegetation & Snow/Ice; Built-up; Permanent water bodies (the 11 WorldCover classes grouped into 7). The store records no definition of the layers (masks, counts or fractions) and no _FillValue attribute; the Zarr fill value is 0, the same as an absent class. At the four centre pixels of every station the values are 0 or 1 and exactly one of the seven layers is 1 per pixel, which is consistent with one-hot class masks; check the values before use.
Sentinel-2: the composite periods are Winter 2023-12-21 to 2024-03-21, Spring 2024-03-21 to 2024-06-22, Summer 2024-06-22 to 2024-09-23 and Autumn 2024-09-23 to 2024-12-21 (from the stores' temporal_coverage attributes). The stores record no units, scale factor or offset; the values are on the source's integer reflectance scale (values in the thousands, not 0 to 1), and patches can contain NaN pixels.
Terrain: the stores record no units for the DEM, the DSM, the slope or the aspect components; see the source products.

Provenance and processing

All stores share the spatial window CONUS 23 to 51 N, 127 to 65 W (spatial_coverage attribute). Each store's history attribute records its processing steps and creation date (2026-03-03 for the observation and ERA5 stores, 2026-03-10 for the node-feature stores, October 2026 for the 2019 embedding stores, the regenerated TerraMind 2024 stores and the TESSERA 1.1 2024 store); they are summarised in the sections above. The patch-store histories record only the extraction at the station locations, the per-season median compositing of Sentinel-2 and the derivation of slope and aspect from the DEM.

Temporal coverage differs by component. The node features are static descriptors of each station's surroundings, and their reference years differ from the observation years:

Component	Temporal coverage
Station observations and ERA5	2020-01-01 to 2023-12-31, hourly
AlphaEarth, TESSERA and TerraMind embeddings	2019 and 2024 (annual), one store per year
SatCLIP embeddings	attribute says 2024; the encoder uses location only
Sentinel-2 seasonal composites	2023-12-21 to 2024-12-21 in four seasons
Land cover	2021
Terrain (GLO-30 DEM products, AW3D30)	static; no temporal coverage recorded

Known limitations

Non-observed station hours are interpolated and flagged per variable, not left missing; use the <var>_qc flags.
Node features describe 2019 to 2024, while the observations cover 2020 to 2023.
The TerraMind inputs' cloud-masked pixels are filled with the band mean before the model; the per-station masked-pixel variables tell which stations are affected. The window variant's land-cover input is not on the legend TerraMind was trained with.
No store records the time zone of the hourly axis.
The terrain and land-cover layers carry no units or layer definitions, and the patch stores have no coordinate reference system variable.
Sentinel-2 patches are on the integer reflectance scale and can contain NaN pixels.

Source data and licenses

No license has been chosen for the compiled dataset yet; each component inherits the terms of its source. The observations, ERA5, the AlphaEarth and TESSERA vectors and the land-cover, Sentinel-2 and terrain patches are extracted or derived from the sources in the table. The SatCLIP and TerraMind vectors are outputs of openly licensed model weights, computed for this benchmark; their rows give the license of the weights.

Source	Used in	License (as stated by the source)
ERA5 hourly data on single levels, ECMWF / Copernicus Climate Change Service (C3S), via the Climate Data Store (CDS)	`era5-hourly/` (CONUS subset and station interpolation)	"CC-BY licence" on the CDS dataset page, that is CC BY 4.0
NOAA MADIS station observations	`madis-hourly/`, station locations	No named license: the MADIS data restrictions and data application pages (see the note below)
Google AlphaEarth Foundations Satellite Embedding V1 Annual (Earth Engine `GOOGLE/SATELLITE_EMBEDDING/V1/ANNUAL`)	the two AlphaEarth embedding stores	CC BY 4.0, stated in the catalog terms of use
SatCLIP location encoder, ResNet18 L40 weights (Microsoft)	SatCLIP embedding store	MIT, the license of the model weights and code
TerraMind 1.0 base weights, `terramind_v1_base` (IBM / ESA)	the four TerraMind embedding stores	Apache-2.0, the license of the model weights
TESSERA v1.1 embeddings (University of Cambridge, `ucam-eo`)	the two TESSERA embedding stores	CC0 1.0, stated in the TESSERA README
ESA WorldCover 10 m 2021 v200	land-cover patches (classes grouped into 7 layers)	CC BY 4.0, stated on the data access page
Copernicus DEM GLO-30 (COP-DEM-GLO-30-F)	DEM, slope and aspect patches; the elevation input of the TerraMind window embeddings	"Licence for Copernicus DEM instance COP-DEM-GLO-30-F Global 30m Full, Free & Open"
JAXA ALOS World 3D 30 m (AW3D30) v3.2	DSM patches	JAXA "Terms of Use of Research Data" and the AW3D30 terms of use
Esri 10 m Annual Land Use Land Cover time series, produced by Impact Observatory for Esri (Earth Engine community asset `projects/sat-io/open-datasets/landcover/ESRI_Global-LULC_10m_TS`)	land-cover input of the TerraMind window embeddings	CC BY 4.0, stated on the catalog page
Copernicus Sentinel-2 MSI Level-2A surface reflectance (harmonized collection)	Sentinel-2 seasonal composite stores and the Sentinel-2 inputs of the TerraMind embeddings	"Legal notice on the use of Copernicus Sentinel Data and Service Information" (European Commission)

Attribution notices. Each notice applies to the corresponding component wherever it is used or redistributed.

ERA5: "Generated using or contains modified Copernicus Climate Change Service information. Neither the European Commission nor ECMWF is responsible for any use that may be made of the Copernicus information or data it contains." ECMWF asks that credits name ECMWF as the producer, the dataset (ERA5), the Climate Data Store as the source, the CC-BY-4.0 license and that the data were modified.
MADIS: NOAA asks publications and web pages that depend on substantial use of the data to include a statement similar to "This study was made possible in part due to the data made available to the National Oceanic and Atmospheric Administration by [provider names]"; web pages that display the observations should also identify the source and carry a disclaimer such as "NOAA and its data providers disclaim liability of any kind whatsoever, including, without limitation, liability for quality, performance, merchantability and fitness for a particular purpose arising out of the use or inability to use the data." This repository does not record the provider of each station.
AlphaEarth: "The AlphaEarth Foundations Satellite Embedding dataset is produced by Google and Google DeepMind."
SatCLIP: the MIT notice "Copyright (c) Microsoft Corporation." accompanies any copy of the weights or code; the authors ask for Klemmer et al. (2025), below, to be cited.
TerraMind: the authors ask for Jakubik et al. (2025), below, to be cited. The Sentinel-2 inputs carry the Copernicus Sentinel notice.
TESSERA: CC0 1.0; the TESSERA README states "Although we do not legally require attribution, we do request it" (Feng et al. 2025, below).
ESA WorldCover: "© ESA WorldCover project 2021 / Contains modified Copernicus Sentinel data (2021) processed by ESA WorldCover consortium"
Copernicus DEM: "produced using Copernicus WorldDEM-30 © DLR e.V. 2010-2014 and © Airbus Defence and Space GmbH 2014-2018 provided under COPERNICUS by the European Union and ESA; all rights reserved" and "The organisations in charge of the Copernicus programme by law or by delegation do not incur any liability for any use of the Copernicus WorldDEM-30"
AW3D30: JAXA's terms state that "it is necessary to display that the original data is provided by JAXA" and ask users "to show the copyright (© JAXA) and the source of data", for example "Original data provided by JAXA: ALOS World 3D 30 m (AW3D30) v3.2, © JAXA".
Sentinel-2: "Contains modified Copernicus Sentinel data 2019, 2023-2024"

MADIS data policy. MADIS publishes no named license. Its data restrictions page (last updated 24 May 2017) sorts data providers into distribution categories; only data in the category "3 - Public - Full distribution" may be redistributed, and "Redistribution of data in distribution categories other than 'full distribution' is not allowed. This includes placing the data itself on public web pages." The mesonet providers request that users not redistribute or place the data on web pages without notifying NOAA (contact: the MADIS team, NCEP.List.MADIS_Support@noaa.gov), and data files containing MADIS mesonet observations "should continue to carry the data provider information". NOAA does not own or operate the mesonet sites; the data come from the individual providers. The station ids in this repository are anonymised and no provider information is stored. Users who publish work based on these observations are asked to include the acknowledgement quoted above, and web pages that display the observations also the disclaimer.

References to cite for the sources you use.

ERA5: Hersbach, H., Bell, B., Berrisford, P., Biavati, G., Horányi, A., Muñoz Sabater, J., Nicolas, J., Peubey, C., Radu, R., Rozum, I., Schepers, D., Simmons, A., Soci, C., Dee, D., Thépaut, J-N. (2023): ERA5 hourly data on single levels from 1940 to present. Copernicus Climate Change Service (C3S) Climate Data Store (CDS). https://doi.org/10.24381/cds.adbb2d47 (accessed before 2026-03-03, the store's creation date)
AlphaEarth: Brown, C. F., Kazmierski, M. R., Pasquarella, V. J., et al. (2025). AlphaEarth Foundations: An embedding field model for accurate and efficient global mapping from sparse label data. https://doi.org/10.48550/arXiv.2507.22291
SatCLIP: Klemmer, K., Rolf, E., Robinson, C., Mackey, L., Rußwurm, M. (2025). SatCLIP: Global, General-Purpose Location Embeddings with Satellite Imagery. Proceedings of the AAAI Conference on Artificial Intelligence, 39(4), 4347-4355. https://doi.org/10.1609/aaai.v39i4.32457
TerraMind: Jakubik, J., Yang, F., Blumenstiel, B., Scheurer, E., Sedona, R., Maurogiovanni, S., Bosmans, J., Dionelis, N., Marsocci, V., Kopp, N., et al. (2025). TerraMind: Large-Scale Generative Multimodality for Earth Observation. IEEE/CVF International Conference on Computer Vision (ICCV). https://doi.org/10.48550/arXiv.2504.11171
TESSERA: Feng, Z., Atzberger, C., Jaffer, S., et al. (2025). TESSERA: Temporal Embeddings of Surface Spectra for Earth Representation and Analysis. https://doi.org/10.48550/arXiv.2506.20380
ESA WorldCover: Zanaga, D., Van De Kerchove, R., Daems, D., De Keersmaecker, W., Brockmann, C., Kirches, G., Wevers, J., Cartus, O., Santoro, M., Fritz, S., Lesiv, M., Herold, M., Tsendbazar, N.E., Xu, P., Ramoino, F., Arino, O., 2022. ESA WorldCover 10 m 2021 v200. https://doi.org/10.5281/zenodo.7254221
Esri land cover: Karra, K., Kontgis, C., Statman-Weil, Z., Mazzariello, J. C., Mathis, M., Brumby, S. P. (2021). Global land use/land cover with Sentinel-2 and deep learning. IGARSS 2021 - 2021 IEEE International Geoscience and Remote Sensing Symposium. https://doi.org/10.1109/IGARSS47720.2021.9553499
Copernicus DEM: ESA asks publications to cite https://doi.org/10.5270/ESA-c5d3d65. The copy used here is referenced through OpenTopography: European Space Agency (2024). Copernicus Global Digital Elevation Model. Distributed by OpenTopography. https://doi.org/10.5069/G9028PQB (accessed before 2026-03-10, the store's creation date)
AW3D30: Tadono, T., Ishida, H., Oda, F., Naito, S., Minakawa, K., Iwamoto, H. (2014). Precise Global DEM Generation by ALOS PRISM. ISPRS Annals II-4; Takaku, J., Tadono, T., Doutsu, M., Ohgushi, F., Kai, H. (2020). Updates of "AW3D30" ALOS Global Digital Surface Model with Other Open Access Datasets. ISPRS Archives XLIII-B4-2020.

Citation

A citation entry for the benchmark will be added here. Until then, please cite the upstream sources you use, listed above.

Maintainers

Hub users Giezi (repository owner, handles access requests) and QidongYang.

Downloads last month: 144

Total file size:

21.9 GB