AeroWF

AeroWF is a multi-airport aerodrome meteorology dataset designed for self-supervised representation learning and downstream evaluation. It contains aligned runway observations, exogenous meteorological variables, weather labels, timestamps, normalization statistics, and airport graph structures stored as NumPy dictionaries.

Dataset subsets

Aero-Pre2020 — Pre-training Subset

139,878 samples from ZBAA, ZSPD, and ZSSS, collected in 2020 and used for the self-supervised pre-training of AeroWF and other self-supervised learning baselines.

• Repository directory: processed_2020/
• Airports: ZBAA, ZSPD, ZSSS
• Intended use: self-supervised pre-training
• ZBAD is intentionally excluded so that it can be used to evaluate transfer to an unseen airport.

Aero-Task — Downstream Subset

108,404 samples used for downstream evaluation, measuring adaptation to diverse operational scenarios beyond the pre-training distribution.

• Repository directory: processed/
• Airports: ZBAA, ZBAD, ZSPD, ZSSS
• Intended use: downstream training and evaluation

Repository structure

.
├── processed/                       # Aero-Task
│   ├── ZBAA_train.npy
│   ├── ZBAD_train.npy
│   ├── ZSPD_train.npy
│   ├── ZSSS_train.npy
│   └── global_weather_config.json
└── processed_2020/                  # Aero-Pre2020
    ├── ZBAA_train.npy
    ├── ZSPD_train.npy
    ├── ZSSS_train.npy
    └── global_weather_config.json

Each airport .npy file stores a serialized Python dictionary. In the table below, split is one of train, val, or test; N is the number of samples, R is the number of runways, T is the window length, and E is the number of graph edges.

Data schema

Key	Shape / type	Description
{split}_runway	(N, R, T, 11), float32	Runway-level meteorological time series.
{split}_exo_categorical	dict[str, ndarray(N)]	Categorical exogenous variables: weather_code_id, sky_condition, has_gust, and is_cavok.
{split}_exo_continuous	(N, 3), float32	Standardized visibility, cloud_height, and gust_speed, in that order.
{split}_weather_label	(N,), int64	Global weather-class ID. This is the same target represented by weather_code_id.
{split}_timestamps	(N,), datetime64[ns]	Start timestamp of each sliding window.
num_weather_classes	int	Number of global weather classes (21 in the published files).
num_sky_classes	int	Number of sky-condition classes (8 in the published files).
class_weights	(num_weather_classes,), float32	Class-weight metadata. The published files currently contain unit weights.
exo_scaler	dict	Training-split transformation parameters for continuous exogenous variables.
graph_structure	dict	Airport/runway graph metadata described below.
runway_feature_names	list[str]	Ordered names of the 11 runway features.
exo_categorical_names	list[str]	Ordered categorical exogenous feature names.
exo_continuous_names	list[str]	Ordered continuous exogenous feature names.
window_size	int	Number of one-minute observations in each window (96 in the published files).
stride	int	Sliding-window stride (1 in the published files).
num_runways	int	Number of runway nodes for the airport.

Runway features

The last dimension of {split}_runway follows this order:

Index	Feature	Description
0	cloud_base	Runway cloud-base observation; stored in the source-data unit.
1	wind_x	Wind vector component: wind_speed * cos(wind_direction).
2	wind_y	Wind vector component: wind_speed * sin(wind_direction).
3	pressure	Atmospheric pressure; stored in the source-data unit.
4	temperature	Air temperature; stored in the source-data unit.
5	humidity	Relative humidity; stored in the source-data unit.
6	dewpoint	Dew-point temperature; stored in the source-data unit.
7	hour_sin	sin(2*pi*hour/24).
8	hour_cos	cos(2*pi*hour/24).
9	month_sin	sin(2*pi*month/12).
10	month_cos	cos(2*pi*month/12).

The published artifacts preserve the physical runway variables before runtime Min-Max scaling. Their exact physical units follow the upstream AWOS source and should not be inferred from the NumPy files alone.

Exogenous features

Feature	Type	Description
weather_code_id	categorical	ID in global_weather_config.json.
sky_condition	categorical	Encoded METAR sky condition.
has_gust	binary	Whether a gust was reported.
is_cavok	binary	Whether CAVOK was reported.
visibility	continuous	METAR visibility; source unit: miles.
cloud_height	continuous	Lowest reported METAR cloud height; source unit: feet.
gust_speed	continuous	Reserved continuous gust feature. It is zero-valued in the current published files; use has_gust for gust presence.

Graph structure

graph_structure contains:

• edge_index: directed edges with shape (E, 2);
• edge_type: one integer type per edge (0: runway-to-airport aggregation, 1: airport-to-runway broadcast, 2: self-loop, 3: runway-to-runway neighbor);
• num_nodes: number of runway nodes plus one airport node;
• num_edge_types: 4.

Normalization

Continuous exogenous variables are transformed with statistics computed only from the training split of each airport file. The same statistics are then applied to its validation and test splits.

For visibility and ordinary continuous variables:

x_scaled = (x - mean_train) / std_train
x        = x_scaled * std_train + mean_train

For cloud_height, published files whose scaler contains "transform": "log1p" use:

x_scaled = (log1p(x) - mean_train) / std_train
x        = expm1(x_scaled * std_train + mean_train)

Always inspect data["exo_scaler"] rather than assuming one transformation for every file version.

The runway arrays are stored before Min-Max normalization. The provided MultiAirportDataset loader computes feature-wise bounds from the loaded training runway arrays and applies:

x_scaled = clip((x - x_min) / (x_max - x_min), 0, 1)

Categorical IDs, binary flags, timestamps, graph indices, and cyclic time features should not be Z-score normalized as continuous physical measurements.

Loading the data

import numpy as np

data = np.load("processed_2020/ZBAA_train.npy", allow_pickle=True).item()

print(data.keys())
print(data["train_runway"].shape)
print(data["train_weather_label"].shape)
print(data["runway_feature_names"])
print(data["exo_scaler"])

Because these files use NumPy object serialization, load them only from a trusted source when enabling allow_pickle=True.

The weather vocabulary is defined in global_weather_config.json and contains 21 classes, including precipitation, thunderstorms, fog, haze, dust, and good-weather conditions.

To invert a continuous exogenous feature safely:

import numpy as np

name = "cloud_height"
column = data["exo_continuous_names"].index(name)
scaled = data["train_exo_continuous"][:, column]
scaler = data["exo_scaler"][name]

value = scaled * scaler["std"] + scaler["mean"]
if scaler.get("transform") == "log1p":
    value = np.expm1(value)

Raw-data processing code

The project Dataset/ directory contains the processing code used to turn raw runway/AWOS observations and METAR reports into model-ready NumPy files. The raw AWOS source files are not redistributed with the processed dataset.

The main pipeline is:

Raw runway/AWOS JSON
    -> preprocess_runway_generic.py
    -> airport/<ICAO>/cleaned_data.csv
                                      \
                                       -> generate_train_data.py
                                      /   -> processed/<ICAO>_train.npy
Raw METAR reports                   /
    -> download_multi.py
    -> preprocess_metar_multi.py
    -> metar/processed/<icao>_metar/{metar_exogenous.csv, metar_exo_config.json}

Script roles

Script	Role
download_multi.py	Downloads daily METAR observations from the Iowa State Mesonet API.
preprocess_metar_multi.py	Parses METAR reports, encodes weather/sky conditions, fills a one-minute timeline, and writes exogenous CSV/config files.
preprocess_runway_generic.py	Parses raw multi-airport runway JSON, resamples observations, fills missing values, vectorizes wind direction, adds cyclic time features, and writes cleaned_data.csv.
generate_train_data.py	Creates sliding windows, performs chronological train/validation/test splits, aligns METAR variables, standardizes continuous exogenous features, creates graph metadata, and writes airport .npy files.
multi_airport_dataset.py	Loads multiple processed airports, pads runway dimensions, creates runway masks, and applies runtime Min-Max scaling.
create_global_weather_map.py	Remaps airport-specific weather IDs into a shared vocabulary. This script overwrites processed files and should only be run on a backup or reproducible copy.
preprocess_zbaa_sliding_window.py	Legacy ZBAA-specific direct JSON-to-window pipeline.
merge_runway_metar.py	Legacy merger with environment-specific hard-coded paths.

Example preprocessing commands

Install the processing dependencies in an isolated environment:

python -m pip install numpy pandas requests tqdm torch scikit-learn

Example for one airport and date range:

# 1. Download raw METAR reports.
python Dataset/download_multi.py \
  --station ZBAA \
  --start_date 2025-02-20 \
  --end_date 2025-11-30 \
  --output_dir Dataset/metar/raw/zbaa

# 2. Convert METAR reports to a one-minute exogenous time series.
python Dataset/preprocess_metar_multi.py \
  --data_dir Dataset/metar/raw/zbaa \
  --output_dir Dataset/metar/processed/zbaa_metar \
  --start_date 2025-02-20 \
  --end_date 2025-11-30

# 3. Convert raw runway/AWOS JSON to a cleaned one-minute CSV.
python Dataset/preprocess_runway_generic.py \
  --json_path Dataset/awos2025/ZBAA.json \
  --output_dir Dataset/airport/ZBAA \
  --airport ZBAA \
  --start_date 2025-02-20 \
  --end_date 2025-11-30

# 4. Create the model-ready NumPy dictionary.
python Dataset/generate_train_data.py \
  --airport ZBAA \
  --csv_path Dataset/airport/ZBAA/cleaned_data.csv \
  --output_dir Dataset/processed \
  --window_size 96 \
  --stride 1

Reproducibility note

The checked-in processing scripts document the processing logic, but generate_train_data.py and the legacy merger still contain paths from the original training environment for locating METAR files. Before regenerating the published artifacts on another machine, change those path constants or mirror the expected directory structure. The published .npy metadata (especially exo_scaler, window_size, and stride) is the authoritative record for the released files.

Intended use

AeroWF is intended for research on aerodrome meteorological representation learning, time-series forecasting, missing-value imputation, weather-condition classification, anomaly detection, and cross-airport adaptation. It is a research benchmark and is not a replacement for certified operational weather or aviation systems.