README.md

---
pretty_name: Channels4World
license: cc-by-4.0
language:
  - en
tags:
  - wireless
  - ray-tracing
  - sionna
  - channel-modeling
  - radio-propagation
  - synthetic
size_categories:
  - 100K<n<1M
configs:
  - config_name: scenes
    default: true
    data_files:
      - split: catalog
        path: c4w-root/scenes.parquet
  - config_name: files
    data_files:
      - split: catalog
        path: c4w-root/files.parquet
  - config_name: tiny_scenes
    data_files:
      - split: catalog
        path: tiny/c4w-root/scenes.parquet
---

# Channels4World

**An environment-scale foundation for wireless AI.** Channels4World is a ray-traced
wireless channel dataset for learning across many environments, from wireless foundation
models to channel prediction and localization: **100,000 synthetic outdoor scenes**, each
with **32 base stations (BSs) and 16,384 UE positions**, simulated at **3.5 and 7 GHz** with
Sionna RT. Scenes come from three generation profiles (urban, metropolitan and suburban).
Train and test are split by scene, and nested tiers from 200 to 100,000 scenes let you scale
the number of environments separately from the data in each.

**Get data:** [Choose a subset and get download commands](https://cbchae.yonsei.ac.kr/channels4world/download.html) ([Space](https://huggingface.co/spaces/Intelligence-Networking-Lab/channels4world-download)) ·
[26 MB starter: one Tiny scene](#download)

![Example scenes across the urban, metropolitan and suburban profiles](docs/scenes.png)

*Example scenes from the three profiles. Building colours show material classes.*

| Release 1.0.0 | Coverage |
|---|---|
| Geometry and positions | All 100,000 scenes |
| Core channels | All 100,000 scenes, both carriers |
| Detail (interactions) | The 10,000 Medium-tier scenes, both carriers |
| Total | About **20.8 TB**: the Full tier, the loose Tiny copy and metadata |

**Access:** Geometry, positions and core channels for all 100,000 scenes are hosted on Hugging Face. Interaction detail exists for the full corpus; Hugging Face currently hosts the 10,000 Medium-tier scenes, including Tiny and Small. Interaction detail for the remaining scenes is currently unavailable for direct download. [Contact the project lead](https://cbchae.yonsei.ac.kr/channels4world/#contact) about access.

Start with plain NumPy, use the `channels4world` library to select larger subsets, or
read the TAR archives with 🤗 Datasets. Numeric records are standard NPZ files;
geometry is ZIP. Every example follows one link: BS 0 and UE 14 of `urban_scene_019234`
at 3.5 GHz, the link the project website shows.

[Project website](https://cbchae.yonsei.ac.kr/channels4world/) ·
[Library source on GitHub](https://github.com/JoonkyuJang/channels4world) ·
[Paper (submitted; arXiv preprint pending)](#license-and-citation) ·
[Tutorials](#tutorials) ·
[Schema reference](docs/schema-reference.md) ·
[Library guide](docs/library-guide.md) ·
[Without the library](docs/without-library.md)

## Contents

Each scene is divided into four **components**, which you can download separately.

![A scene, one channel record and four paths from urban_scene_019234](docs/overview.png)

*`urban_scene_019234` at 3.5 GHz, top view (heights not shown). UE positions are a sample
of the 16,384. Each path segment takes the colour of the interaction it leaves.*

| Component | What it holds | One file per | Files per scene |
|---|---|---|---|
| **geometry** | The 3-D scene: Mitsuba XML and OBJ meshes | scene | 1 |
| **positions** | Coordinates of the 32 BSs and 16,384 UEs | scene | 1 |
| **core** | Every retained path from one BS to each UE it reaches: gain, delay, angles, interaction count and type flags | scene × carrier × BS | 64 |
| **detail** | Each path's interactions in order: type and location | scene × carrier × BS | 64 |

Geometry and positions are shared by both carriers; core and detail are frequency-specific.
Most channel work needs only positions and core.

**What a record keeps.** Each link keeps at most the 16 strongest paths whose power exceeds
−150 dB, ordered by decreasing power (computed in float32). Paths combine line of sight, specular reflection and
diffraction, with up to four interactions per path; diffuse reflection and refraction are
not modeled. A UE with no stored link to a BS has no retained path to it; that is not a
zero-power channel. The scenes are synthetic and the channels are simulated, not measured;
the paper describes how they were generated.

Gains are the passband coefficients without the carrier-delay phase, relative to unit
power. Angles: zenith from +z, azimuth from +x toward +y. Each BS and UE has one isotropic,
vertically polarized antenna, already included in the gains. Details: [schema reference](docs/schema-reference.md).

<details>
<summary><b>How the files connect</b></summary>

![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]`.

</details>

<details>
<summary><b>Arrays in each file</b></summary>

*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=<Hz>/component=core/bs<NNNNN>.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 |

</details>

## 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.

<details open>
<summary><b>Try one Tiny scene — 26 MB, 16 files</b></summary>

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.

</details>

<details>
<summary><b>Download a tier</b></summary>

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.

</details>

<details>
<summary><b>Select scenes and components</b></summary>

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

</details>

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.

<details>
<summary><b>Read with the library</b></summary>

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

</details>

<details>
<summary><b>Read loose files with NumPy</b></summary>

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.

</details>

<details>
<summary><b>Pad paths to fixed-size arrays</b></summary>

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

</details>

### 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.

<details>
<summary><b>Stream archives with 🤗 Datasets</b></summary>

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

</details>

## 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.

<details>
<summary><b>File reference</b></summary>

| 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>/` | 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=<id>/               loose files per scene:
    geometry.zip, positions.npz
    band_hz=<3500000000|7000000000>/component=<core|detail>/bs00000.npz … bs00031.npz
```

Archive path templates:

```text
payload/scene/<geometry|positions>/inc<N>-<tier>/<group>-<component>.tar
payload/<3.5ghz|7ghz>/<core|detail>/inc<N>-<tier>/<group>-<band>-<component>.tar
```

- **Groups** are named `<split>-<profile code>-g<NNNNN>`, 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.

</details>

<details>
<summary><b>Query the catalogs</b></summary>

```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])
```

</details>

## 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 |