{ "cells": [ { "cell_type": "markdown", "id": "2e88d23e", "metadata": {}, "source": [ "# Streaming and exporting to numpy\n", "\n", "Companion notebook for the RDDAC [documentation](https://rddac.readthedocs.io). It is written to stand on its own: every step is annotated so the notebook reads top to bottom.\n", "\n", "## Walkthrough\n", "\n", "1. build a fixed-shape custom view (a 1 000-pixel scan-line profile),\n", "2. iterate it offline with `rddac.streaming.iter_view` (no PyTorch, no `mlcroissant.Dataset.records()` FileSet walk),\n", "3. export the view as flat `.npy` memmaps with `export_to_numpy`, using `transforms` and a `record_transform`,\n", "4. read the shards back with `load_export` (+ `by_sim_id`),\n", "5. time the streaming path against the memmap path,\n", "6. plot the profiles straight from the shards,\n", "7. handle ragged fields: the shape check and `export_to_numpy_per_sim`.\n", "\n", "## Assumptions\n", "\n", "- This notebook lives in `notebooks/` of the repository and reads the dataset from `../data/` (on your machine: the directory `rddac download` wrote to).\n", "- Everything below scopes to five experiments from the bundled `sample.zip`, so a small download is enough to run the entire notebook.\n", "- The exported `.npy` files are written into a throwaway temp directory and deleted at the end." ] }, { "cell_type": "code", "execution_count": 1, "id": "e0dd532d", "metadata": { "execution": { "iopub.execute_input": "2026-07-06T12:50:58.570842Z", "iopub.status.busy": "2026-07-06T12:50:58.570698Z", "iopub.status.idle": "2026-07-06T12:51:00.344867Z", "shell.execute_reply": "2026-07-06T12:51:00.344186Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "rddac 0.1.0\n", "experiments used below: [0, 500, 1002, 1500, 2000]\n" ] } ], "source": [ "import warnings\n", "warnings.filterwarnings('ignore')\n", "\n", "import shutil\n", "import tempfile\n", "import time\n", "import zipfile\n", "from pathlib import Path\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "import rddac\n", "print('rddac', rddac.__version__)\n", "\n", "DATA_DIR = Path('../data')\n", "# DATA_DIR = Path('./data') # uncomment instead when running from the repository root\n", "assert (DATA_DIR / 'metadata.json').is_file(), f'{DATA_DIR} does not contain the dataset'\n", "\n", "EXPORT_ROOT = Path(tempfile.mkdtemp(prefix='rddac_export_'))\n", "EXPORT_DIR = EXPORT_ROOT / 'scan_profiles'\n", "\n", "with zipfile.ZipFile(DATA_DIR / 'h5' / 'sample.zip') as zf:\n", " SAMPLE_IDS = sorted(int(Path(n).stem) for n in zf.namelist() if n.endswith('.h5'))[:5]\n", "print('experiments used below:', SAMPLE_IDS)" ] }, { "cell_type": "markdown", "id": "13fdd747", "metadata": {}, "source": [ "## 1. Build a fixed-shape view\n", "\n", "`export_to_numpy` pre-allocates one memmap per field, so every record must share one shape — the raw force table (per-experiment row count) does not qualify, but a **slice** of a scan buffer does. The scan is a flat row-major buffer over a 2000 x 3200 grid, so 1 000 consecutive pixels of scan row 1000 live at indices `1000 * 3200 + 1100 .. + 2099`: a horizontal **height profile across the middle of the cup**, `(1000,)` for every experiment.\n", "\n", "Two CSV columns ride along via qualified ids: the blankholder force (an obvious regression target) and the oil type (a categorical we will encode at export time). The published manifest stays unchanged; only the in-memory `ds` grows.\n", "\n", "Note that the slice fixes the record *shape*, not the read cost — `iter_view` reads the whole 6.4 M-value buffer from the zip and slices in memory, which is exactly the per-record cost the export below amortises away." ] }, { "cell_type": "code", "execution_count": 2, "id": "8e208976", "metadata": { "execution": { "iopub.execute_input": "2026-07-06T12:51:00.346510Z", "iopub.status.busy": "2026-07-06T12:51:00.346196Z", "iopub.status.idle": "2026-07-06T12:51:00.534034Z", "shell.execute_reply": "2026-07-06T12:51:00.533345Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "record_sets after add_view:\n", " process-parameters\n", " field-map\n", " pointcloud-op10\n", " pointcloud-op20\n", " force-curve\n", " sheet-thickness\n", " oil-thickness\n", " thickness\n", " scan-profile\n" ] } ], "source": [ "X_SHAPE, ROW, COL0, WIDTH = 3200, 1000, 1100, 1000\n", "PROFILE_IDX = list(range(ROW * X_SHAPE + COL0, ROW * X_SHAPE + COL0 + WIDTH))\n", "\n", "ds = rddac.load(data_dir=DATA_DIR)\n", "rddac.add_view(\n", " ds,\n", " 'scan-profile',\n", " fields={\n", " 'profile': ('pointcloud_op10_z', PROFILE_IDX), # (1000,) height profile, fixed shape\n", " 'bhf': 'process-parameters/blankholder_force', # regression target candidate\n", " 'oil': 'process-parameters/oil_type', # categorical, encoded at export time\n", " },\n", ")\n", "print('record_sets after add_view:')\n", "for rs in ds.metadata.record_sets:\n", " print(f' {rs.id}')" ] }, { "cell_type": "markdown", "id": "3c31a54d", "metadata": {}, "source": [ "## 2. Preview records with `streaming.iter_view`\n", "\n", "`rddac.streaming.iter_view(view, dataset=ds)` is the plain-Python counterpart to `RDDACDataset.__iter__`. No PyTorch dependency, and none of the `mlcroissant.Dataset.records()` FileSet walk that materialises every zip member up front (minutes on the full release). It opens each zip on demand and yields one `dict[str, np.ndarray]` per experiment, with every alias already sliced according to its JSONPath transform, plus the private `_sim_id` scratch key carrying the experiment id.\n", "\n", "`where=lambda r: r['has_pointcloud']` guards against the handful of experiments without a scan (10 of 9 000): the predicate runs on the CSV rows before any zip is opened. The same `sim_ids=` / `where=` arguments accept any subset; drop both to walk every experiment in `process_parameters.csv`." ] }, { "cell_type": "code", "execution_count": 3, "id": "40cb91f6", "metadata": { "execution": { "iopub.execute_input": "2026-07-06T12:51:00.535422Z", "iopub.status.busy": "2026-07-06T12:51:00.535320Z", "iopub.status.idle": "2026-07-06T12:51:00.726799Z", "shell.execute_reply": "2026-07-06T12:51:00.726117Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "experiment 0: profile.shape=(1000,) bhf=100 kN oil='coarse'\n", "experiment 500: profile.shape=(1000,) bhf=100 kN oil='fine'\n" ] } ], "source": [ "for rec in rddac.streaming.iter_view(\n", " 'scan-profile',\n", " data_dir=DATA_DIR,\n", " dataset=ds,\n", " sim_ids=SAMPLE_IDS[:2],\n", " where=lambda r: r['has_pointcloud'],\n", "):\n", " print(f\"experiment {rec['_sim_id']:4d}: profile.shape={rec['profile'].shape} \"\n", " f\"bhf={rec['bhf']} kN oil={rec['oil']!r}\")" ] }, { "cell_type": "markdown", "id": "7704818e", "metadata": {}, "source": [ "## 3. Export to numpy\n", "\n", "`export_to_numpy` walks the view once, applies the optional transforms, and writes each output alias into its own pre-allocated `.npy` memmap of shape `(n_sims, *field_shape)`. It also writes `sim_ids.npy` so the row order is recoverable. After this runs once, the per-record cost drops from \"open zip + h5py + decompress 6.4 M values\" to a single mmap'd numpy slice.\n", "\n", "Both transform hooks are exercised here, and together they are a good template for how training pipelines actually consume the dataset:\n", "\n", "1. **`transforms={alias: fn}`** encodes a single field: the categorical `oil` string becomes a small-int label.\n", "2. **`record_transform`** sees the whole record after the per-field transforms and decides what lands on disk: it centres each profile on its own mean (the raw scanner offset is irrelevant for shape learning) and keeps that mean as a separate `z_mean` shard, so the physical values stay recoverable. Anything that fits in a numpy array — scalar, vector, label — can ride alongside the tensors at the same row index; no separate metadata file needed." ] }, { "cell_type": "code", "execution_count": 4, "id": "c52b9ccb", "metadata": { "execution": { "iopub.execute_input": "2026-07-06T12:51:00.728217Z", "iopub.status.busy": "2026-07-06T12:51:00.728113Z", "iopub.status.idle": "2026-07-06T12:51:01.127010Z", "shell.execute_reply": "2026-07-06T12:51:01.126328Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "export_to_numpy: 0.39 s for 5 experiments\n", " profile -> profile.npy ( 20128 bytes)\n", " z_mean -> z_mean.npy ( 148 bytes)\n", " bhf -> bhf.npy ( 148 bytes)\n", " oil_label -> oil_label.npy ( 168 bytes)\n", " sim_ids -> sim_ids.npy ( 168 bytes)\n" ] } ], "source": [ "OIL_LABELS = {'coarse': 0, 'medium': 1, 'fine': 2}\n", "\n", "def center_profile(rec):\n", " \"\"\"Zero-mean the profile, keep the mean + labels as separate shards.\"\"\"\n", " z = rec['profile'].astype(np.float32)\n", " z_mean = np.float32(z.mean())\n", " return {\n", " 'profile': z - z_mean, # (1000,) zero-mean height profile\n", " 'z_mean': z_mean, # scalar, de-normalisation constant\n", " 'bhf': np.float32(rec['bhf']), # regression target\n", " 'oil_label': np.int64(rec['oil']), # already int after the per-field transform\n", " }\n", "\n", "t0 = time.perf_counter()\n", "paths = rddac.streaming.export_to_numpy(\n", " 'scan-profile',\n", " EXPORT_DIR,\n", " data_dir=DATA_DIR,\n", " dataset=ds,\n", " sim_ids=SAMPLE_IDS,\n", " where=lambda r: r['has_pointcloud'],\n", " transforms={'oil': lambda v: OIL_LABELS[v]},\n", " record_transform=center_profile,\n", ")\n", "t_export = time.perf_counter() - t0\n", "\n", "print(f'export_to_numpy: {t_export:6.2f} s for {len(SAMPLE_IDS)} experiments')\n", "for alias, path in paths.items():\n", " print(f' {alias:10s} -> {path.name:16s} ({path.stat().st_size:6d} bytes)')" ] }, { "cell_type": "markdown", "id": "90e54f6f", "metadata": {}, "source": [ "## 4. Read the shards back with `load_export`\n", "\n", "`rddac.streaming.load_export(directory)` opens the exported folder behind the standard Python data model (`__len__`, `__getitem__`, `__iter__`, plus `by_sim_id`). Each row is a plain `dict[str, np.ndarray]` backed by `mmap_mode='r'`, so the full release fits even when it is too large for RAM: only the rows you actually access page in.\n", "\n", "`load_export` deliberately does **not** import torch. It just satisfies the same `len + getitem` protocol PyTorch's map-style `Dataset` uses, so the returned object plugs into `DataLoader`, `tf.data.Dataset.from_generator`, JAX, or a plain Python loop without any adapter. Pass `fields=['profile', 'bhf']` to load a subset; unknown names raise `ValueError` so typos surface immediately." ] }, { "cell_type": "code", "execution_count": 5, "id": "13b080f9", "metadata": { "execution": { "iopub.execute_input": "2026-07-06T12:51:01.128475Z", "iopub.status.busy": "2026-07-06T12:51:01.128345Z", "iopub.status.idle": "2026-07-06T12:51:01.133018Z", "shell.execute_reply": "2026-07-06T12:51:01.132323Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "len(export) = 5\n", "export.fields = ('bhf', 'oil_label', 'profile', 'z_mean')\n", "export.sim_ids = [0, 500, 1002, 1500, 2000]\n", "\n", " bhf shape=() dtype=float32 value=100.0\n", " oil_label shape=() dtype=int64 value=2\n", " profile shape=(1000,) dtype=float32 \n", " z_mean shape=() dtype=float32 value=36712.375\n" ] } ], "source": [ "export = rddac.streaming.load_export(EXPORT_DIR)\n", "\n", "print(f'len(export) = {len(export)}')\n", "print(f'export.fields = {export.fields}')\n", "print(f'export.sim_ids = {export.sim_ids.tolist()}')\n", "print()\n", "\n", "record = export.by_sim_id(500)\n", "for alias, value in record.items():\n", " print(f' {alias:10s} shape={value.shape} dtype={value.dtype} '\n", " f'{\"value=\" + str(value) if value.ndim == 0 else \"\"}')" ] }, { "cell_type": "markdown", "id": "8f0c3c1e", "metadata": {}, "source": [ "## 5. Time the two paths back to back\n", "\n", "We iterate the same five experiments both ways and time it. Path A is `streaming.iter_view`, the same call from step 2 — it re-reads the full 6.4 M-value scan buffer from the zip for every record before slicing. Path B walks the memmap shards. Both compute the same statistic (`sum |profile - mean|`) so numerical equality confirms the export is faithful.\n", "\n", "The absolute numbers are small with five experiments, but the **per-record ratio** is what carries over to a training loop: multiply by your epoch's record count to see the real win, and weigh it against the one-time export cost above." ] }, { "cell_type": "code", "execution_count": 6, "id": "51faa960", "metadata": { "execution": { "iopub.execute_input": "2026-07-06T12:51:01.134338Z", "iopub.status.busy": "2026-07-06T12:51:01.134234Z", "iopub.status.idle": "2026-07-06T12:51:01.541865Z", "shell.execute_reply": "2026-07-06T12:51:01.541117Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iter_view : 5 experiments in 403.07 ms ( 80.61 ms/record) sum=15308.0\n", "load_export : 5 experiments in 0.15 ms ( 0.03 ms/record) sum=15308.0\n", "\n", "per-record speedup: 2635x faster after a one-time 0.39 s export\n" ] } ], "source": [ "# Path A: iter_view (opens the zip and decompresses the scan buffer per record).\n", "t0 = time.perf_counter()\n", "stream_sum, n = 0.0, 0\n", "for rec in rddac.streaming.iter_view('scan-profile', data_dir=DATA_DIR, dataset=ds,\n", " sim_ids=SAMPLE_IDS, where=lambda r: r['has_pointcloud']):\n", " z = rec['profile'].astype(np.float32)\n", " stream_sum += float(np.abs(z - z.mean()).sum())\n", " n += 1\n", "t_stream = time.perf_counter() - t0\n", "\n", "# Path B: load_export (mmap slice per record).\n", "t0 = time.perf_counter()\n", "mmap_sum, m = 0.0, 0\n", "for record in export:\n", " mmap_sum += float(np.abs(record['profile']).sum())\n", " m += 1\n", "t_mmap = time.perf_counter() - t0\n", "\n", "print(f'iter_view : {n:2d} experiments in {1000 * t_stream:8.2f} ms ({1000 * t_stream / n:7.2f} ms/record) sum={stream_sum:.1f}')\n", "print(f'load_export : {m:2d} experiments in {1000 * t_mmap:8.2f} ms ({1000 * t_mmap / m:7.2f} ms/record) sum={mmap_sum:.1f}')\n", "print()\n", "print(f'per-record speedup: {t_stream / max(t_mmap, 1e-9):.0f}x faster after a one-time {t_export:.2f} s export')" ] }, { "cell_type": "markdown", "id": "616b6782", "metadata": {}, "source": [ "## 6. Plot from the shards\n", "\n", "The shards on disk are just numpy memmaps now, so no `open_h5` or view machinery is needed to look at the data. The zero-mean profiles of all five experiments overlay directly; the legend carries each experiment's blankholder force straight from the `bhf` shard. Gaps in a line are pixels the scanner did not measure (raw `z == 0`, which the centring maps to `-z_mean` — masked below)." ] }, { "cell_type": "code", "execution_count": 7, "id": "5cf65e9a", "metadata": { "execution": { "iopub.execute_input": "2026-07-06T12:51:01.543212Z", "iopub.status.busy": "2026-07-06T12:51:01.543106Z", "iopub.status.idle": "2026-07-06T12:51:01.707620Z", "shell.execute_reply": "2026-07-06T12:51:01.707021Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(figsize=(8, 3.6), dpi=150)\n", "x_px = np.arange(COL0, COL0 + WIDTH)\n", "for i in range(len(export)):\n", " rec = export[i]\n", " z = rec['profile'].astype(np.float32)\n", " z = np.where(z + rec['z_mean'] == 0, np.nan, z) # mask no-measurement pixels\n", " ax.plot(x_px, z, linewidth=1,\n", " label=f\"exp {int(export.sim_ids[i]):04d} ({rec['bhf']:.0f} kN)\")\n", "ax.set_xlabel('x [px] along scan row 1000')\n", "ax.set_ylabel('z - mean(z) [raw units]')\n", "ax.grid(True, alpha=0.3)\n", "ax.legend(loc='best', fontsize='small')\n", "ax.set_title('OP10 mid-cup height profiles, zero-mean, from the numpy shards')\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "a802bb1c", "metadata": {}, "source": [ "## 7. When records have variable shapes\n", "\n", "`export_to_numpy` pre-allocates one memmap per alias, sized from record 0, and verifies every subsequent record against it. The raw force table is the canonical failure case: its row count differs per experiment, so the export aborts with a `ValueError` that points at the fix." ] }, { "cell_type": "code", "execution_count": 8, "id": "c03bc6ce", "metadata": { "execution": { "iopub.execute_input": "2026-07-06T12:51:01.710377Z", "iopub.status.busy": "2026-07-06T12:51:01.710266Z", "iopub.status.idle": "2026-07-06T12:51:01.750276Z", "shell.execute_reply": "2026-07-06T12:51:01.749479Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ValueError: record 1: field 'force_data' has shape (720, 8) but record 0 had shape (1140, 8). export_to_numpy requires every record to share the same shape per field (it pre-allocates one memmap per alias from record 0). For variable-shape views (e.g. graph data with sim-dependent node or edge counts) use ddacs.streaming.export_to_numpy_per_sim instead, which writes one .npz per simulation and allows shapes to vary.\n" ] } ], "source": [ "try:\n", " rddac.streaming.export_to_numpy('force-curve', EXPORT_ROOT / 'will_fail',\n", " data_dir=DATA_DIR, dataset=ds, sim_ids=[0, 4500])\n", "except ValueError as e:\n", " print(f'ValueError: {e}')" ] }, { "cell_type": "markdown", "id": "ab385d10", "metadata": {}, "source": [ "For ragged fields, switch to `rddac.streaming.export_to_numpy_per_sim`: same `iter_view` + transform pipeline, but the writer is one `np.savez(.npz)` per record instead of one memmap per alias, so shapes may vary freely. Consumers reload via `np.load(path)` and access fields by name.\n", "\n", "Trade-off: per-experiment `.npz` loses the page-cache-sharing-across-DataLoader-workers property that mmap shards get for free. Prefer `export_to_numpy` when shapes are fixed (or can be sliced / padded to a fixed shape, as in step 1); use `export_to_numpy_per_sim` only when neither fits." ] }, { "cell_type": "code", "execution_count": 9, "id": "f6d7ad9f", "metadata": { "execution": { "iopub.execute_input": "2026-07-06T12:51:01.751587Z", "iopub.status.busy": "2026-07-06T12:51:01.751476Z", "iopub.status.idle": "2026-07-06T12:51:01.798018Z", "shell.execute_reply": "2026-07-06T12:51:01.797289Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 0.npz force_data: shape=(1140, 8) dtype=float32\n", " 4500.npz force_data: shape=(720, 8) dtype=float32\n", " 500.npz force_data: shape=(1140, 8) dtype=float32\n" ] } ], "source": [ "PER_SIM_DIR = EXPORT_ROOT / 'force_per_sim'\n", "rddac.streaming.export_to_numpy_per_sim(\n", " 'force-curve',\n", " PER_SIM_DIR,\n", " data_dir=DATA_DIR,\n", " dataset=ds,\n", " sim_ids=[0, 500, 4500],\n", ")\n", "\n", "for p in sorted(PER_SIM_DIR.glob('*.npz')):\n", " arrs = np.load(p)\n", " for k in arrs.files:\n", " print(f' {p.name:8s} {k}: shape={arrs[k].shape} dtype={arrs[k].dtype}')" ] }, { "cell_type": "markdown", "id": "589b80c8", "metadata": {}, "source": [ "## 8. Clean up\n", "\n", "The exports were demonstration artifacts; remove them so repeated runs start fresh. (For a real project, keep the export directory around — the one-time cost is the whole point.)" ] }, { "cell_type": "code", "execution_count": 10, "id": "eef672aa", "metadata": { "execution": { "iopub.execute_input": "2026-07-06T12:51:01.799520Z", "iopub.status.busy": "2026-07-06T12:51:01.799417Z", "iopub.status.idle": "2026-07-06T12:51:01.802532Z", "shell.execute_reply": "2026-07-06T12:51:01.801977Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "removed /tmp/rddac_export_6thnik45\n" ] } ], "source": [ "shutil.rmtree(EXPORT_ROOT)\n", "print('removed', EXPORT_ROOT)" ] }, { "cell_type": "markdown", "id": "2751fa77", "metadata": {}, "source": [ "## Where to go next\n", "\n", "- The `transforms` / `record_transform` pattern from step 3 is exactly how you turn any categorical column into a training label at export time; the same hooks exist on `export_to_numpy_per_sim`.\n", "- `streaming.iter_view` is independent of the on-disk format: it transparently reads loose `NNNN.h5` files (after `rddac download --extract --remove-zip`, see notebook 05) and zipped archives, preferring loose files because the `BytesIO` round trip is skipped.\n", "- For batched, sharded training there is `RDDACDataset` (notebook 03), which uses the same view-driven mechanics and benefits from the same `add_view` mutations via its `dataset=` kwarg." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.14" } }, "nbformat": 4, "nbformat_minor": 5 }