TYessine commited on
Commit
b86ec24
·
verified ·
1 Parent(s): 433b6b7

Upload README.md with huggingface_hub

Browse files
Files changed (1) hide show
  1. README.md +315 -3
README.md CHANGED
@@ -1,3 +1,315 @@
1
- ---
2
- license: cc-by-4.0
3
- ---
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ---
2
+ # Dataset card for the Hugging Face Hub (uploaded as README.md). Fill in every <...> before uploading.
3
+ license: cc-by-4.0
4
+ pretty_name: AIRWISE synthetic urban RF coverage maps (2.4 GHz, ground-to-drone)
5
+ task_categories:
6
+ - image-to-image
7
+ annotations_creators:
8
+ - machine-generated
9
+ source_datasets:
10
+ - original
11
+ tags:
12
+ - radio-propagation
13
+ - radio-map
14
+ - coverage-map
15
+ - path-gain
16
+ - pathloss
17
+ - ray-tracing
18
+ - sionna
19
+ - uav
20
+ - drone
21
+ - wireless
22
+ - synthetic
23
+ - out-of-distribution
24
+ size_categories:
25
+ - 1K<n<10K
26
+ viewer: false # the data is stored as NumPy .npz files, which the Hub viewer cannot display
27
+ ---
28
+
29
+ # AIRWISE synthetic urban RF coverage maps
30
+
31
+ Ray traced **path gain maps from a ground station to a drone** flying at a fixed altitude above synthetic
32
+ 128 m × 128 m city blocks, at **2.4 GHz**. Every map comes with the height map of its scene (ground + buildings),
33
+ the station position and the drone altitude, so it can be used to train and test models that predict a radio
34
+ coverage map from the city geometry (e.g. image-to-image neural networks), including on **unseen city layouts**
35
+ (out of distribution split).
36
+
37
+ The dataset was made for *Neural Prediction of RF Coverage Maps for Drone Missions*, a project of AIRWISE, a set
38
+ of student projects at Politecnico di Milano on simulating drone missions in urban and complex environments. Planning a drone mission
39
+ that keeps a radio link to the ground station needs a coverage map at every flight altitude; ray tracing gives
40
+ accurate maps but is slow and has to be rerun whenever the station or the scene changes. The project asks whether a
41
+ neural network trained on ray traced maps can replace it, and how much accuracy is lost for the speedup.
42
+
43
+ ![Top views of 4 scenes per family: building height (colour) and the 24 candidate ground stations](scenes_city/overview.png)
44
+
45
+ *Four scenes per family (rows). Colour: building height; dots: candidate ground stations (blue open, cyan street, red courtyard).*
46
+
47
+ ## At a glance
48
+
49
+ | | |
50
+ |---|---|
51
+ | Scenes | 540 procedurally generated city blocks, 128 m × 128 m, 6 layout families (3 seen in training, 3 unseen) |
52
+ | Maps | 6,480 path gain maps of 128 × 128 cells (1 m), 3 ground stations per scene × 4 drone altitudes |
53
+ | Input | surface height map (m) + station position (m) + drone altitude (m) |
54
+ | Target | path gain in dB, floored at -150 dB |
55
+ | Frequency | 2.4 GHz, isotropic vertically polarised antennas |
56
+ | Ray tracer | Sionna RT 2.2.0 (`RadioMapSolver`): line of sight, specular and diffuse reflections, diffraction |
57
+ | Format | NumPy `.npz`, one file per split, ~330 MB in total (compressed) |
58
+ | Code | https://github.com/YessineT/Neural-Prediction-of-RF-Coverage-Maps-for-Drone-Missions (`dataset-generation/`) |
59
+ | Authors | Yessine Turki, Mehdi Ben Mefteh, Sami El Azaar (Multidisciplinary Project, Politecnico di Milano) |
60
+ | Supervisors | Luca Barletta (Politecnico di Milano), Stefano Rini, Alessia Radicula, Arthur Garbuz |
61
+ | Contact | tu.yessine@gmail.com, or open an issue on the GitHub repository |
62
+ | Version | 1.0, 2026-11-04 |
63
+
64
+ ## Repository layout
65
+
66
+ ```
67
+ README.md this card
68
+ train.npz val.npz test.npz ood.npz the maps (one file per split)
69
+ settings.json the exact ray tracing settings used for every map
70
+ scenes_city/ the 3D scenes the maps were traced on (to reproduce or extend the dataset)
71
+ index.json every scene with its family and split
72
+ config.json all generator parameters and the seed
73
+ check_results.json result of every quality check, per scene
74
+ overview.png top views of a few scenes per family
75
+ <family>_<NNNN>/ one folder per scene, see "Scene files" below
76
+ ```
77
+
78
+ ## Data fields (`<split>.npz`)
79
+
80
+ Every split file holds the arrays below. All strings are stored as fixed width unicode, so the files load with
81
+ plain `np.load` (no `allow_pickle`). S = number of scenes in the split, N = number of maps (N = 12 S).
82
+
83
+ | array | shape | type | meaning |
84
+ |---|---|---|---|
85
+ | `heights` | (S, 128, 128) | float32 | surface height of every scene of the split (terrain + buildings), m |
86
+ | `scene_names` | (S,) | str | scene name, e.g. `blocks_0007` (folder in `scenes_city/`) |
87
+ | `scene_hash` | (S,) | str | SHA-1 of the scene's height map at tracing time |
88
+ | `scene_idx` | (N,) | int32 | index into `heights` / `scene_names` of every map |
89
+ | `station_pos` | (N, 3) | float32 | ground station (transmitter) position x, y, z, m |
90
+ | `altitude` | (N,) | float32 | height z of the map plane (drone altitude), m: 15, 30, 45 or 60 |
91
+ | `target_db` | (N, 128, 128) | float32 | path gain in dB, **-150 dB = no ray arrived** (weaker values are also clipped to -150) |
92
+ | `rt_time` | (N,) | float32 | ray tracing time of that map, s (RTX 4070 Laptop GPU, after an untimed warm-up) |
93
+
94
+ The height maps are stored once per scene; use `scene_idx` to pair each map with its scene. The maps of one scene
95
+ are stored station by station, each with the 4 altitudes in increasing order.
96
+
97
+ **Grid.** The scene is centred on (0, 0). Cell `[i, j]` (row i, column j) has its centre at
98
+ x = j − 63.5 m, y = i − 63.5 m, i.e. rows run along y and columns along x, and the maps line up exactly with the
99
+ height maps (checked). All heights, altitudes and station z values are absolute z coordinates, not heights above
100
+ the ground. The terrain is flat (z = 0) except in the `hilly` family (±2 to 5 m), where a station can have a
101
+ negative z.
102
+
103
+ **Path gain.** `target_db` is the path gain between two isotropic (0 dBi) antennas, so for a real link
104
+ received power (dBm) = transmit power (dBm) + antenna gains (dBi) + `target_db`.
105
+
106
+ **Validity mask.** A cell is valid only where a drone can be, i.e. where the map plane is above the surface:
107
+
108
+ ```python
109
+ valid = heights[scene_idx[k]] < altitude[k] - 0.5
110
+ ```
111
+
112
+ Cells inside buildings taller than the altitude are not valid and should be left out of the loss and the
113
+ evaluation (they may contain tiny numerical values, see "Quality checks").
114
+
115
+ ## Splits
116
+
117
+ | split | families | scenes | maps | file size |
118
+ |---|---|---|---|---|
119
+ | train | blocks, grid, downtown | 360 (120 per family) | 4,320 | 220 MB |
120
+ | val | blocks, grid, downtown | 45 (15 per family) | 540 | 27 MB |
121
+ | test | blocks, grid, downtown | 45 (15 per family) | 540 | 28 MB |
122
+ | ood | canyon, courtyard, hilly | 90 (30 per family) | 1,080 | 55 MB |
123
+
124
+ A scene belongs to exactly one split, so no geometry is shared between splits. Train, val and test come from the
125
+ same distribution (two sample Kolmogorov-Smirnov test on built fraction, tallest building and number of
126
+ buildings). The `ood` families are never seen in training and measure generalisation to new kinds of cities.
127
+ Use `val` for model selection and report `test` and `ood` separately.
128
+
129
+ **Layout families**
130
+ - `blocks`: scattered buildings of random size, orientation and height (boxes, L shapes, podium + tower)
131
+ - `grid`: rotated Manhattan style street grid, blocks cut into lots
132
+ - `downtown`: dense centre with tall buildings, lower towards the edges
133
+ - `canyon` (ood): long parallel buildings with narrow streets
134
+ - `courtyard` (ood): ring and U shaped buildings around courtyards
135
+ - `hilly` (ood): `blocks` on hilly terrain
136
+
137
+ Buildings are 6 to 55 m tall and at least 3 m apart; no roof is closer than 1 m to a drone altitude, so the
138
+ validity mask is unambiguous.
139
+
140
+ ## Statistics
141
+
142
+ Computed on the released files, over valid cells only.
143
+
144
+ | split | valid cells | valid cells without signal (-150 dB) | path gain where there is signal: 5th pct / median / max | `rt_time` median |
145
+ |---|---|---|---|---|
146
+ | train | 95.0 % | 2.0 % | -118.1 / -81.4 / -53.9 dB | 0.29 s |
147
+ | val | 94.8 % | 1.9 % | -117.7 / -81.1 / -54.0 dB | 0.29 s |
148
+ | test | 95.4 % | 2.0 % | -118.3 / -81.3 / -54.0 dB | 0.29 s |
149
+ | ood | 94.3 % | 3.4 % | -121.5 / -81.1 / -54.0 dB | 0.27 s |
150
+
151
+ The highest gain (about -54 dB) is the free space gain over the shortest station to drone distance (5 m). The
152
+ no-signal cells sit at -150 dB, about 70 dB below the median, so with a plain MSE on dB values these few cells
153
+ weigh a lot in the loss; consider treating them separately (e.g. clip the target to a higher floor, or add a
154
+ "signal / no signal" output).
155
+
156
+ ## How the maps were made
157
+
158
+ **Scenes.** `generate_city_scenes.py` builds each scene from a fixed seed (2026): it places the buildings of the
159
+ family's layout, writes closed meshes for Sionna, and computes the height map on the same 1 m grid as the radio
160
+ maps.
161
+
162
+ **Ground stations.** Each scene has 24 candidate stations, 1 to 10 m above the ground, at least 2 m from every wall,
163
+ 5 m from the border and 5 m from each other, and at least 5 m below the lowest drone altitude. Three of them are
164
+ chosen per scene at random (fixed seed); a station whose maps failed a quality check is replaced by another one.
165
+
166
+ **Ray tracing** (`settings.json` has the exact values):
167
+
168
+ | setting | value |
169
+ |---|---|
170
+ | frequency | 2.4 GHz |
171
+ | antennas | 1 isotropic, vertically polarised antenna at the station and at every map cell |
172
+ | rays per map | 1e8 |
173
+ | maximum interactions per path (`max_depth`) | 8 |
174
+ | line of sight, specular reflection | on |
175
+ | diffraction | on |
176
+ | diffuse reflection | on, scattering coefficient 0.3, Lambertian pattern |
177
+ | refraction (through walls) | off: the buildings are closed, hollow volumes without inner walls, so energy crossing a whole building would be far too strong |
178
+ | materials | ITU-R P.2040 "concrete" (buildings) and "medium dry ground" (ground), 0.2 m thick |
179
+
180
+ These settings were chosen in a convergence study on a sample of scenes: with 1e8 rays no line of sight cell is
181
+ missed, and shadowed cells differ from a 2e8 ray reference by about 0.6 dB (median). Raising `max_depth` from 8 to
182
+ 10 (tested with specular reflections only) leaves the gain unchanged where there is signal and switches 1.2 % of the
183
+ cells between signal and no signal. Diffraction and diffuse reflections each change shadowed cells by up to ~18 dB
184
+ (90th percentile) and are therefore included.
185
+
186
+ **Timing.** `rt_time` is the wall clock time of one `RadioMapSolver` call, including the transfer of the map to
187
+ the CPU, so it can serve as the baseline for a speed comparison with a learned model. It is about 0.29 s per map
188
+ on an RTX 4070 Laptop GPU (a few maps take longer, up to 1.6 s).
189
+
190
+ ## Quality checks
191
+
192
+ Every scene and every map was checked with `check_city_scenes.py` (results per scene in
193
+ `scenes_city/check_results.json`), among others:
194
+ - the meshes are closed, outward facing and exactly the buildings in `meta.json`; the ray traced mesh equals the
195
+ height map (vertical rays through every cell, horizontal rays along every row and column)
196
+ - the validity mask computed from the mesh equals the one computed from the height map
197
+ - the gain right above the station matches free space, never exceeds free space by more than 10 dB, and shadowed
198
+ cells receive clearly less than line of sight cells (exact line of sight from the mesh)
199
+ - the power inside buildings is at most 1e-4 of the map's power. Some maps contain a few very weak values inside
200
+ buildings (rays slipping numerically through mesh edges, typically 1e-8 of the map's power); those cells are
201
+ outside the validity mask
202
+ - the generator is reproducible: regenerating with the same seed gives identical files
203
+
204
+ Scenes that failed a check were not traced.
205
+
206
+ ## Scene files (`scenes_city/<scene>/`)
207
+
208
+ | file | content |
209
+ |---|---|
210
+ | `<scene>.xml` | Sionna / Mitsuba scene (load with `sionna.rt.load_scene`) |
211
+ | `meshes/ground.ply`, `meshes/buildings.ply` | binary PLY meshes, one closed mesh per building |
212
+ | `height_map.npz` | `x`, `y` (cell centres), `terrain`, `surface` and `occupancy` (share of the cell covered by buildings), 128 × 128 |
213
+ | `sources.npz` | the 24 candidate stations: `positions`, `height_agl`, `ground_z`, `wall_distance`, `station_class` (0 open, 1 street, 2 courtyard) |
214
+ | `meta.json` | family, statistics and the exact geometry of every building |
215
+
216
+ ## Usage
217
+
218
+ One map:
219
+
220
+ ```python
221
+ import numpy as np
222
+ from huggingface_hub import hf_hub_download
223
+
224
+ f = hf_hub_download("TYessine/airwise-rf-coverage-maps", "train.npz", repo_type="dataset")
225
+ d = np.load(f)
226
+ k = 0 # one map
227
+ height = d["heights"][d["scene_idx"][k]] # input, 128 x 128, m
228
+ target = d["target_db"][k] # output, 128 x 128, dB
229
+ valid = height < d["altitude"][k] - 0.5 # cells to use in the loss
230
+ ```
231
+
232
+ A PyTorch dataset (the whole `train` split takes about 0.3 GB of memory):
233
+
234
+ ```python
235
+ import numpy as np
236
+ import torch
237
+
238
+ class CoverageMaps(torch.utils.data.Dataset):
239
+ def __init__(self, path):
240
+ with np.load(path) as d:
241
+ self.heights = torch.from_numpy(d["heights"])
242
+ self.idx = torch.from_numpy(d["scene_idx"]).long()
243
+ self.station = torch.from_numpy(d["station_pos"])
244
+ self.alt = torch.from_numpy(d["altitude"])
245
+ self.target = torch.from_numpy(d["target_db"])
246
+
247
+ def __len__(self):
248
+ return len(self.target)
249
+
250
+ def __getitem__(self, k):
251
+ h = self.heights[self.idx[k]]
252
+ valid = h < self.alt[k] - 0.5
253
+ return dict(height=h, station=self.station[k], altitude=self.alt[k],
254
+ target=self.target[k], valid=valid)
255
+ ```
256
+
257
+ How the station and the altitude are given to the model (extra input channels, distance map, conditioning
258
+ vector, ...) is left to the user.
259
+
260
+ **Suggested metrics.** RMSE in dB over the valid cells of every map, reported for `test` and `ood` separately
261
+ (and, if useful, per family and per altitude). Since a mission planner mostly needs to know where the link holds,
262
+ also report the error near the boundary between covered and uncovered cells (for a chosen sensitivity threshold),
263
+ and the prediction time per map next to `rt_time`.
264
+
265
+ To reproduce or extend the dataset (other stations, altitudes or settings), download `scenes_city/` and run
266
+ `make_dataset.py` from the code repository.
267
+
268
+ ## Intended uses
269
+
270
+ - Training and benchmarking fast surrogate models of ray tracing (radio map prediction from the city geometry)
271
+ - Studying generalisation to unseen city layouts (`ood` split)
272
+ - Planning drone links or ground station positions in research settings
273
+
274
+ **Out of scope.** The maps are not a substitute for measurements or a site survey of a real city, and should not
275
+ be used as the only basis for safety critical drone operations.
276
+
277
+ ## Limitations
278
+
279
+ - The cities are synthetic: box shaped buildings of a single material, no windows, vegetation, vehicles or
280
+ street furniture.
281
+ - The maps are simulated, not measured. Diffuse scattering uses a single scattering coefficient (0.3, a typical
282
+ value for building facades) that was not fitted to measurements.
283
+ - The maps give the average path gain of the ray traced paths; fast fading is not modelled.
284
+ - One frequency (2.4 GHz), one antenna type (isotropic, vertical polarisation), four fixed altitudes and a
285
+ 128 m × 128 m area; models trained on it will not transfer directly to other settings.
286
+ - `rt_time` depends on the GPU (RTX 4070 Laptop) and the Sionna version; compare it only with timings on the same
287
+ hardware.
288
+
289
+ ## License
290
+
291
+ [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). The scenes and maps were generated with Sionna RT (Apache 2.0); the ITU material
292
+ parameters come from ITU-R P.2040.
293
+
294
+ ## Citation
295
+
296
+ ```bibtex
297
+ @misc{turki2026airwise,
298
+ title = {AIRWISE synthetic urban RF coverage maps},
299
+ author = {Turki, Yessine and Ben Mefteh, Mehdi and El Azaar, Sami},
300
+ year = {2026},
301
+ howpublished = {\url{https://huggingface.co/datasets/TYessine/airwise-rf-coverage-maps}}
302
+ }
303
+ ```
304
+
305
+ Please also cite Sionna RT, which was used to compute the maps:
306
+
307
+ ```bibtex
308
+ @article{sionna-rt,
309
+ title = {Sionna RT: Differentiable Ray Tracing for Radio Propagation Modeling},
310
+ author = {Hoydis, Jakob and Ait Aoudia, Fay{\c{c}}al and Cammerer, Sebastian and Nimier-David, Merlin and
311
+ Binder, Nikolaus and Marcus, Guillermo and Keller, Alexander},
312
+ journal = {arXiv preprint arXiv:2303.11103},
313
+ year = {2023}
314
+ }
315
+ ```