Datasets:

SHussain37
/

PRCA-Net-dataset

license: odbl
pretty_name: Ray-Traced Cross-Frequency Radio Map Dataset
tags:
  - radio-propagation
  - path-loss
  - radio-map
  - wireless-communications
  - ray-tracing
  - 6g
  - channel-modeling
size_categories:
  - 1K<n<10K
task_categories:
  - image-to-image
annotations_creators:
  - machine-generated
language: []
configs:
  - config_name: default
    data_files:
      - split: train
        path: splits/train.csv
      - split: validation
        path: splits/val.csv
      - split: test
        path: splits/test.csv

Ray-Traced Cross-Frequency Radio Map Dataset

A large ray-traced radio-map (path-loss) dataset for zero-shot cross-frequency generalization research, generated with Sionna RT over real urban geometry from OpenStreetMap.

150 urban scenes across 15 cities, 256×256 rasters
8 transmitters per scene across three deployment strata (street, rooftop, mast)
6 carrier frequencies: 1.8, 3.5, 7, 28 GHz (training) + 10, 60 GHz (held out, for interpolation / extrapolation studies)
7,200 path-loss maps (150 × 8 × 6), receiver fixed at 1.5 m
Frozen train/val/test split (124/13/13 scenes) for reproducible benchmarking
Isotropic antennas on both ends; per-scene building-height rasters included

Intended use

This dataset is designed to benchmark radio-map prediction models on carrier frequencies not seen during training — i.e. can a model trained at 1.8/3.5/7/28 GHz predict path loss at an interpolated (10 GHz) or extrapolated (60 GHz) band. It also supports standard (same-frequency) radio-map estimation, scene-generalization studies, and physics-informed learning research.

Quick start

from huggingface_hub import snapshot_download
root = snapshot_download(repo_id="SHussain37/PRCA-Net-dataset", repo_type="dataset")

from radiomap_dataset import RadioMapData   # loader.py from this repo
data = RadioMapData(root)

# frozen split, exactly as benchmarked
test_scenes = data.split("test")

# the held-out-frequency test set (interp. + extrap.)
idx = data.indices_for_split("test", freqs=[10000, 60000])   # MHz
item = data[idx[0]]
item["path_loss_db"]   # (256, 256) float32, dB
item["height_map"]     # (256, 256) float32, building height (m)

Directory layout

manifest.csv                 # one row per map: scene_id, tx_id, freq_mhz, rx_height_m, file
scene_split.csv              # frozen train/val/test partition (by scene_id)
splits/{train,val,test}.csv  # same split, flat per-map lists (for HF viewer)
scenes/
  S0001_nyc-midtown-01/
    meta.json                # tile size, raster resolution, tx metadata
    height_map.npy           # (256, 256) float32 building height, metres
  ...                        # 150 scene folders
maps/
  S0001_nyc-midtown-01/
    S0001_nyc-midtown-01__T01__f001800__h0015.npz   # key 'path_loss_db'
    ...                      # 48 maps per folder (8 Tx x 6 freq)
  ...

Filename convention

Each map file is named:

<scene_id>__T<NN>__f<FFFFFF>__h<HHHH>.npz

token	meaning	example
`<scene_id>`	scene / folder name	`S0001_nyc-midtown-01`
`T<NN>`	transmitter index (01–08)	`T01`
`f<FFFFFF>`	frequency in MHz, 6-digit padded	`f001800` = 1800 MHz, `f060000` = 60 GHz
`h<HHHH>`	rx height in decimetres	`h0015` = 1.5 m (constant)

Each .npz contains a single array under key path_loss_db: a (256, 256) float32 path-loss map in dB. The receiver height is 1.5 m for every map, so h0015 is constant throughout.

Frequencies

Band	Role	`freq_mhz`
1.8 GHz	training	1800
3.5 GHz	training	3500
7 GHz	training	7000
28 GHz	training	28000
10 GHz	held out (interp.)	10000
60 GHz	held out (extrap.)	60000

Benchmarking: reproducing the splits

To compare against results reported on this dataset, use the frozen split verbatim — do not re-partition. The split is defined by scene in scene_split.csv (124 train / 13 val / 13 test), so no scene ever appears in two splits. The splits/{train,val,test}.csv files list the same partition per-map (and power the dataset viewer above).

The recommended way is the provided loader, which resolves the split for you:

from huggingface_hub import snapshot_download
root = snapshot_download(repo_id="SHussain37/PRCA-Net-dataset",
                         repo_type="dataset")

from radiomap_dataset import RadioMapData        # radiomap_dataset/ ships in this repo
data = RadioMapData(root)

# --- the exact evaluation regimes ---
# training frequencies (1.8/3.5/7/28 GHz), unseen TEST scenes:
seen_freq   = data.indices_for_split("test", freqs=[1800, 3500, 7000, 28000])
# held-out frequencies, TEST scenes -- the cross-frequency benchmark:
interp_10   = data.indices_for_split("test", freqs=[10000])   # interpolation
extrap_60   = data.indices_for_split("test", freqs=[60000])   # extrapolation
heldout_all = data.indices_for_split("test", freqs=[10000, 60000])

for i in extrap_60[:1]:
    item = data[i]
    item["path_loss_db"]   # (256, 256) float32, dB  -- prediction target
    item["height_map"]     # (256, 256) float32, building height (m)
    item["scene_id"], item["tx_id"], item["freq_mhz"]

If you prefer not to use the loader, read scene_split.csv directly and filter your own dataframe by scene_id — the split membership is the only thing you must keep identical.

Reported evaluation protocol

For results comparable to the paper:

Metric: RMSE in dB, pooled over all valid (ray-reached, non-building) pixels — pool globally, do not average per-map RMSE (that biases the estimate).
Regimes: report per scene×frequency regime; separate held-out 10 GHz (interpolation) and 60 GHz (extrapolation), and also split LoS vs NLoS where relevant.
Validity mask: a pixel is valid if it is reached by the ray tracer and not inside a building. (The path_loss_db maps encode unreached/building pixels consistently; mask them out identically for every model.)

Generation

Maps were computed with Sionna RT 2.0.1's RadioMapSolver (3.2×10⁸ rays per transmitter, diffraction enabled). Transmitters and receivers are single isotropic antennas — no antenna directivity — so the maps reflect propagation (free-space spreading, diffraction, scattering, multipath) rather than antenna-pattern effects. Building geometry is from OpenStreetMap.

Reproducibility note. With diffraction enabled, Sionna RT's RadioMapSolver is not perfectly deterministic across runs even with a fixed seed (upstream behaviour). The released maps are fixed; this only affects users re-running the generation pipeline.

License

Data and code are under different licenses.

Data (maps, height maps, metadata): ODbL v1.0, because it derives from OpenStreetMap. Required attribution: "Contains information from OpenStreetMap, © OpenStreetMap contributors, ODbL."
Code (the radiomap_dataset loader and scripts): MIT.

Citation

@misc{radiomap_xfreq_2026,
  title        = {Ray-Traced Cross-Frequency Radio Map Dataset},
  author       = {[AUTHORS — fill in at public release]},
  year         = {2026},
  howpublished = {Hugging Face Hub},
  note         = {DOI: [generate at public release]},
  license      = {ODbL-1.0}
}

Please also cite the associated paper (see the repository for the current reference).