#!/usr/bin/env python3 """Build the publication-ready AIDLAB-HAR package from the immutable v2 ZIP.""" from __future__ import annotations import argparse import csv import hashlib import html import json import re import shutil import tempfile import urllib.request import zipfile from collections import Counter, OrderedDict, defaultdict from datetime import datetime from pathlib import Path import numpy as np import pandas as pd import pyarrow as pa import pyarrow.parquet as pq import pyedflib SOURCE_URL = "https://aidlab-production-datasets.s3.eu-central-1.amazonaws.com/AIDLAB-HAR-DATASET_v2.zip" SOURCE_SHA256 = "bc501d73ad636d9db29ca65525811b9d3a76f7257d1a0f5d9143ccb8bbbd63d7" DISTRIBUTION_URL = "https://aidlab-production-datasets.s3.eu-central-1.amazonaws.com/AIDLAB-HAR-DATASET_v3.zip" SAMPLING_RATE_HZ = 50.0 ARCHIVE_ROOT = "AIDLAB-HAR-DATASET-v3" EXPECTED_SIGNALS = [ "acceleration_x", "acceleration_y", "acceleration_z", "quaternion_x", "quaternion_y", "quaternion_z", "quaternion_w", ] ACTIVITIES = OrderedDict( [ ("ABDOMINALTENSE", "abdominal_tense"), ("BEND", "bend"), ("BROADJUMP", "broad_jump"), ("BURPEES", "burpee"), ("CHAIRSTANDANDSIT", "chair_stand_and_sit"), ("CRUNCHES", "crunch"), ("DOWNWARDDOG", "downward_dog"), ("LUNGES", "lunge"), ("LYINGHIPRISES", "lying_hip_rise"), ("PLANK", "plank"), ("PUSHUPS", "push_up"), ("ROTATINGTOETOUCHES", "rotating_toe_touch"), ("RUNNINGPLANK", "running_plank"), ("SIDELUNGES", "side_lunge"), ("SQUATS", "squat"), ("WALK", "walk"), ] ) ACTIVITY_IDS = {source: index for index, source in enumerate(ACTIVITIES)} FILENAME_PATTERN = re.compile(r"^(SUB\d{2})_(.+)_S(\d+)$") def sha256(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for chunk in iter(lambda: handle.read(1024 * 1024), b""): digest.update(chunk) return digest.hexdigest() def resolve_source(source: Path | None, work_dir: Path) -> Path: if source is None: source = work_dir / "AIDLAB-HAR-DATASET_v2.zip" urllib.request.urlretrieve(SOURCE_URL, source) if not source.is_file(): raise FileNotFoundError(source) actual = sha256(source) if actual != SOURCE_SHA256: raise ValueError(f"Source checksum mismatch: expected {SOURCE_SHA256}, got {actual}") with zipfile.ZipFile(source) as archive: if archive.testzip() is not None: raise ValueError("Source ZIP failed CRC validation") return source def parse_recording_id(recording_id: str) -> tuple[str, str, int]: match = FILENAME_PATTERN.match(recording_id) if not match: raise ValueError(f"Unexpected recording filename: {recording_id}") subject_code, source_activity, series = match.groups() if source_activity not in ACTIVITIES: raise ValueError(f"Unknown activity label: {source_activity}") return subject_code, source_activity, int(series) def normalize_event(source_event: str) -> str: normalized = source_event.strip().lower().replace(" ", "_") if normalized.startswith("repetition_"): normalized = normalized.replace("repetition_", "repetition_marker_", 1) allowed = { "series_onset", "series_offset", "repetition_marker_onset", "repetition_marker_offset", } if normalized not in allowed: raise ValueError(f"Unknown annotation event: {source_event}") return normalized def contiguous_invalid_intervals(mask: np.ndarray) -> list[tuple[int, int]]: padded = np.concatenate(([False], mask, [False])).astype(np.int8) transitions = np.diff(padded) starts = np.flatnonzero(transitions == 1) ends = np.flatnonzero(transitions == -1) return list(zip(starts.tolist(), ends.tolist(), strict=True)) def write_corrected_edf( source_path: Path, target_path: Path, physical_samples: np.ndarray, signal_headers: list[dict], source_subject_code: str, ) -> dict[str, float]: corrected_headers = [] for index, header in enumerate(signal_headers): corrected = dict(header) if index < 3: corrected.update(dimension="g", physical_min=-8.0, physical_max=8.0) else: corrected.update(dimension="1", physical_min=-1.0, physical_max=1.0) corrected_headers.append(corrected) file_header = { "technician": "", "recording_additional": "DATE PLACEHOLDER; REL TIME", "patientname": source_subject_code, "patient_additional": "PSEUDONYM; NOT GLOBAL PARTICIPANT ID", "patientcode": "", "equipment": "Aidlab IMU", "admincode": "", "sex": "", "startdate": datetime(1985, 1, 1), "birthdate": "", } with pyedflib.EdfWriter( str(target_path), len(corrected_headers), file_type=pyedflib.FILETYPE_EDFPLUS ) as writer: writer.setHeader(file_header) writer.setSignalHeaders(corrected_headers) writer.writeSamples(physical_samples.T, digital=False) with pyedflib.EdfReader(str(target_path)) as reader: roundtrip = np.vstack([reader.readSignal(i) for i in range(7)]).T dimensions = [reader.getPhysicalDimension(i) for i in range(7)] ranges = [ (reader.getPhysicalMinimum(i), reader.getPhysicalMaximum(i)) for i in range(7) ] if dimensions != ["g", "g", "g", "1", "1", "1", "1"]: raise ValueError(f"Incorrect corrected dimensions in {target_path.name}: {dimensions}") if ranges != [(-8.0, 8.0)] * 3 + [(-1.0, 1.0)] * 4: raise ValueError(f"Incorrect corrected ranges in {target_path.name}: {ranges}") differences = np.abs(roundtrip - physical_samples) acceleration_error = float(differences[:, :3].max(initial=0.0)) quaternion_error = float(differences[:, 3:].max(initial=0.0)) if acceleration_error > 0.00013 or quaternion_error > 0.000016: raise ValueError( f"EDF round-trip error too large in {target_path.name}: " f"acc={acceleration_error}, quat={quaternion_error}" ) return { "acceleration_max_abs_error_g": acceleration_error, "quaternion_max_abs_error": quaternion_error, } def write_deterministic_zip(source_root: Path, target_zip: Path) -> None: with zipfile.ZipFile( target_zip, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=9 ) as archive: for path in sorted(source_root.rglob("*")): if not path.is_file(): continue relative = Path(ARCHIVE_ROOT) / path.relative_to(source_root) info = zipfile.ZipInfo(str(relative), date_time=(1985, 1, 1, 0, 0, 0)) info.compress_type = zipfile.ZIP_DEFLATED info.external_attr = 0o100644 << 16 archive.writestr(info, path.read_bytes(), compress_type=zipfile.ZIP_DEFLATED, compresslevel=9) def write_preview_svg(signals: pd.DataFrame, annotations: pd.DataFrame, target: Path) -> None: recording_id = "SUB58_SQUATS_S1" frame = signals.loc[signals.recording_id == recording_id].reset_index(drop=True) events = annotations.loc[annotations.recording_id == recording_id] if frame.empty: raise ValueError(f"Preview recording not found: {recording_id}") width, height = 1200, 460 left, right, top, bottom = 70, 30, 70, 55 plot_width = width - left - right plot_height = height - top - bottom duration = float(frame.timestamp_s.max()) values = frame[["acceleration_x_g", "acceleration_y_g", "acceleration_z_g"]].to_numpy() valid_values = values[np.isfinite(values)] y_limit = max(2.0, float(np.max(np.abs(valid_values))) * 1.1) def x_coord(timestamp: float) -> float: return left + timestamp / duration * plot_width def y_coord(value: float) -> float: return top + (y_limit - value) / (2 * y_limit) * plot_height colors = ["#ff5a5f", "#2aa876", "#4169e1"] labels = ["acceleration_x_g", "acceleration_y_g", "acceleration_z_g"] lines = [ f'', '', f'AIDLAB-HAR sample · squat · chest acceleration', f'{html.escape(recording_id)} · 50 Hz · shaded markers are annotation windows', ] for row in events.itertuples(): if row.event != "repetition_marker_onset": continue later = events[(events.timestamp_s > row.timestamp_s) & (events.event == "repetition_marker_offset")] if later.empty: continue end = float(later.iloc[0].timestamp_s) start_x, end_x = x_coord(float(row.timestamp_s)), x_coord(end) lines.append( f'' ) for tick in range(int(duration) + 1): if tick % 5 != 0: continue x = x_coord(float(tick)) lines.append(f'') lines.append(f'{tick}s') for value in np.linspace(-y_limit, y_limit, 5): y = y_coord(float(value)) lines.append(f'') lines.append(f'{value:.1f}g') stride = max(1, len(frame) // 1000) sampled = frame.iloc[::stride] for column, color, label in zip(labels, colors, labels, strict=True): points = [] for row in sampled.itertuples(): value = getattr(row, column) if pd.isna(value): continue points.append(f"{x_coord(float(row.timestamp_s)):.2f},{y_coord(float(value)):.2f}") lines.append(f'') legend_x = left + labels.index(label) * 190 lines.append(f'') lines.append(f'{label}') lines.append("") target.write_text("\n".join(lines) + "\n", encoding="utf-8") def build(source_zip: Path, output: Path) -> dict: data_dir = output / "data" raw_dir = output / "raw" metadata_dir = output / "metadata" assets_dir = output / "assets" scripts_dir = output / "scripts" for directory in (data_dir, raw_dir, metadata_dir, assets_dir, scripts_dir): directory.mkdir(parents=True, exist_ok=True) for required in ("README.md", "RAW_DATA_README.md", "CLEANING_NOTES.md", "LICENSE"): if not (output / required).is_file(): raise FileNotFoundError(output / required) recordings: list[dict] = [] annotations: list[dict] = [] signal_frames: list[pd.DataFrame] = [] quality_intervals: list[dict] = [] activity_counts = Counter() activity_seconds = defaultdict(float) total_acceleration_invalid = 0 total_quaternion_invalid = 0 max_acceleration_roundtrip_error = 0.0 max_quaternion_roundtrip_error = 0.0 with tempfile.TemporaryDirectory(prefix="aidlab-har-build-") as temporary: temporary_path = Path(temporary) extracted = temporary_path / "source" clean_root = temporary_path / "clean" clean_data = clean_root / "data" clean_data.mkdir(parents=True) with zipfile.ZipFile(source_zip) as archive: archive.extractall(extracted) source_data = extracted / "AIDLAB-HAR-DATASET-v2" / "data" edf_files = sorted(source_data.glob("*.edf")) csv_files = sorted(source_data.glob("*.csv")) if len(edf_files) != 180 or len(csv_files) != 130: raise ValueError( f"Unexpected source contents: {len(edf_files)} EDF, {len(csv_files)} CSV" ) for edf_path in edf_files: recording_id = edf_path.stem source_subject_code, source_activity, series_index = parse_recording_id(recording_id) activity_id = ACTIVITY_IDS[source_activity] activity_label = ACTIVITIES[source_activity] annotation_path = edf_path.with_suffix(".csv") with pyedflib.EdfReader(str(edf_path)) as reader: labels = reader.getSignalLabels() rates = [float(reader.getSampleFrequency(i)) for i in range(7)] physical_samples = np.vstack([reader.readSignal(i) for i in range(7)]).T duration_s = float(reader.getFileDuration()) signal_headers = reader.getSignalHeaders() if labels != EXPECTED_SIGNALS: raise ValueError(f"Unexpected channels in {edf_path.name}: {labels}") if rates != [SAMPLING_RATE_HZ] * 7: raise ValueError(f"Unexpected sample rate in {edf_path.name}: {rates}") n_samples = len(physical_samples) if n_samples != round(duration_s * SAMPLING_RATE_HZ): raise ValueError(f"Duration/sample mismatch in {edf_path.name}") timestamps = np.arange(n_samples, dtype=np.float64) / SAMPLING_RATE_HZ event_rows: list[tuple[float, str, str]] = [] if annotation_path.exists(): with annotation_path.open(newline="", encoding="utf-8-sig") as handle: for row in csv.DictReader(handle): timestamp_s = float(row["TIMESTAMP"]) source_event = row["EVENT"].strip() event = normalize_event(source_event) if not 0 <= timestamp_s <= duration_s: raise ValueError(f"Out-of-range event in {annotation_path.name}") event_rows.append((timestamp_s, event, source_event)) annotations.append( { "recording_id": recording_id, "source_subject_code": source_subject_code, "activity_id": np.int8(activity_id), "activity_label": activity_label, "source_activity": source_activity, "series_index": np.int8(series_index), "timestamp_s": timestamp_s, "event": event, "source_event": source_event, } ) series_active = np.zeros(n_samples, dtype=bool) marker_active = np.zeros(n_samples, dtype=bool) marker_index = np.full(n_samples, -1, dtype=np.int16) open_series: int | None = None open_marker: int | None = None n_markers = 0 for timestamp_s, event, _ in event_rows: index = min(int(np.searchsorted(timestamps, timestamp_s, side="left")), n_samples) if event == "series_onset": if open_series is not None: raise ValueError(f"Nested series in {recording_id}") open_series = index elif event == "series_offset": if open_series is None: raise ValueError(f"Series offset without onset in {recording_id}") series_active[open_series:index] = True open_series = None elif event == "repetition_marker_onset": if open_marker is not None: raise ValueError(f"Nested marker in {recording_id}") open_marker = index elif event == "repetition_marker_offset": if open_marker is None: raise ValueError(f"Marker offset without onset in {recording_id}") n_markers += 1 marker_active[open_marker:index] = True marker_index[open_marker:index] = n_markers open_marker = None if open_series is not None or open_marker is not None: raise ValueError(f"Unclosed annotation interval in {recording_id}") acceleration = physical_samples[:, :3] quaternion = physical_samples[:, 3:] acceleration_norm = np.linalg.norm(acceleration, axis=1) quaternion_norm = np.linalg.norm(quaternion, axis=1) quaternion_valid = ( np.isfinite(quaternion).all(axis=1) & (quaternion_norm >= 0.9) & (quaternion_norm <= 1.1) ) # Near-zero acceleration can be real during an airborne phase. Treat it # as missing only with the simultaneous invalid-quaternion packet pattern. acceleration_valid = np.isfinite(acceleration).all(axis=1) & ~( (acceleration_norm < 0.1) & ~quaternion_valid ) sample_valid = acceleration_valid & quaternion_valid total_acceleration_invalid += int((~acceleration_valid).sum()) total_quaternion_invalid += int((~quaternion_valid).sum()) for signal_name, invalid_mask in ( ("acceleration", ~acceleration_valid), ("quaternion", ~quaternion_valid), ): for start, end in contiguous_invalid_intervals(invalid_mask): quality_intervals.append( { "recording_id": recording_id, "signal": signal_name, "start_sample": start, "end_sample_exclusive": end, "start_s": start / SAMPLING_RATE_HZ, "end_s": end / SAMPLING_RATE_HZ, } ) parquet_values = physical_samples.astype(np.float32) parquet_values[~acceleration_valid, :3] = np.nan parquet_values[~quaternion_valid, 3:] = np.nan has_annotations = annotation_path.exists() sample_activity_ids = [ activity_id if (not has_annotations or active) else None for active in series_active ] sample_activity_labels = [ activity_label if value is not None else None for value in sample_activity_ids ] sample_frame = pd.DataFrame( { "recording_id": recording_id, "source_subject_code": source_subject_code, "recording_activity_id": np.int8(activity_id), "recording_activity_label": activity_label, "source_activity": source_activity, "series_index": np.int8(series_index), "sample_index": np.arange(n_samples, dtype=np.int32), "timestamp_s": timestamps, "activity_id": pd.array(sample_activity_ids, dtype="Int8"), "activity_label": sample_activity_labels, "acceleration_x_g": parquet_values[:, 0], "acceleration_y_g": parquet_values[:, 1], "acceleration_z_g": parquet_values[:, 2], "quaternion_x": parquet_values[:, 3], "quaternion_y": parquet_values[:, 4], "quaternion_z": parquet_values[:, 5], "quaternion_w": parquet_values[:, 6], "acceleration_valid": acceleration_valid, "quaternion_valid": quaternion_valid, "sample_valid": sample_valid, "series_active": pd.array( series_active if has_annotations else [None] * n_samples, dtype="boolean", ), "repetition_marker_active": pd.array( marker_active if has_annotations else [None] * n_samples, dtype="boolean", ), "repetition_marker_index": pd.array( [int(value) if value >= 0 else None for value in marker_index], dtype="Int16", ), } ) signal_frames.append(sample_frame) archive_edf_path = f"{ARCHIVE_ROOT}/data/{edf_path.name}" archive_annotation_path = ( f"{ARCHIVE_ROOT}/data/{annotation_path.name}" if has_annotations else None ) recordings.append( { "recording_id": recording_id, "source_subject_code": source_subject_code, "activity_id": np.int8(activity_id), "activity_label": activity_label, "source_activity": source_activity, "series_index": np.int8(series_index), "sampling_rate_hz": np.float32(SAMPLING_RATE_HZ), "duration_s": duration_s, "n_samples": np.int32(n_samples), "n_annotations": np.int16(len(event_rows)), "n_repetition_markers": np.int16(n_markers), "has_annotations": has_annotations, "n_acceleration_invalid": np.int32((~acceleration_valid).sum()), "n_quaternion_invalid": np.int32((~quaternion_valid).sum()), "n_samples_valid": np.int32(sample_valid.sum()), "valid_fraction": np.float32(sample_valid.mean()), "absolute_time_available": False, "archive_edf_path": archive_edf_path, "archive_annotation_path": archive_annotation_path, } ) activity_counts[activity_label] += 1 activity_seconds[activity_label] += duration_s corrected_path = clean_data / edf_path.name errors = write_corrected_edf( edf_path, corrected_path, physical_samples, signal_headers, source_subject_code, ) max_acceleration_roundtrip_error = max( max_acceleration_roundtrip_error, errors["acceleration_max_abs_error_g"] ) max_quaternion_roundtrip_error = max( max_quaternion_roundtrip_error, errors["quaternion_max_abs_error"] ) if has_annotations: with (clean_data / annotation_path.name).open( "w", newline="", encoding="utf-8" ) as handle: writer = csv.DictWriter(handle, fieldnames=["timestamp_s", "event"]) writer.writeheader() for timestamp_s, event, _ in event_rows: writer.writerow({"timestamp_s": f"{timestamp_s:.9g}", "event": event}) recordings_frame = pd.DataFrame(recordings).sort_values("recording_id").reset_index(drop=True) annotations_frame = ( pd.DataFrame(annotations) .sort_values(["recording_id", "timestamp_s"]) .reset_index(drop=True) ) signals_frame = pd.concat(signal_frames, ignore_index=True) pq.write_table( pa.Table.from_pandas(recordings_frame, preserve_index=False), data_dir / "recordings.parquet", compression="zstd", row_group_size=180, write_page_index=True, ) pq.write_table( pa.Table.from_pandas(signals_frame, preserve_index=False), data_dir / "signals.parquet", compression="zstd", row_group_size=50_000, write_page_index=True, ) pq.write_table( pa.Table.from_pandas(annotations_frame, preserve_index=False), data_dir / "annotations.parquet", compression="zstd", row_group_size=5_000, write_page_index=True, ) with (clean_root / "quality_intervals.csv").open( "w", newline="", encoding="utf-8" ) as handle: fieldnames = [ "recording_id", "signal", "start_sample", "end_sample_exclusive", "start_s", "end_s", ] writer = csv.DictWriter(handle, fieldnames=fieldnames) writer.writeheader() writer.writerows(quality_intervals) shutil.copy2(output / "RAW_DATA_README.md", clean_root / "README.md") shutil.copy2(output / "CLEANING_NOTES.md", clean_root / "CLEANING_NOTES.md") shutil.copy2(output / "LICENSE", clean_root / "LICENSE") distribution_archive = raw_dir / "AIDLAB-HAR-DATASET_v3.zip" write_deterministic_zip(clean_root, distribution_archive) with zipfile.ZipFile(distribution_archive) as archive: if archive.testzip() is not None: raise ValueError("Cleaned distribution ZIP failed CRC validation") write_preview_svg(signals_frame, annotations_frame, assets_dir / "sample-squat.svg") artifact_paths = [ data_dir / "recordings.parquet", data_dir / "signals.parquet", data_dir / "annotations.parquet", raw_dir / "AIDLAB-HAR-DATASET_v3.zip", assets_dir / "sample-squat.svg", ] manifest = { "dataset": "AIDLAB-HAR v3 corrected distribution", "distribution_url": DISTRIBUTION_URL, "source_archive_url": SOURCE_URL, "source_archive_sha256": SOURCE_SHA256, "sampling_rate_hz": SAMPLING_RATE_HZ, "recordings": len(recordings), "signal_samples": int(sum(item["n_samples"] for item in recordings)), "annotations": len(annotations), "repetition_marker_intervals": int( sum(item["n_repetition_markers"] for item in recordings) ), "duration_seconds": float(sum(item["duration_s"] for item in recordings)), "activity_labels": list(ACTIVITIES.values()), "activity_mapping": [ { "activity_id": ACTIVITY_IDS[source], "activity_label": label, "source_activity": source, } for source, label in ACTIVITIES.items() ], "activity_summary": { label: { "recordings": activity_counts[label], "duration_seconds": activity_seconds[label], } for label in ACTIVITIES.values() }, "quality": { "acceleration_invalid_samples": total_acceleration_invalid, "quaternion_invalid_samples": total_quaternion_invalid, "quality_intervals": len(quality_intervals), "acceleration_valid_definition": ( "finite values; a vector norm < 0.1 g is invalid only when the " "simultaneous quaternion is invalid" ), "quaternion_valid_definition": "finite values and vector norm in [0.9, 1.1]", }, "edf_corrections": { "acceleration_dimension": "g", "acceleration_physical_range": [-8.0, 8.0], "quaternion_dimension": "1", "quaternion_physical_range": [-1.0, 1.0], "absolute_time_available": False, "placeholder_start_date": "1985-01-01T00:00:00", "max_acceleration_roundtrip_error_g": max_acceleration_roundtrip_error, "max_quaternion_roundtrip_error": max_quaternion_roundtrip_error, }, "transformation_notes": [ "Activity labels are canonical snake_case; source labels are preserved separately.", "Samples outside annotated exercise series have null sample-level activity labels.", "Invalid signal values are null in Parquet and represented as intervals in the cleaned archive.", "Repetition annotations are marker/fiducial windows, not complete movement cycles.", "No synthetic train/validation/test split was created; every configuration uses the full split.", ], "artifacts": { str(path.relative_to(output)): {"bytes": path.stat().st_size, "sha256": sha256(path)} for path in artifact_paths }, "build_environment": { "numpy": np.__version__, "pandas": pd.__version__, "pyarrow": pa.__version__, "pyedflib": pyedflib.__version__, }, } (metadata_dir / "manifest.json").write_text( json.dumps(manifest, indent=2) + "\n", encoding="utf-8" ) return manifest def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--source", type=Path, help="Path to the immutable AIDLAB-HAR v2 ZIP") parser.add_argument( "--output", type=Path, default=Path(__file__).resolve().parents[1], help="Publication package root (default: repository root)", ) args = parser.parse_args() output = args.output.resolve() with tempfile.TemporaryDirectory(prefix="aidlab-har-source-") as temporary: source = resolve_source(args.source, Path(temporary)) manifest = build(source, output) print( json.dumps( { "recordings": manifest["recordings"], "signal_samples": manifest["signal_samples"], "annotations": manifest["annotations"], "quality": manifest["quality"], "artifacts": manifest["artifacts"], }, indent=2, ) ) if __name__ == "__main__": main()