README.md

---
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](https://nvlabs.github.io/sionna/) 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

```python
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:

```python
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

```bibtex
@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).

## Acknowledgements

Building geometry © OpenStreetMap contributors (ODbL). Ray tracing with
NVIDIA Sionna RT (Apache-2.0).