Upload README.md with huggingface_hub

README.md

@@ -1,3 +1,218 @@
 ---
 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).