TAR records with HF Datasets
HF Datasets can read the existing TAR member names with its webdataset loader. The
examples need pip install datasets; hf:// paths are read through huggingface_hub,
which datasets installs.
Each core/detail NPZ is one scene × carrier × BS record; each positions NPZ is one
scene record. These are ragged records, not preassembled UE training samples.
Choose and join components before defining samples or batching them.
The card shows a short remote/local iteration example.
streaming=True returns an iterable; omitting it downloads remote input as needed and
builds an Arrow dataset on disk, even when the TARs are already local. Neither route
extracts a subset root for the channels4world library. Tiny can remain loose throughout.
Decoding and array representation
HF's loader already decodes record["npz"]; do not pass that mapping to np.load.
Its feature inference and NumPy formatting are separate steps: integer widths can
change, and empty arrays need their declared dimensions restored. Direct NumPy NPZ
reads and the channels4world library retain the stored numeric dtypes and shapes; HF's formatted
rows do not promise that representation unchanged.
The explicit features and restoration below follow the release's array schema
(schema/arrays.json, summarized in the schema reference). The
shape comes from each NPZ's embedded JSON __meta__.
import json
import numpy as np
from datasets import Array2D, Features, Sequence, Value, load_dataset
SCHEMAS = {
"core": {
"link_ue_index": ("int32", ("links",)),
"link_path_offsets": ("int64", ("links+1",)),
"path_rank": ("uint8", ("paths",)),
"a_real": ("float32", ("paths",)), "a_imag": ("float32", ("paths",)),
"tau": ("float32", ("paths",)),
"theta_t": ("float32", ("paths",)), "phi_t": ("float32", ("paths",)),
"theta_r": ("float32", ("paths",)), "phi_r": ("float32", ("paths",)),
"interaction_count": ("uint8", ("paths",)),
"interaction_flags": ("uint16", ("paths",)),
},
"detail": {
"path_interaction_offsets": ("int64", ("paths+1",)),
"interaction_rank": ("uint8", ("interactions",)),
"interaction_type": ("int8", ("interactions",)),
"interaction_vertex": ("float32", ("interactions", 3)),
},
"positions": {
"bs_positions": ("float32", ("bs", 3)),
"ue_positions": ("float32", ("ues", 3)),
},
}
def features_for(component):
fields = {"__meta__": Value("string")}
for name, (dtype, axes) in SCHEMAS[component].items():
fields[name] = (Array2D(shape=(None, 3), dtype=dtype) if len(axes) == 2
else Sequence(Value(dtype)))
return Features({"__key__": Value("string"), "__url__": Value("string"), "npz": fields})
def restore_npz(record):
raw = record["npz"]
meta = json.loads(str(raw["__meta__"]))
def size(axis):
if isinstance(axis, int):
return axis
name, _, extra = axis.partition("+")
return meta["dimensions"][name] + (int(extra) if extra else 0)
arrays = {
name: np.asarray(raw[name], dtype=dtype).reshape(tuple(size(a) for a in axes))
for name, (dtype, axes) in SCHEMAS[meta["identity"]["component"]].items()
}
return meta, arrays
For example, zero interactions restore interaction_vertex to (0, 3) rather than
an ambiguous empty vector. Core and detail offsets still have their final sentinel:
an empty core has link_path_offsets.shape == (1,).
One chosen link, with remote or local TARs
Stream only the archives of the group that holds the chosen scene (the group column of
the scenes catalog), then pick records by identity:
SCENE_ID, BS_ID, UE_ID = "urban_scene_019234", 0, 14
GROUP = "test-urban-g00000" # from the scenes catalog
base = "hf://datasets/Intelligence-Networking-Lab/Channels4World@v1.0.0/payload"
# For downloaded copies: base = "c4w/payload"
def records(component):
archive = (f"{base}/3.5ghz/core/inc1-small/{GROUP}-3.5ghz-core.tar" if component == "core"
else f"{base}/scene/positions/inc1-small/{GROUP}-positions.tar")
return load_dataset(
"webdataset", streaming=True, features=features_for(component),
data_files={"test": archive},
)["test"].with_format("numpy")
def identity_of(meta):
i = meta["identity"]
return i["scene_id"], i["bs_index"]
meta, core = next((m, a) for m, a in map(restore_npz, records("core"))
if identity_of(m) == (SCENE_ID, BS_ID))
positions = next(a for m, a in map(restore_npz, records("positions"))
if m["identity"]["scene_id"] == SCENE_ID)
row = int(np.searchsorted(core["link_ue_index"], UE_ID)) # UE 14's link row
assert row < core["link_ue_index"].size and core["link_ue_index"][row] == UE_ID
start, stop = map(int, core["link_path_offsets"][row:row + 2])
print(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]))
Archives stream in order, so each iterator reads until it reaches the matching record:
at most one group's archive (800 channel records or 25 scene records). This scene is the
first in its group, so both stop almost at once. To fetch one record without reading the
rest of its archive, use a byte-range read
(file guide). For repeated
workloads, index or cache positions rather than rescanning them for every BS.
Core and detail additionally join by carrier and BS and must share path_axis_sha256;
their __key__ values differ by component. Use the identity and dependency metadata, not
only equal array lengths. Restoration itself does not verify content hashes.
Optional: stock WebDataset and NumPy
Stock webdataset, without calling its decoder, yields NPZ bytes. For a downloaded
core TAR, standard NumPy opens those bytes with their stored dtypes and shapes:
import io
import webdataset as wds
archive = "c4w/payload/3.5ghz/core/inc1-small/test-urban-g00000-3.5ghz-core.tar"
key = "records/scene=urban_scene_019234/band_hz=3500000000/component=core/bs00000"
record = next(r for r in wds.WebDataset(archive, shardshuffle=False) if r["__key__"] == key)
with np.load(io.BytesIO(record["npz"]), allow_pickle=False) as npz:
core = {name: npz[name] for name in npz.files if name != "__meta__"}
meta = json.loads(npz["__meta__"].item())
Each WebDataset sample is one member: __key__ is the member path without its .npz
extension. Keep the same UE, scene and component associations as above.
Explicit features avoid relying on types inferred from the first examples, and restoration makes the stored dtypes and shapes explicit again. Reference behavior: HF WebDataset loader and NumPy formatter.