Publish reproducible Kinect build and baseline scripts

scripts/build_dataset.py

@@ -0,0 +1,418 @@
+"""Build a reach-intent benchmark from PLOS ONE supplementary archive S3.
+
+The builder reads the source archive without extracting it, joins event logs to
+the approximately 16 Hz skeleton stream, and writes viewer-friendly CSV files.
+It intentionally excludes the clinical table and fine-grained demographics.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import gzip
+import hashlib
+import io
+import json
+import re
+import urllib.request
+import zipfile
+from collections import Counter, defaultdict
+from datetime import date, datetime
+from pathlib import Path
+from typing import Iterable, Iterator
+
+SOURCE_URL = (
+    "https://journals.plos.org/plosone/article/file?type=supplementary&"
+    "id=info:doi/10.1371/journal.pone.0170472.s003"
+)
+SOURCE_SHA256 = "21fc2ae8d8bce10b3cecd6416fdda390ba98476c9b9abe95be91857aea07d008"
+
+TARGET_NAMES = {
+    0: "right_low_45",
+    1: "right_lateral",
+    2: "right_up_30",
+    3: "right_up_60",
+    4: "right_top",
+    5: "left_low_45",
+    6: "left_lateral",
+    7: "left_up_30",
+    8: "left_up_60",
+    9: "left_top",
+}
+
+# The two session-level PCA outliers removed in the public analysis workflow.
+QC_OUTLIER_FEATURE_KEYS = {
+    "1024_2015.03.19_19.19",
+    "1038_2014.12.11_17.45",
+}
+
+EVENT_RE = re.compile(
+    r"\t(?P<timestamp>\d+)\tObject (?P<object>\d+) "
+    r"(?P<event>appeared|timed out|reached by (?P<hand>right|left) hand)!"
+)
+SESSION_RE = re.compile(
+    r"(?P<participant>\d+)_(?P<date>\d{4}\.\d{2}\.\d{2})_"
+    r"(?P<time>\d{2}\.\d{2}\.\d{2})\.txt$"
+)
+
+
+def _open_text(data: bytes) -> io.TextIOWrapper:
+    return io.TextIOWrapper(io.BytesIO(data), encoding="utf-8-sig", newline="")
+
+
+def _write_csv(path: Path, fieldnames: list[str], rows: Iterable[dict]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.suffix == ".gz":
+        raw = path.open("wb")
+        binary = gzip.GzipFile(filename="", mode="wb", fileobj=raw, mtime=0)
+        handle = io.TextIOWrapper(binary, encoding="utf-8", newline="")
+    else:
+        handle = path.open("w", encoding="utf-8", newline="")
+    try:
+        writer = csv.DictWriter(handle, fieldnames=fieldnames, extrasaction="ignore")
+        writer.writeheader()
+        writer.writerows(rows)
+    finally:
+        handle.close()
+
+
+def download_source(destination: Path) -> Path:
+    """Download and checksum the canonical PLOS supplementary archive."""
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    request = urllib.request.Request(SOURCE_URL, headers={"User-Agent": "open-sma-hub/0.1"})
+    with urllib.request.urlopen(request) as response, destination.open("wb") as output:
+        while block := response.read(1024 * 1024):
+            output.write(block)
+    digest = hashlib.sha256(destination.read_bytes()).hexdigest()
+    if digest != SOURCE_SHA256:
+        destination.unlink(missing_ok=True)
+        raise ValueError(f"Source checksum mismatch: expected {SOURCE_SHA256}, got {digest}")
+    return destination
+
+
+def _read_features(outer: zipfile.ZipFile) -> dict[str, str]:
+    data = outer.read("S1_Dataset/full_features_class.txt")
+    rows = csv.DictReader(_open_text(data), delimiter="\t")
+    return {
+        row["name"]: "sma" if row["class"].strip().lower() == "sma" else "control"
+        for row in rows
+    }
+
+
+def _read_clinical_context(
+    outer: zipfile.ZipFile,
+) -> tuple[set[str], dict[tuple[str, date], int]]:
+    """Read only IDs, dates, and visit numbers needed for source-study filtering."""
+    rows = csv.DictReader(_open_text(outer.read("S1_Dataset/clinical_data.csv")))
+    participants: set[str] = set()
+    visits: dict[tuple[str, date], int] = {}
+    for row in rows:
+        participant_id = row["ID"]
+        participants.add(participant_id)
+        visits[(participant_id, datetime.strptime(row["DATE"], "%d.%m.%Y").date())] = int(
+            row["VISIT"]
+        )
+    return participants, visits
+
+
+def _parse_raw(data: bytes) -> list[dict[str, str]]:
+    reader = csv.DictReader(_open_text(data), delimiter="\t")
+    rows = []
+    for row in reader:
+        if not row.get("currentTimeMillis"):
+            continue
+        cleaned = {key.strip(): value.strip() for key, value in row.items() if key is not None}
+        cleaned["currentTimeMillis"] = str(int(float(cleaned["currentTimeMillis"])))
+        rows.append(cleaned)
+    return rows
+
+
+def _parse_events(data: bytes, raw_start_ms: int | None = None) -> list[dict]:
+    active: dict[int, int] = {}
+    trials: list[dict] = []
+    inferred_first_object_closed = False
+    for line in data.decode("utf-8-sig", errors="replace").splitlines():
+        match = EVENT_RE.search(line)
+        if not match:
+            continue
+        timestamp = int(match.group("timestamp"))
+        object_index = int(match.group("object"))
+        event = match.group("event")
+        if event == "appeared":
+            active[object_index] = timestamp
+        elif object_index in active:
+            trials.append(
+                {
+                    "object_index": object_index,
+                    "target_label": object_index % 10,
+                    "target_name": TARGET_NAMES[object_index % 10],
+                    "repeat_index": object_index // 10,
+                    "start_ms": active.pop(object_index),
+                    "end_ms": timestamp,
+                    "status": "reached" if event.startswith("reached") else "timed_out",
+                    "hand": match.group("hand") or "",
+                    "start_inferred": False,
+                }
+            )
+        elif (
+            raw_start_ms is not None
+            and object_index == 0
+            and timestamp >= raw_start_ms
+            and not inferred_first_object_closed
+        ):
+            # The game source starts object 0 without logging an "appeared" event.
+            # Raw recording begins after game initialization, so raw_start_ms is
+            # the earliest observable bound for its first presentation.
+            trials.append(
+                {
+                    "object_index": 0,
+                    "target_label": 0,
+                    "target_name": TARGET_NAMES[0],
+                    "repeat_index": 0,
+                    "start_ms": raw_start_ms,
+                    "end_ms": timestamp,
+                    "status": "reached" if event.startswith("reached") else "timed_out",
+                    "hand": match.group("hand") or "",
+                    "start_inferred": True,
+                }
+            )
+            inferred_first_object_closed = True
+    return trials
+
+
+def _nested_archive(outer: zipfile.ZipFile, name: str) -> zipfile.ZipFile:
+    return zipfile.ZipFile(io.BytesIO(outer.read(name)))
+
+
+def build(source_zip: Path, output_dir: Path) -> dict:
+    digest = hashlib.sha256(source_zip.read_bytes()).hexdigest()
+    if digest != SOURCE_SHA256:
+        raise ValueError(f"Source checksum mismatch: expected {SOURCE_SHA256}, got {digest}")
+
+    trials_out: list[dict] = []
+    frames_out: list[dict] = []
+    sessions: list[dict] = []
+
+    with zipfile.ZipFile(source_zip) as outer:
+        groups = _read_features(outer)
+        clinical_participants, clinical_visits = _read_clinical_context(outer)
+        with _nested_archive(outer, "S1_Dataset/Full_RawData.zip") as raw_zip, _nested_archive(
+            outer, "S1_Dataset/Full_LogFile.zip"
+        ) as log_zip:
+            raw_names = sorted(name for name in raw_zip.namelist() if name.endswith(".txt"))
+            log_by_session = {
+                Path(name).name.removeprefix("log_").removesuffix(".txt"): name
+                for name in log_zip.namelist()
+                if name.endswith(".txt")
+            }
+            raw_session_ids = {Path(name).name.removesuffix(".txt") for name in raw_names}
+            unmatched_raw_sessions = sorted(raw_session_ids - set(log_by_session))
+            unmatched_log_sessions = sorted(set(log_by_session) - raw_session_ids)
+            invalid_date_sessions: list[str] = []
+            for raw_name in raw_names:
+                filename = Path(raw_name).name
+                match = SESSION_RE.match(filename)
+                if not match:
+                    continue
+                session_id = filename.removesuffix(".txt")
+                participant_id = match.group("participant")
+                # Reproduce the public R preprocessing rules from the study.
+                if participant_id == "1018":  # Marked "not SMA" in StatisticalAnalysis.Rmd.
+                    continue
+                if participant_id not in clinical_participants:
+                    continue
+                if session_id.startswith("1027_2014.07.10_"):  # Marked "no real game".
+                    continue
+                session_date = datetime.strptime(match.group("date"), "%Y.%m.%d").date()
+                visit_number = clinical_visits.get((participant_id, session_date))
+                # These fallbacks exactly reproduce 1_dataPreprocessing.R.
+                if visit_number is None and session_date > date(2015, 1, 1):
+                    visit_number = 4
+                if participant_id in {"1035", "1039"} and session_date == date(2014, 12, 18):
+                    visit_number = 3
+                if visit_number is None:
+                    invalid_date_sessions.append(session_id)
+                    continue
+                feature_key = session_id.rsplit(".", 1)[0]
+                group = groups.get(feature_key)
+                if group is None:
+                    raise KeyError(f"No group label for {session_id}")
+                qc_outlier = feature_key in QC_OUTLIER_FEATURE_KEYS
+                log_name = log_by_session.get(session_id)
+                if log_name is None:
+                    continue
+                raw_rows = _parse_raw(raw_zip.read(raw_name))
+                if not raw_rows:
+                    continue
+                raw_min = int(raw_rows[0]["currentTimeMillis"])
+                raw_max = int(raw_rows[-1]["currentTimeMillis"])
+                events = _parse_events(log_zip.read(log_name), raw_start_ms=raw_min)
+                kept = 0
+                reached = 0
+                for sequence, trial in enumerate(events):
+                    start = max(trial["start_ms"], raw_min)
+                    end = min(trial["end_ms"], raw_max)
+                    selected = [
+                        row for row in raw_rows if start <= int(row["currentTimeMillis"]) <= end
+                    ]
+                    if end <= start or len(selected) < 2:
+                        continue
+                    trial_id = f"{session_id}__{sequence:02d}_o{trial['object_index']:02d}"
+                    duration = end - start
+                    trial_row = {
+                        "trial_id": trial_id,
+                        "session_id": session_id,
+                        "participant_id": participant_id,
+                        "group": group,
+                        "qc_outlier": qc_outlier,
+                        **trial,
+                        "start_ms": start,
+                        "end_ms": end,
+                        "duration_ms": duration,
+                        "n_frames": len(selected),
+                    }
+                    trials_out.append(trial_row)
+                    kept += 1
+                    reached += trial["status"] == "reached"
+                    for frame_index, row in enumerate(selected):
+                        timestamp = int(row["currentTimeMillis"])
+                        frames_out.append(
+                            {
+                                "trial_id": trial_id,
+                                "session_id": session_id,
+                                "participant_id": participant_id,
+                                "group": group,
+                                "qc_outlier": qc_outlier,
+                                "target_label": trial["target_label"],
+                                "target_name": trial["target_name"],
+                                "repeat_index": trial["repeat_index"],
+                                "status": trial["status"],
+                                "hand": trial["hand"],
+                                "start_inferred": trial["start_inferred"],
+                                "frame_index": frame_index,
+                                "timestamp_ms": timestamp,
+                                "elapsed_ms": timestamp - start,
+                                "progress": round((timestamp - start) / duration, 6),
+                                **{
+                                    key: value
+                                    for key, value in row.items()
+                                    if key not in {"Time", "currentTimeMillis"}
+                                },
+                            }
+                        )
+                sessions.append(
+                    {
+                        "session_id": session_id,
+                        "participant_id": participant_id,
+                        "group": group,
+                        "qc_outlier": qc_outlier,
+                        "session_datetime": f"{match.group('date').replace('.', '-') }T{match.group('time').replace('.', ':')}",
+                        "visit_index": visit_number - 1,
+                        "n_trials": kept,
+                        "n_reached_trials": reached,
+                    }
+                )
+
+    by_participant: dict[str, list[dict]] = defaultdict(list)
+    for session in sessions:
+        by_participant[session["participant_id"]].append(session)
+    participants_by_group: dict[str, list[str]] = defaultdict(list)
+    for participant_id, participant_sessions in by_participant.items():
+        participants_by_group[participant_sessions[0]["group"]].append(participant_id)
+    folds: dict[str, int] = {}
+    for group, participant_ids in participants_by_group.items():
+        for index, participant_id in enumerate(sorted(participant_ids)):
+            folds[participant_id] = index % 5
+
+    session_lookup = {session["session_id"]: session for session in sessions}
+    for session in sessions:
+        session["fold"] = folds[session["participant_id"]]
+    for row in trials_out:
+        row["visit_index"] = session_lookup[row["session_id"]]["visit_index"]
+        row["fold"] = folds[row["participant_id"]]
+    for row in frames_out:
+        row["visit_index"] = session_lookup[row["session_id"]]["visit_index"]
+        row["fold"] = folds[row["participant_id"]]
+
+    coordinate_columns = [
+        key
+        for key in frames_out[0]
+        if key.endswith("-X") or key.endswith("-Y") or key.endswith("-Z")
+    ]
+    trial_fields = [
+        "trial_id", "session_id", "participant_id", "group", "qc_outlier", "visit_index", "fold",
+        "object_index", "target_label", "target_name", "repeat_index", "status", "hand", "start_inferred",
+        "start_ms", "end_ms", "duration_ms", "n_frames",
+    ]
+    frame_fields = [
+        "trial_id", "session_id", "participant_id", "group", "qc_outlier", "visit_index", "fold",
+        "target_label", "target_name", "repeat_index", "status", "hand", "start_inferred", "frame_index",
+        "timestamp_ms", "elapsed_ms", "progress", *coordinate_columns,
+    ]
+    session_fields = [
+        "session_id", "participant_id", "group", "qc_outlier", "session_datetime", "visit_index", "fold",
+        "n_trials", "n_reached_trials",
+    ]
+    split_rows = [
+        {
+            "participant_id": participant_id,
+            "group": participant_sessions[0]["group"],
+            "fold": folds[participant_id],
+        }
+        for participant_id, participant_sessions in sorted(by_participant.items())
+    ]
+
+    _write_csv(output_dir / "reach_trials.csv.gz", trial_fields, trials_out)
+    _write_csv(output_dir / "reach_frames.csv.gz", frame_fields, frames_out)
+    _write_csv(output_dir / "sessions.csv", session_fields, sessions)
+    _write_csv(output_dir / "participant_folds.csv", ["participant_id", "group", "fold"], split_rows)
+
+    summary = {
+        "source_sha256": digest,
+        "participants": len(by_participant),
+        "sessions": len(sessions),
+        "trials": len(trials_out),
+        "frames": len(frames_out),
+        "groups": Counter(session["group"] for session in sessions),
+        "participant_groups": Counter(row["group"] for row in split_rows),
+        "trial_status": Counter(row["status"] for row in trials_out),
+        "targets": Counter(row["target_name"] for row in trials_out),
+        "inferred_start_trials": sum(bool(row["start_inferred"]) for row in trials_out),
+        "qc_outlier_sessions": sorted(
+            session["session_id"] for session in sessions if session["qc_outlier"]
+        ),
+        "unmatched_raw_sessions": unmatched_raw_sessions,
+        "unmatched_log_sessions": unmatched_log_sessions,
+        "study_preprocessing_exclusions": {
+            "participant_not_sma": ["1018"],
+            "participant_without_clinical_record": ["1036"],
+            "invalid_game": ["1027_2014.07.10"],
+            "invalid_or_nonstudy_session_dates": invalid_date_sessions,
+        },
+    }
+    summary = {key: dict(value) if isinstance(value, Counter) else value for key, value in summary.items()}
+    (output_dir / "build_summary.json").write_text(
+        json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+    return summary
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--source-zip", type=Path, help="Downloaded PLOS supplementary S3 archive")
+    parser.add_argument("--output-dir", type=Path, default=Path("kinect/data"))
+    parser.add_argument(
+        "--download",
+        type=Path,
+        metavar="PATH",
+        help="Download the canonical source archive to PATH before building",
+    )
+    args = parser.parse_args(argv)
+    source = download_source(args.download) if args.download else args.source_zip
+    if source is None:
+        parser.error("provide --source-zip or --download")
+    print(json.dumps(build(source, args.output_dir), indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

scripts/download_original.py

@@ -0,0 +1,31 @@
+"""Download the canonical PLOS supplementary archive and verify its checksum."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import urllib.request
+from pathlib import Path
+
+URL = "https://journals.plos.org/plosone/article/file?type=supplementary&id=info:doi/10.1371/journal.pone.0170472.s003"
+SHA256 = "21fc2ae8d8bce10b3cecd6416fdda390ba98476c9b9abe95be91857aea07d008"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("output", type=Path, nargs="?", default=Path("plos_s3_dataset.zip"))
+    args = parser.parse_args()
+    request = urllib.request.Request(URL, headers={"User-Agent": "open-sma-hub/0.1"})
+    with urllib.request.urlopen(request) as response, args.output.open("wb") as output:
+        while block := response.read(1024 * 1024):
+            output.write(block)
+    digest = hashlib.sha256(args.output.read_bytes()).hexdigest()
+    if digest != SHA256:
+        args.output.unlink(missing_ok=True)
+        raise SystemExit(f"Checksum mismatch: expected {SHA256}, got {digest}")
+    print(f"Verified {args.output} ({digest})")
+
+
+if __name__ == "__main__":
+    main()
+

scripts/evaluate_baseline.py

@@ -0,0 +1,220 @@
+"""Dependency-free nearest-centroid baselines for the reach-intent benchmark."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import gzip
+import json
+import math
+from collections import defaultdict
+from pathlib import Path
+
+CHECKPOINTS = (0.25, 0.50, 1.00)
+
+
+def read_rows(path: Path):
+    opener = gzip.open if path.suffix == ".gz" else open
+    with opener(path, "rt", encoding="utf-8", newline="") as handle:
+        yield from csv.DictReader(handle)
+
+
+def vector(row, initial):
+    values = []
+    for side in ("Right", "Left"):
+        for axis in ("X", "Y", "Z"):
+            hand = float(row[f"{side}Hand-{axis}"])
+            shoulder = float(row[f"{side}Shoulder-{axis}"])
+            start_hand = float(initial[f"{side}Hand-{axis}"])
+            values.extend((hand - shoulder, hand - start_hand))
+    shoulder_width = math.sqrt(
+        sum(
+            (float(row[f"RightShoulder-{axis}"]) - float(row[f"LeftShoulder-{axis}"])) ** 2
+            for axis in ("X", "Y", "Z")
+        )
+    )
+    scale = max(shoulder_width, 1.0)
+    return tuple(value / scale for value in values)
+
+
+def load_examples(
+    data_dir: Path,
+    checkpoint: float,
+    exclude_inferred: bool = False,
+    exclude_qc_outliers: bool = True,
+):
+    trials = {
+        row["trial_id"]: row
+        for row in read_rows(data_dir / "reach_trials.csv.gz")
+        if row["status"] == "reached"
+        and not (exclude_inferred and row["start_inferred"].lower() == "true")
+        and not (exclude_qc_outliers and row["qc_outlier"].lower() == "true")
+    }
+    first, selected = {}, {}
+    for row in read_rows(data_dir / "reach_frames.csv.gz"):
+        trial_id = row["trial_id"]
+        if trial_id not in trials:
+            continue
+        first.setdefault(trial_id, row)
+        progress = float(row["progress"])
+        if progress <= checkpoint:
+            selected[trial_id] = row
+    examples = []
+    for trial_id, row in selected.items():
+        metadata = trials[trial_id]
+        examples.append(
+            {
+                **metadata,
+                "label": int(metadata["target_label"]),
+                "fold": int(metadata["fold"]),
+                "visit": int(metadata["visit_index"]),
+                "x": vector(row, first[trial_id]),
+            }
+        )
+    return examples
+
+
+def centroid(rows):
+    return tuple(sum(row["x"][i] for row in rows) / len(rows) for i in range(len(rows[0]["x"])))
+
+
+def prototypes(rows):
+    by_label = defaultdict(list)
+    for row in rows:
+        by_label[row["label"]].append(row)
+    return {label: centroid(items) for label, items in by_label.items()}
+
+
+def predict(x, centers):
+    return min(centers, key=lambda label: sum((a - b) ** 2 for a, b in zip(x, centers[label])))
+
+
+def metrics(pairs):
+    if not pairs:
+        return {"n": 0, "accuracy": None, "macro_recall": None, "by_group": {}}
+    recalls, by_group = [], defaultdict(list)
+    for label in range(10):
+        subset = [(truth, pred) for truth, pred, _ in pairs if truth == label]
+        if subset:
+            recalls.append(sum(truth == pred for truth, pred in subset) / len(subset))
+    for truth, pred, group in pairs:
+        by_group[group].append(truth == pred)
+    return {
+        "n": len(pairs),
+        "accuracy": round(sum(truth == pred for truth, pred, _ in pairs) / len(pairs), 4),
+        "macro_recall": round(sum(recalls) / len(recalls), 4),
+        "by_group": {
+            group: round(sum(values) / len(values), 4) for group, values in sorted(by_group.items())
+        },
+    }
+
+
+def generic(examples):
+    pairs = []
+    for fold in range(5):
+        train = [row for row in examples if row["fold"] != fold]
+        test = [row for row in examples if row["fold"] == fold]
+        centers = prototypes(train)
+        pairs.extend((row["label"], predict(row["x"], centers), row["group"]) for row in test)
+    return metrics(pairs)
+
+
+def personalized(examples, shots, prior_weight=5):
+    """Compare generic, personal-only, and prior-weighted adaptation fairly."""
+    generic_pairs, personal_pairs, adapted_pairs = [], [], []
+    for fold in range(5):
+        generic_centers = prototypes([row for row in examples if row["fold"] != fold])
+        people = defaultdict(list)
+        for row in examples:
+            if row["fold"] == fold:
+                people[row["participant_id"]].append(row)
+        for rows in people.values():
+            ordered = sorted(
+                rows, key=lambda row: (row["visit"], row["session_id"], row["trial_id"])
+            )
+            by_label = defaultdict(list)
+            for row in ordered:
+                by_label[row["label"]].append(row)
+            calibration_by_label = {
+                label: items[:shots] for label, items in by_label.items() if items[:shots]
+            }
+            test = [row for items in by_label.values() for row in items[shots:]]
+            personal_centers = {
+                label: centroid(items) for label, items in calibration_by_label.items()
+            }
+            adapted_centers = dict(generic_centers)
+            for label, personal_center in personal_centers.items():
+                n_personal = len(calibration_by_label[label])
+                adapted_centers[label] = tuple(
+                    (prior_weight * generic_value + n_personal * personal_value)
+                    / (prior_weight + n_personal)
+                    for generic_value, personal_value in zip(
+                        generic_centers[label], personal_center
+                    )
+                )
+            for row in test:
+                item = (row["label"], row["group"])
+                generic_pairs.append((item[0], predict(row["x"], generic_centers), item[1]))
+                personal_pairs.append((item[0], predict(row["x"], personal_centers), item[1]))
+                adapted_pairs.append((item[0], predict(row["x"], adapted_centers), item[1]))
+    generic_metrics = metrics(generic_pairs)
+    personal_metrics = metrics(personal_pairs)
+    adapted_metrics = metrics(adapted_pairs)
+    gain = None
+    if adapted_metrics["accuracy"] is not None and generic_metrics["accuracy"] is not None:
+        gain = round(adapted_metrics["accuracy"] - generic_metrics["accuracy"], 4)
+    return {
+        "generic_on_same_test": generic_metrics,
+        "personal_only": personal_metrics,
+        "adapted": adapted_metrics,
+        "adapted_accuracy_gain": gain,
+        "generic_prior_weight": prior_weight,
+    }
+
+
+def cross_visit(examples):
+    pairs = []
+    people = defaultdict(list)
+    for row in examples:
+        people[row["participant_id"]].append(row)
+    for rows in people.values():
+        calibration = [row for row in rows if row["visit"] == 0]
+        test = [row for row in rows if row["visit"] > 0]
+        centers = prototypes(calibration)
+        pairs.extend((row["label"], predict(row["x"], centers), row["group"]) for row in test)
+    return metrics(pairs)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-dir", type=Path, default=Path("data"))
+    parser.add_argument("--output", type=Path)
+    args = parser.parse_args()
+    result = {}
+    for checkpoint in CHECKPOINTS:
+        result[str(checkpoint)] = {}
+        for slice_name, exclude_inferred, exclude_qc_outliers in (
+            ("paper_qc", False, True),
+            ("paper_qc_explicit_start_only", True, True),
+            ("all_exact_pairs", False, False),
+        ):
+            examples = load_examples(
+                args.data_dir,
+                checkpoint,
+                exclude_inferred=exclude_inferred,
+                exclude_qc_outliers=exclude_qc_outliers,
+            )
+            result[str(checkpoint)][slice_name] = {
+                "generic_5_fold": generic(examples),
+                "personalized_1_shot": personalized(examples, 1),
+                "personalized_5_shot": personalized(examples, 5),
+                "cross_visit": cross_visit(examples),
+            }
+    rendered = json.dumps(result, indent=2, sort_keys=True) + "\n"
+    if args.output:
+        args.output.write_text(rendered, encoding="utf-8")
+    print(rendered, end="")
+
+
+if __name__ == "__main__":
+    main()