--- pretty_name: Channels4World license: cc-by-4.0 language: - en tags: - wireless - ray-tracing - sionna - channel-modeling - radio-propagation - synthetic size_categories: - 100K How the files connect ![How the geometry, positions, core and detail files connect, with illustrative values](docs/files.png) *Illustrative values: link 0 is UE 2 and owns paths 0–1; link 1 is UE 9 and owns path 2.* - **One frame:** geometry, positions and interaction vertices share scene coordinates in metres. - **BS:** the number in a file name (`bs00000`) is its row in `bs_positions`. - **UE:** each value of `link_ue_index` is a row in `ue_positions`. A UE that isn't listed has no retained link to this BS (not a zero-power channel). - **Paths:** link ℓ owns paths `link_path_offsets[ℓ]` to `link_path_offsets[ℓ+1]` (end excluded). - **Interactions:** detail lists paths in core's order; path *p* owns interactions `path_interaction_offsets[p]` to `[p+1]`.
Arrays in each file *L* links, *P* paths and *I* interactions vary per record. For example, BS 0 of `urban_scene_019234` at 3.5 GHz has *L* = 15,873 retained links and *P* = 214,443 paths. **geometry** · `geometry.zip`: `scene.json` names the entry XML, which references OBJ meshes in metres. **positions** · `positions.npz` | Array | Shape | Type | Meaning | |---|---|---|---| | `bs_positions` | 32 × 3 | float32 | BS coordinates, m | | `ue_positions` | 16,384 × 3 | float32 | UE coordinates, m | **core** · `band_hz=/component=core/bs.npz` | Array | Shape | Type | Meaning | |---|---|---|---| | `link_ue_index` | *L* | int32 | UE ID of each link, ascending | | `link_path_offsets` | *L* + 1 | int64 | Where each link's paths start and end | | `a_real`, `a_imag` | *P* | float32 | Complex path gain | | `tau` | *P* | float32 | Delay, s | | `theta_t`, `phi_t` | *P* | float32 | Departure angles at the BS, rad | | `theta_r`, `phi_r` | *P* | float32 | Arrival angles at the UE, rad | | `interaction_count` | *P* | uint8 | Number of interactions | | `interaction_flags` | *P* | uint16 | Interaction types present, one bit per type | | `path_rank` | *P* | uint8 | 0-based position within its link, by decreasing float32 power | **detail** · same name under `component=detail` | Array | Shape | Type | Meaning | |---|---|---|---| | `path_interaction_offsets` | *P* + 1 | int64 | Where each path's interactions start and end | | `interaction_type` | *I* | int8 | 1 specular reflection, 8 diffraction (2 diffuse reflection and 4 refraction are defined but not modeled) | | `interaction_rank` | *I* | uint8 | 0-based position along the path | | `interaction_vertex` | *I* × 3 | float32 | Location, m |
## Organization Every scene belongs to one **split** (train or test) and one **profile** (urban, metropolitan or suburban). Scenes are offered in nested **tiers**, so a larger tier keeps every scene of the smaller ones. Every tier is 90% train and 10% test, and within each split 50% urban, 25% metropolitan and 25% suburban. | Tier | Train urban | Train metropolitan | Train suburban | Test urban | Test metropolitan | Test suburban | Total | |---|---:|---:|---:|---:|---:|---:|---:| | Tiny | 90 | 45 | 45 | 10 | 5 | 5 | 200 | | Small | 450 | 225 | 225 | 50 | 25 | 25 | 1,000 | | Medium | 4,500 | 2,250 | 2,250 | 500 | 250 | 250 | 10,000 | | Large | 22,500 | 11,250 | 11,250 | 2,500 | 1,250 | 1,250 | 50,000 | | Full | 45,000 | 22,500 | 22,500 | 5,000 | 2,500 | 2,500 | 100,000 | - A scene is in exactly one split. Both carriers and all four components of a scene share it. - There is no validation split. Hold out training scenes by scene, not by link or UE. - In the catalog, `tier` is the **smallest** tier that contains a scene. Medium is therefore `tier in {"tiny", "small", "medium"}`. | Tier | Core | Detail | Geometry + positions | Total | |---|---:|---:|---:|---:| | Tiny | 38.9 GB | 26.7 GB | 41 MB | 65.6 GB | | Small | 194 GB | 133 GB | 207 MB | 327 GB | | Medium | 1.93 TB | 1.32 TB | 2.07 GB | 3.26 TB | | Large | 9.66 TB | 1.32 TB (Medium only) | 10.3 GB | 10.99 TB | | Full | 19.32 TB | 1.32 TB (Medium only) | 20.7 GB | 20.66 TB | *Sizes cover both carriers (GB = 10⁹ bytes, TB = 10¹² bytes); catalogs and group metadata add under 0.2%. Tiny is published as loose files (65.7 GB with its metadata), and its scenes are also part of Small.* The 29.14 TB reported in the paper reflects an earlier compression and packaging format. The release has since been repackaged to make the data easier to download and use. Tiers choose scenes; components and carriers are chosen separately. Tiny needs no unpacking. ## Download Try one scene from Tiny to get loose files without unpacking. For Small or larger, download TAR archives and use the catalog to select scenes, carriers and components. Each example below leaves files under `c4w/`. Commands use the release tag `v1.0.0`; the `hf` command comes with `huggingface_hub` (`pip install huggingface_hub`). The [download helper](https://cbchae.yonsei.ac.kr/channels4world/download.html) (also a [Space](https://huggingface.co/spaces/Intelligence-Networking-Lab/channels4world-download)) sizes any tier, split, profile, carrier and component choice and writes these commands for it.
Try one Tiny scene — 26 MB, 16 files Download base station 0 of one scene (**26.0 MB** in 16 files, including the metadata the library needs): ```bash hf download Intelligence-Networking-Lab/Channels4World --repo-type dataset \ --revision v1.0.0 --local-dir c4w \ --include 'tiny/c4w-root.json' --include 'tiny/c4w-root/*' --include 'tiny/schema/*' \ --include 'tiny/groups/test-urban-g00000/catalog/members.parquet' \ --include 'tiny/groups/test-urban-g00000/snapshot.json' \ --include 'tiny/records/scene=urban_scene_019234/positions.npz' \ --include 'tiny/records/scene=urban_scene_019234/geometry.zip' \ --include 'tiny/records/scene=urban_scene_019234/band_hz=*/component=*/bs00000.npz' ``` For NumPy alone, the last three `--include` patterns are enough (15.2 MB). For all 32 BSs of the scene, replace them with `--include 'tiny/records/scene=urban_scene_019234/*'` (418.0 MB with the metadata). For all of Tiny, use `--include 'tiny/*'` (65.7 GB). For another Tiny scene, take its `group` from the `tiny_scenes` catalog. The three scenes shown on the project website, `urban_scene_019234`, `metro_scene_054046` and `suburban_scene_096016`, are Tiny test scenes. Then [read the data](#read-the-data) below.
Download a tier Install the optional library with `pip install channels4world` (Python ≥3.11). Download the release catalog, then select Small, positions and core at 3.5 GHz: ```bash hf download Intelligence-Networking-Lab/Channels4World --repo-type dataset \ --revision v1.0.0 --local-dir c4w \ --include 'c4w-root.json' --include 'c4w-root/*' ``` ```python import channels4world as c4w from huggingface_hub import snapshot_download ds = c4w.open("c4w") selection = ds.select(tier="small", frequencies_hz=[3_500_000_000], components=("positions", "core")) report = selection.missing() print(report) # planned files and total size if report.files: snapshot_download( "Intelligence-Networking-Lab/Channels4World", repo_type="dataset", revision="v1.0.0", local_dir=report.local_dir, allow_patterns=report.repo_files, ) assert selection.missing().complete ``` `select()` also takes `split=` and `profile=` (catalog spelling: `urban`, `metropolitan`, `suburban`). Each archive holds one group: 25 scenes of one split and profile, from one tier, with all 32 BSs. Tier, split and profile selections therefore download exactly their scenes; a list of scene IDs downloads the whole groups that contain them. `selection.to_recipe()` saves a selection as a small JSON recipe that others can replay with `ds.select_recipe(...)` or `c4w missing c4w --recipe FILE`; the download helper writes the same recipes. The [library guide](docs/library-guide.md) covers larger download plans, subsets and caching; [without the library](docs/without-library.md) covers glob downloads and ordinary TAR extraction.
Select scenes and components With the release catalog from the tier example local, choose exact scene IDs and the components you need. The catalog finds the containing archives: ```python import channels4world as c4w from huggingface_hub import snapshot_download ds = c4w.open("c4w") selection = ds.select(scene_ids=["urban_scene_019234"], frequencies_hz=[3_500_000_000], components=("positions", "core")) report = selection.missing() print(report) if report.files: snapshot_download( "Intelligence-Networking-Lab/Channels4World", repo_type="dataset", revision="v1.0.0", local_dir=report.local_dir, allow_patterns=report.repo_files, ) assert selection.missing().complete ```
HF Datasets can also [stream archives](#streaming-archives) without downloading the entire selection first. ## Read the data We recommend the `channels4world` library for selection, verification and repeated reads; standard NumPy works directly with loose files. Both examples read the same link, BS 0 → UE 14 of `urban_scene_019234` at 3.5 GHz: its delays, complex gains and BS–UE distance. Change the IDs at the top to read any other link you have downloaded.
Read with the library ```python from pathlib import Path import numpy as np import channels4world as c4w TINY_ROOT = Path("c4w/tiny") SCENE_ID, CARRIER_HZ, BS_ID, UE_ID = "urban_scene_019234", 3_500_000_000, 0, 14 ds = c4w.open(TINY_ROOT) scene = ds.scene(SCENE_ID) record = scene.frequencies[CARRIER_HZ].base_stations[BS_ID].read() positions = scene.read_positions() link = record.get_link(UE_ID) # None when this UE has no retained link to this BS print(link.n_paths, link.core["tau"]) # 16 retained paths, delays in s print(link.core["a_real"] + 1j * link.core["a_imag"]) print(np.linalg.norm(positions.ue[UE_ID] - positions.bs[BS_ID])) ``` The library's arrays keep the stored dtypes and are read-only. For downloaded TARs, open the release root (`c4w/`) and iterate your selection directly; extraction is optional. See [iteration and extraction](docs/library-guide.md#iterate-extract-or-cache).
Read loose files with NumPy The same code works after ordinary TAR extraction: change `TINY_ROOT` to the extracted folder. ```python from pathlib import Path import numpy as np TINY_ROOT = Path("c4w/tiny") SCENE_ID, CARRIER_HZ, BS_ID, UE_ID = "urban_scene_019234", 3_500_000_000, 0, 14 scene_dir = TINY_ROOT / "records" / f"scene={SCENE_ID}" core_path = scene_dir / f"band_hz={CARRIER_HZ}" / "component=core" / f"bs{BS_ID:05d}.npz" with np.load(core_path, allow_pickle=False) as core, np.load( scene_dir / "positions.npz", allow_pickle=False ) as positions: ue_ids = core["link_ue_index"] # retained UE IDs, ascending row = int(np.searchsorted(ue_ids, UE_ID)) # this UE's link row assert row < ue_ids.size and ue_ids[row] == UE_ID, "No retained link to this UE." start, stop = map(int, core["link_path_offsets"][row:row + 2]) print(stop - start, core["tau"][start:stop]) print(core["a_real"][start:stop] + 1j * core["a_imag"][start:stop]) print(np.linalg.norm(positions["ue_positions"][UE_ID] - positions["bs_positions"][BS_ID])) ``` NumPy preserves the NPZ's stored dtypes and shapes. `UE_ID` indexes positions; `row` indexes retained links. Keep that mapping when filtering. Ordinary TAR extraction writes these payload paths; library extraction also creates a navigable subset root.
Pad paths to fixed-size arrays Each link has at most 16 paths, so any per-path array becomes an `(L, 16)` array plus a mask. Row *i* belongs to UE `link_ue_index[i]`: ```python import numpy as np def pad_paths(core, name, max_paths=16): """Per-path array -> (links, max_paths) array and a mask of stored paths.""" offsets = np.asarray(core["link_path_offsets"]) values = np.asarray(core[name]) counts = np.diff(offsets) # paths per link rows = np.repeat(np.arange(counts.size), counts) cols = np.arange(offsets[-1]) - np.repeat(offsets[:-1], counts) padded = np.zeros((counts.size, max_paths), values.dtype) padded[rows, cols] = values mask = np.arange(max_paths) < counts[:, None] return padded, mask with np.load(core_path, allow_pickle=False) as core: # core_path from the example above tau, mask = pad_paths(core, "tau") # (L, 16) float32, (L, 16) bool gain = pad_paths(core, "a_real")[0] + 1j * pad_paths(core, "a_imag")[0] ue_ids = core["link_ue_index"] # (L,) row i <-> UE ue_ids[i] ``` Padded entries are zero; use the mask, not the value, to tell them apart. The same works on library records and on HF Datasets rows after [restoring their shapes](docs/hf-datasets.md#decoding-and-array-representation). The library has the same function, with a per-path version for interactions: `from channels4world.transforms import pad_paths, pad_interactions`.
### Streaming archives Stream remote TARs on demand, or iterate the same TARs saved locally without a network read. Each HF Datasets example is one BS record, not one UE or a joined scene. Archives stream in order: to reach one record, stream only the group archive that holds it.
Stream archives with 🤗 Datasets ```python import numpy as np from datasets import load_dataset SCENE_ID, BS_ID, UE_ID = "urban_scene_019234", 0, 14 archive = ("hf://datasets/Intelligence-Networking-Lab/Channels4World@v1.0.0/payload/" "3.5ghz/core/inc1-small/test-urban-g00000-3.5ghz-core.tar") # this scene's group # For a downloaded copy: archive = "c4w/payload/3.5ghz/core/inc1-small/test-urban-g00000-3.5ghz-core.tar" member = f"records/scene={SCENE_ID}/band_hz=3500000000/component=core/bs{BS_ID:05d}" core = load_dataset("webdataset", streaming=True, data_files={"test": archive})["test"] record = next(r for r in core.with_format("numpy") if r["__key__"] == member) arrays = record["npz"] # HF has already decoded the NPZ row = int(np.searchsorted(arrays["link_ue_index"], UE_ID)) start, stop = map(int, arrays["link_path_offsets"][row:row + 2]) print(arrays["tau"][start:stop]) # UE 14's delays (s) ``` The group comes from the `scenes` catalog. Streaming reads the archive from its start, so the members before this record are read too (at most one group's archive). `streaming=True` iterates on demand; without it, HF Datasets downloads the archives and builds an Arrow dataset on disk, from remote or local input. HF formatting can change dtypes. See the [HF guide](docs/hf-datasets.md) for explicit features, shape and dtype restoration, and joining positions. To read one record without the rest of its archive, use a byte-range read ([file guide](docs/without-library.md#find-the-byte-location-of-one-record)). Tiny stays loose.
## Tutorials Each tutorial is a page and a notebook that runs top to bottom. The two reading tutorials follow the same link, BS 0 → UE 14 of `urban_scene_019234`. | Tutorial | Reads with | Covers | |---|---|---| | [Read one scene](docs/tutorial-library.md) ([notebook](docs/notebooks/01-read-one-scene-library.ipynb)) | the library | catalog → scene → carrier → BS → UE link → paths; geometry and positions; the stored arrays; the same link at 7 GHz | | [Read one scene without the library](docs/tutorial-numpy.md) ([notebook](docs/notebooks/02-read-one-scene-numpy.ipynb)) | NumPy | the same steps on the loose files | | [From channel records to a DataLoader](docs/ml-guide.md) ([notebook](docs/notebooks/03-dataloader.ipynb)) | the library, PyTorch | link samples, train/validation/test by scene, padded arrays, preprocessing, a cache and batches | ## Files and catalogs The catalogs list scenes and files so you can choose downloads and locate records; metadata supplies their identities and checksums. The dataset viewer shows three catalog configs: `scenes` (default; one row per scene), `files` (every archive, group metadata and schema file with its size and SHA-256; the root catalog files and this card are not listed) and `tiny_scenes` (Tiny's 200 scenes). Their split is named `catalog`; it is not the train/test split, which is the `split` column. The viewer shows catalog rows, not channel arrays. The [file guide](docs/without-library.md) explains how to use them.
File reference | Path | What it is | |---|---| | `c4w-root.json`, `c4w-root/` | Release catalog: every scene (split, profile, tier, group) and every archive, metadata and schema file (path, size, checksum) | | `groups//` | Group metadata: where each record sits inside the archives, and its identity and checksums | | `schema/` | Interpretation documents (units, conventions, interaction codes) | ```text c4w-root.json, c4w-root/ release catalog schema/, groups/ interpretation documents, group metadata payload/ TAR archives (paths below) tiny/ Tiny: its own catalog, schema/, groups/ and records/scene=/ loose files per scene: geometry.zip, positions.npz band_hz=<3500000000|7000000000>/component=/bs00000.npz … bs00031.npz ``` Archive path templates: ```text payload/scene//inc-/-.tar payload/<3.5ghz|7ghz>//inc-/--.tar ``` - **Groups** are named `--g`, with profile code `urban`, `metro` or `suburban` (the catalog spells `metro` as `metropolitan`). Each holds exactly 25 scenes. - **Increments** are `inc1-small`, `inc2-medium`, `inc3-large` and `inc4-full`. A tier is its own increment plus all smaller ones, so in every component folder Small is `inc1-*`, Medium `inc[1-2]-*`, Large `inc[1-3]-*` and Full `inc*`. - **Detail** is hosted in `inc1-small` and `inc2-medium` only.
Query the catalogs ```python from datasets import load_dataset REPO, REV = "Intelligence-Networking-Lab/Channels4World", "v1.0.0" scenes = load_dataset(REPO, "scenes", split="catalog", revision=REV) files = load_dataset(REPO, "files", split="catalog", revision=REV) print(scenes.filter(lambda row: row["split"] == "test")[:3]) print(files.filter(lambda row: row["kind"] == "payload")[:3]) ```
## License and citation Channels4World: [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). If you share or adapt it, credit **Joonkyu Jang**, link the license and indicate changes. channels4world library: [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0). If Channels4World is useful in your research, please cite the dataset paper: > J. Jang, H.-J. Moon, K. S. Kim, S.-L. Kim, J. Hoydis, R. W. Heath Jr. and C.-B. Chae, > "Channels4World: An Environment-Scale Dataset for Wireless Foundation Models," > submitted to *IEEE Transactions on Communications*. The arXiv preprint and a BibTeX entry will be added here when the preprint is available. | Item | Version | |---|---| | Channels4World release | 1.0.0: tag `v1.0.0` (the tag pins the exact repository commit) | | Collection ID | `channels4world-v1-20260714`, in every record header; it names the generated collection, while `1.0.0` names this release | | Library | `channels4world` 1.0.0, Python ≥3.11 | | Catalog format | `channels4world.root` version 1 |