| """Build paper-strength multi-split benchmark datasets for PROVEDIt.""" |
|
|
| from __future__ import annotations |
|
|
| import csv |
| import json |
| import random |
| import sys |
| from collections import Counter |
| from dataclasses import dataclass |
| from pathlib import Path |
| from typing import Dict, Iterable, List, Tuple |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[2] |
| if str(ROOT) not in sys.path: |
| sys.path.insert(0, str(ROOT)) |
|
|
| from src.cli.build_study_datasets import ( |
| PROCESSED_ROOT, |
| BenchmarkSpec, |
| PanelSpec, |
| SampleMeta, |
| RD12_SPEC, |
| RD14_SPEC, |
| collect_canonical_samples, |
| load_reference_donors, |
| normalize_allele, |
| normalize_marker, |
| ) |
|
|
|
|
| @dataclass(frozen=True) |
| class SplitSpec: |
| split_id: str |
| donor_seed: int |
| partition_seed: int |
|
|
|
|
| @dataclass(frozen=True) |
| class PaperBenchmarkSpec: |
| dataset_id: str |
| study_id: str |
| source_mode: str |
| known_count: int |
| unknown_count: int |
| panels: Tuple[PanelSpec, ...] |
| splits: Tuple[SplitSpec, ...] |
| primary_task: str |
|
|
|
|
| def make_paper_spec(base: BenchmarkSpec, dataset_id: str, primary_task: str) -> PaperBenchmarkSpec: |
| splits = tuple( |
| SplitSpec( |
| split_id=f"split_{idx:02d}", |
| donor_seed=41 + idx, |
| partition_seed=1041 + idx, |
| ) |
| for idx in range(1, 11) |
| ) |
| return PaperBenchmarkSpec( |
| dataset_id=dataset_id, |
| study_id=base.study_id, |
| source_mode=base.source_mode, |
| known_count=base.known_count, |
| unknown_count=base.unknown_count, |
| panels=base.panels, |
| splits=splits, |
| primary_task=primary_task, |
| ) |
|
|
|
|
| RD14_PAPER_SPEC = make_paper_spec( |
| RD14_SPEC, |
| dataset_id="rd14-fullref-50_multisplit_v2", |
| primary_task="main benchmark", |
| ) |
|
|
| RD12_PAPER_SPEC = make_paper_spec( |
| RD12_SPEC, |
| dataset_id="rd12-fullref-61_multisplit_v2", |
| primary_task="secondary benchmark", |
| ) |
|
|
|
|
| def join_ints(values: Iterable[int]) -> str: |
| return ",".join(str(value) for value in values) |
|
|
|
|
| def make_known_unknown_split( |
| all_ids: List[int], known_count: int, unknown_count: int, seed: int |
| ) -> Tuple[List[int], List[int]]: |
| rng = random.Random(seed) |
| ids = list(all_ids) |
| rng.shuffle(ids) |
| unknown_ids = sorted(ids[:unknown_count]) |
| known_ids = sorted(ids[unknown_count : unknown_count + known_count]) |
| return known_ids, unknown_ids |
|
|
|
|
| def make_partition_map(sample_map: Dict[Tuple[str, str], SampleMeta], seed: int) -> Dict[str, str]: |
| family_ids = sorted({sample.sample_family_id for sample in sample_map.values()}) |
| rng = random.Random(seed) |
| rng.shuffle(family_ids) |
|
|
| n = len(family_ids) |
| train_cut = int(n * 0.70) |
| dev_cut = int(n * 0.85) |
|
|
| partition_map: Dict[str, str] = {} |
| for idx, family_id in enumerate(family_ids): |
| if idx < train_cut: |
| partition_map[family_id] = "train" |
| elif idx < dev_cut: |
| partition_map[family_id] = "dev" |
| else: |
| partition_map[family_id] = "test" |
| return partition_map |
|
|
|
|
| def write_reference_donors(out_dir: Path, reference_rows: List[Dict[str, str]]) -> None: |
| path = out_dir / "reference_donors.csv" |
| with path.open("w", newline="", encoding="utf-8") as handle: |
| writer = csv.DictWriter(handle, fieldnames=["study_id", "panel", "person_id", "marker", "alleles"]) |
| writer.writeheader() |
| for row in reference_rows: |
| writer.writerow(row) |
|
|
|
|
| def build_samples_master_rows( |
| spec: PaperBenchmarkSpec, sample_map: Dict[Tuple[str, str], SampleMeta] |
| ) -> Dict[Tuple[str, str], Dict[str, str]]: |
| rows: Dict[Tuple[str, str], Dict[str, str]] = {} |
| for key, sample in sorted(sample_map.items(), key=lambda item: (item[1].panel, item[1].sample_file)): |
| rows[key] = { |
| "benchmark_id": spec.dataset_id, |
| "study_id": sample.study_id, |
| "panel": sample.panel, |
| "source_mode": sample.source_mode, |
| "sample_file": sample.sample_file, |
| "source_csv": sample.source_csv, |
| "sample_family_id": sample.sample_family_id, |
| "folder_people_label": sample.folder_people_label, |
| "injection_time": sample.injection_time, |
| "true_contributors": join_ints(sample.true_contributors), |
| "total_contributors": str(sample.total_contributors), |
| "is_active_mixture_sample": str(sample.is_active_mixture_sample), |
| } |
| return rows |
|
|
|
|
| def write_samples_master(out_dir: Path, rows: Dict[Tuple[str, str], Dict[str, str]]) -> None: |
| fieldnames = [ |
| "benchmark_id", |
| "study_id", |
| "panel", |
| "source_mode", |
| "sample_file", |
| "source_csv", |
| "sample_family_id", |
| "folder_people_label", |
| "injection_time", |
| "true_contributors", |
| "total_contributors", |
| "is_active_mixture_sample", |
| ] |
| path = out_dir / "samples_master.csv" |
| with path.open("w", newline="", encoding="utf-8") as handle: |
| writer = csv.DictWriter(handle, fieldnames=fieldnames) |
| writer.writeheader() |
| for row in rows.values(): |
| writer.writerow(row) |
|
|
|
|
| def build_sample_label_rows( |
| spec: PaperBenchmarkSpec, |
| split: SplitSpec, |
| sample_map: Dict[Tuple[str, str], SampleMeta], |
| known_ids: List[int], |
| unknown_ids: List[int], |
| partition_map: Dict[str, str], |
| ) -> Dict[Tuple[str, str], Dict[str, str]]: |
| known_set = set(known_ids) |
| unknown_set = set(unknown_ids) |
| rows: Dict[Tuple[str, str], Dict[str, str]] = {} |
|
|
| for key, sample in sorted(sample_map.items(), key=lambda item: (item[1].panel, item[1].sample_file)): |
| true_set = set(sample.true_contributors) |
| known_true = sorted(true_set & known_set) |
| unknown_true = sorted(true_set & unknown_set) |
| rows[key] = { |
| "benchmark_id": spec.dataset_id, |
| "split_id": split.split_id, |
| "partition": partition_map[sample.sample_family_id], |
| "study_id": sample.study_id, |
| "panel": sample.panel, |
| "sample_file": sample.sample_file, |
| "sample_family_id": sample.sample_family_id, |
| "true_contributors": join_ints(sample.true_contributors), |
| "known_contributors_true": join_ints(known_true), |
| "unknown_contributors_true": join_ints(unknown_true), |
| "num_known_in_sample": str(len(known_true)), |
| "num_unknown_in_sample": str(len(unknown_true)), |
| "unknown_present": "1" if unknown_true else "0", |
| "total_contributors": str(sample.total_contributors), |
| } |
| return rows |
|
|
|
|
| def write_sample_labels(path: Path, rows: Dict[Tuple[str, str], Dict[str, str]]) -> None: |
| fieldnames = [ |
| "benchmark_id", |
| "split_id", |
| "partition", |
| "study_id", |
| "panel", |
| "sample_file", |
| "sample_family_id", |
| "true_contributors", |
| "known_contributors_true", |
| "unknown_contributors_true", |
| "num_known_in_sample", |
| "num_unknown_in_sample", |
| "unknown_present", |
| "total_contributors", |
| ] |
| with path.open("w", newline="", encoding="utf-8") as handle: |
| writer = csv.DictWriter(handle, fieldnames=fieldnames) |
| writer.writeheader() |
| for row in rows.values(): |
| writer.writerow(row) |
|
|
|
|
| def write_sample_labels_all_splits(out_dir: Path, split_rows: List[Dict[str, str]]) -> None: |
| fieldnames = [ |
| "benchmark_id", |
| "split_id", |
| "partition", |
| "study_id", |
| "panel", |
| "sample_file", |
| "sample_family_id", |
| "true_contributors", |
| "known_contributors_true", |
| "unknown_contributors_true", |
| "num_known_in_sample", |
| "num_unknown_in_sample", |
| "unknown_present", |
| "total_contributors", |
| ] |
| path = out_dir / "sample_labels_all_splits.csv" |
| with path.open("w", newline="", encoding="utf-8") as handle: |
| writer = csv.DictWriter(handle, fieldnames=fieldnames) |
| writer.writeheader() |
| for row in split_rows: |
| writer.writerow(row) |
|
|
|
|
| def build_leakage_audit( |
| spec: PaperBenchmarkSpec, |
| split: SplitSpec, |
| sample_rows: Dict[Tuple[str, str], Dict[str, str]], |
| partition_map: Dict[str, str], |
| ) -> Dict[str, object]: |
| family_partitions: Dict[str, set[str]] = {} |
| sample_partitions: Dict[str, set[str]] = {} |
| partition_counts = Counter() |
| unknown_counts = Counter() |
|
|
| for row in sample_rows.values(): |
| family_id = row["sample_family_id"] |
| partition = row["partition"] |
| sample_key = f"{row['panel']}|{row['sample_file']}" |
|
|
| family_partitions.setdefault(family_id, set()).add(partition) |
| sample_partitions.setdefault(sample_key, set()).add(partition) |
| partition_counts[partition] += 1 |
| unknown_counts[row["unknown_present"]] += 1 |
|
|
| families_with_multiple_partitions = sorted( |
| family_id for family_id, parts in family_partitions.items() if len(parts) > 1 |
| ) |
| samples_with_multiple_partitions = sorted( |
| sample_key for sample_key, parts in sample_partitions.items() if len(parts) > 1 |
| ) |
|
|
| return { |
| "benchmark_id": spec.dataset_id, |
| "split_id": split.split_id, |
| "study_id": spec.study_id, |
| "donor_seed": split.donor_seed, |
| "partition_seed": split.partition_seed, |
| "num_samples": len(sample_rows), |
| "num_unique_families": len(partition_map), |
| "partition_counts": dict(partition_counts), |
| "unknown_present_counts": { |
| "0": unknown_counts.get("0", 0), |
| "1": unknown_counts.get("1", 0), |
| }, |
| "families_with_multiple_partitions": families_with_multiple_partitions, |
| "samples_with_multiple_partitions": samples_with_multiple_partitions, |
| "family_leakage_detected": bool(families_with_multiple_partitions), |
| "sample_leakage_detected": bool(samples_with_multiple_partitions), |
| } |
|
|
|
|
| def write_manifest( |
| split_dir: Path, |
| spec: PaperBenchmarkSpec, |
| split: SplitSpec, |
| known_ids: List[int], |
| unknown_ids: List[int], |
| partition_map: Dict[str, str], |
| ) -> None: |
| manifest = { |
| "benchmark_id": spec.dataset_id, |
| "split_id": split.split_id, |
| "study_id": spec.study_id, |
| "source_mode": spec.source_mode, |
| "known_count": spec.known_count, |
| "unknown_count": spec.unknown_count, |
| "donor_seed": split.donor_seed, |
| "partition_seed": split.partition_seed, |
| "known_ids": known_ids, |
| "unknown_ids": unknown_ids, |
| "family_partition_map": partition_map, |
| } |
| (split_dir / "split_manifest.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8") |
|
|
|
|
| def write_json(path: Path, payload: Dict[str, object]) -> None: |
| path.write_text(json.dumps(payload, indent=2), encoding="utf-8") |
|
|
|
|
| def build_marker_and_peak_tables( |
| out_dir: Path, |
| spec: PaperBenchmarkSpec, |
| sample_map: Dict[Tuple[str, str], SampleMeta], |
| sample_master_rows: Dict[Tuple[str, str], Dict[str, str]], |
| ) -> None: |
| peak_fieldnames = [ |
| "benchmark_id", |
| "study_id", |
| "panel", |
| "sample_file", |
| "sample_family_id", |
| "marker", |
| "dye", |
| "peak_index", |
| "allele_label_raw", |
| "allele_label_norm", |
| "size", |
| "height", |
| "is_ol", |
| "is_empty", |
| "total_contributors", |
| ] |
| marker_fieldnames = [ |
| "benchmark_id", |
| "study_id", |
| "panel", |
| "sample_file", |
| "sample_family_id", |
| "marker", |
| "dye", |
| "peak_count_total", |
| "peak_count_non_ol", |
| "observed_alleles_all", |
| "observed_alleles_non_ol", |
| "max_height", |
| "sum_height", |
| "has_ol", |
| "total_contributors", |
| ] |
|
|
| peak_path = out_dir / "peak_table.csv" |
| marker_path = out_dir / "marker_table.csv" |
| marker_agg: Dict[Tuple[str, str, str], Dict[str, object]] = {} |
| sample_to_source = { |
| (sample.panel, sample.sample_file): ROOT / sample.source_csv for sample in sample_map.values() |
| } |
|
|
| with peak_path.open("w", newline="", encoding="utf-8") as peak_handle: |
| peak_writer = csv.DictWriter(peak_handle, fieldnames=peak_fieldnames) |
| peak_writer.writeheader() |
|
|
| for panel_spec in spec.panels: |
| for csv_path in sorted(panel_spec.raw_root.rglob("*.csv")): |
| if "Known Genotypes" in csv_path.name: |
| continue |
| with csv_path.open(encoding="utf-8-sig", newline="", errors="replace") as handle: |
| reader = csv.DictReader(handle) |
| for row in reader: |
| sample_file = row["Sample File"].strip() |
| key = (panel_spec.panel, sample_file) |
| if key not in sample_master_rows: |
| continue |
| if sample_to_source[key] != csv_path: |
| continue |
|
|
| sample_row = sample_master_rows[key] |
| marker = normalize_marker(row["Marker"]) |
| dye = row["Dye"].strip() |
| marker_key = (panel_spec.panel, sample_file, marker) |
|
|
| if marker_key not in marker_agg: |
| marker_agg[marker_key] = { |
| "benchmark_id": sample_row["benchmark_id"], |
| "study_id": sample_row["study_id"], |
| "panel": panel_spec.panel, |
| "sample_file": sample_file, |
| "sample_family_id": sample_row["sample_family_id"], |
| "marker": marker, |
| "dye": set(), |
| "peak_count_total": 0, |
| "peak_count_non_ol": 0, |
| "observed_alleles_all": set(), |
| "observed_alleles_non_ol": set(), |
| "max_height": 0.0, |
| "sum_height": 0.0, |
| "has_ol": 0, |
| "total_contributors": sample_row["total_contributors"], |
| } |
|
|
| agg = marker_agg[marker_key] |
| agg["dye"].add(dye) |
|
|
| for idx in range(1, 101): |
| allele_raw = row.get(f"Allele {idx}", "") |
| size_raw = row.get(f"Size {idx}", "") |
| height_raw = row.get(f"Height {idx}", "") |
| if allele_raw is None or str(allele_raw).strip() == "": |
| continue |
|
|
| allele_raw = str(allele_raw).strip() |
| allele_norm = normalize_allele(allele_raw) |
| try: |
| size = float(size_raw) |
| except (TypeError, ValueError): |
| size = "" |
| try: |
| height = float(height_raw) |
| except (TypeError, ValueError): |
| height = 0.0 |
|
|
| is_ol = 1 if allele_norm.upper() == "OL" else 0 |
| agg["peak_count_total"] += 1 |
| agg["observed_alleles_all"].add(allele_norm) |
| agg["sum_height"] += height |
| if height > agg["max_height"]: |
| agg["max_height"] = height |
| if is_ol: |
| agg["has_ol"] = 1 |
| else: |
| agg["peak_count_non_ol"] += 1 |
| agg["observed_alleles_non_ol"].add(allele_norm) |
|
|
| peak_writer.writerow( |
| { |
| "benchmark_id": sample_row["benchmark_id"], |
| "study_id": sample_row["study_id"], |
| "panel": panel_spec.panel, |
| "sample_file": sample_file, |
| "sample_family_id": sample_row["sample_family_id"], |
| "marker": marker, |
| "dye": dye, |
| "peak_index": idx, |
| "allele_label_raw": allele_raw, |
| "allele_label_norm": allele_norm, |
| "size": size, |
| "height": height, |
| "is_ol": is_ol, |
| "is_empty": 0, |
| "total_contributors": sample_row["total_contributors"], |
| } |
| ) |
|
|
| with marker_path.open("w", newline="", encoding="utf-8") as marker_handle: |
| writer = csv.DictWriter(marker_handle, fieldnames=marker_fieldnames) |
| writer.writeheader() |
| for _, agg in sorted(marker_agg.items(), key=lambda item: (item[1]["panel"], item[1]["sample_file"], item[1]["marker"])): |
| writer.writerow( |
| { |
| "benchmark_id": agg["benchmark_id"], |
| "study_id": agg["study_id"], |
| "panel": agg["panel"], |
| "sample_file": agg["sample_file"], |
| "sample_family_id": agg["sample_family_id"], |
| "marker": agg["marker"], |
| "dye": "|".join(sorted(agg["dye"])), |
| "peak_count_total": agg["peak_count_total"], |
| "peak_count_non_ol": agg["peak_count_non_ol"], |
| "observed_alleles_all": "|".join(sorted(a for a in agg["observed_alleles_all"] if a)), |
| "observed_alleles_non_ol": "|".join(sorted(a for a in agg["observed_alleles_non_ol"] if a)), |
| "max_height": f"{agg['max_height']:.6f}", |
| "sum_height": f"{agg['sum_height']:.6f}", |
| "has_ol": agg["has_ol"], |
| "total_contributors": agg["total_contributors"], |
| } |
| ) |
|
|
|
|
| def write_docs( |
| out_dir: Path, |
| spec: PaperBenchmarkSpec, |
| universe_size: int, |
| sample_count: int, |
| split_count: int, |
| ) -> None: |
| readme = f"""# {spec.dataset_id} |
| |
| Paper-strength frozen benchmark dataset built from PROVEDIt `UnFiltered`. |
| |
| ## Summary |
| |
| - study: `{spec.study_id}` |
| - source_mode: `{spec.source_mode}` |
| - panels included: {", ".join(panel.panel for panel in spec.panels)} |
| - reference universe size: `{universe_size}` |
| - number of samples: `{sample_count}` |
| - known donors per split: `{spec.known_count}` |
| - unknown donors per split: `{spec.unknown_count}` |
| - number of frozen splits: `{split_count}` |
| - benchmark role: `{spec.primary_task}` |
| |
| ## Layout |
| |
| - `reference_donors.csv`: donor-level ground-truth reference alleles |
| - `samples_master.csv`: split-invariant sample metadata and true contributors |
| - `sample_labels_all_splits.csv`: sample labels across all frozen splits |
| - `marker_table.csv`: one row per sample-marker pair |
| - `peak_table.csv`: one row per peak |
| - `splits/`: split-specific manifests, labels, and leakage audits |
| - `SCHEMA.md`: column dictionary for all dataset files |
| - `PROTOCOL.md`: fixed experimental protocol for the paper |
| """ |
| schema = """# Schema |
| |
| ## reference_donors.csv |
| |
| - `study_id`: PROVEDIt study ID |
| - `panel`: STR panel / kit |
| - `person_id`: donor identifier within the study |
| - `marker`: marker / locus name |
| - `alleles`: donor ground-truth alleles at that marker |
| |
| ## samples_master.csv |
| |
| - `benchmark_id`: dataset release identifier |
| - `study_id`: PROVEDIt study ID |
| - `panel`: STR panel / kit |
| - `source_mode`: filtered vs unfiltered source flag |
| - `sample_file`: original sample name from raw CSV |
| - `source_csv`: raw CSV file from which the sample was kept |
| - `sample_family_id`: family/group key used to reduce leakage |
| - `folder_people_label`: original folder label such as `1-Person`, `2-Person` |
| - `injection_time`: timing label from the raw path, e.g. `5 sec` |
| - `true_contributors`: comma-separated contributor IDs parsed from the sample name |
| - `total_contributors`: total contributor count parsed from the sample name |
| - `is_active_mixture_sample`: 1 if the sample belongs to the active raw study universe |
| |
| ## sample_labels_all_splits.csv |
| |
| - `benchmark_id`: dataset release identifier |
| - `split_id`: split identifier such as `split_01` |
| - `partition`: train/dev/test assignment |
| - `study_id`: PROVEDIt study ID |
| - `panel`: STR panel / kit |
| - `sample_file`: original sample name |
| - `sample_family_id`: family/group key used to reduce leakage |
| - `true_contributors`: comma-separated contributor IDs parsed from the sample name |
| - `known_contributors_true`: contributor IDs belonging to the known split |
| - `unknown_contributors_true`: contributor IDs belonging to the unknown split |
| - `num_known_in_sample`: count of known contributors in the sample |
| - `num_unknown_in_sample`: count of unknown contributors in the sample |
| - `unknown_present`: 1 if at least one unknown contributor is present, else 0 |
| - `total_contributors`: total contributor count parsed from the sample name |
| |
| ## marker_table.csv |
| |
| - `benchmark_id`: dataset release identifier |
| - `study_id`: PROVEDIt study ID |
| - `panel`: STR panel / kit |
| - `sample_file`: original sample name |
| - `sample_family_id`: family/group key used to reduce leakage |
| - `marker`: marker/locus name |
| - `dye`: dye channel(s) observed for that sample-marker |
| - `peak_count_total`: total non-empty peak slots for the marker |
| - `peak_count_non_ol`: total non-OL peaks for the marker |
| - `observed_alleles_all`: all observed allele labels joined by `|` |
| - `observed_alleles_non_ol`: non-OL allele labels joined by `|` |
| - `max_height`: maximum peak height for the marker |
| - `sum_height`: sum of peak heights for the marker |
| - `has_ol`: 1 if at least one OL peak is present, else 0 |
| - `total_contributors`: inherited split-invariant sample metadata |
| |
| ## peak_table.csv |
| |
| - `benchmark_id`: dataset release identifier |
| - `study_id`: PROVEDIt study ID |
| - `panel`: STR panel / kit |
| - `sample_file`: original sample name |
| - `sample_family_id`: family/group key used to reduce leakage |
| - `marker`: marker/locus name |
| - `dye`: dye channel |
| - `peak_index`: original peak slot index from the raw CSV row |
| - `allele_label_raw`: raw allele label as stored in the source CSV |
| - `allele_label_norm`: normalized allele label after whitespace / `.0` cleanup |
| - `size`: reported fragment size for the peak |
| - `height`: reported peak height for the peak |
| - `is_ol`: 1 if the peak label is `OL`, else 0 |
| - `is_empty`: reserved flag; materialized peaks are written as 0 |
| - `total_contributors`: inherited split-invariant sample metadata |
| |
| ## splits/<split_id>/split_manifest.json |
| |
| - `benchmark_id`: dataset release identifier |
| - `split_id`: split identifier |
| - `study_id`: PROVEDIt study ID |
| - `source_mode`: filtered vs unfiltered source flag |
| - `known_count`: size of the known donor set |
| - `unknown_count`: size of the unknown donor set |
| - `donor_seed`: seed used to sample known vs unknown donors |
| - `partition_seed`: seed used to assign sample families to train/dev/test |
| - `known_ids`: donor IDs belonging to the known set |
| - `unknown_ids`: donor IDs belonging to the unknown set |
| - `family_partition_map`: mapping from `sample_family_id` to `train`, `dev`, or `test` |
| |
| ## splits/<split_id>/sample_labels.csv |
| |
| Same columns as `sample_labels_all_splits.csv`, but restricted to one split. |
| |
| ## splits/<split_id>/leakage_audit.json |
| |
| - `partition_counts`: number of samples in train/dev/test |
| - `unknown_present_counts`: number of samples with and without unknown contributors |
| - `families_with_multiple_partitions`: family IDs that leaked across partitions |
| - `samples_with_multiple_partitions`: sample keys that leaked across partitions |
| - `family_leakage_detected`: boolean leakage flag at family level |
| - `sample_leakage_detected`: boolean leakage flag at sample level |
| """ |
| protocol = f"""# Experimental Protocol |
| |
| ## Benchmark Role |
| |
| - dataset: `{spec.dataset_id}` |
| - study: `{spec.study_id}` |
| - role: `{spec.primary_task}` |
| |
| ## Frozen Split Design |
| |
| - number of donor-level splits: `{split_count}` |
| - known donors per split: `{spec.known_count}` |
| - unknown donors per split: `{spec.unknown_count}` |
| - train/dev/test assignment is done at the `sample_family_id` level |
| - each split stores both donor IDs and family partition assignments |
| |
| ## Tasks |
| |
| Primary tasks: |
| |
| - identify `known_contributors_true` |
| - predict `num_known_in_sample` |
| - detect `unknown_present` |
| |
| ## Data Usage Rules |
| |
| - all collaborators must use the same frozen dataset artifacts |
| - all collaborators must use the provided split manifests |
| - `samples_master.csv`, `marker_table.csv`, and `peak_table.csv` are split-invariant |
| - split-specific supervision must come from `sample_labels_all_splits.csv` or `splits/<split_id>/sample_labels.csv` |
| |
| ## Recommended Reporting |
| |
| Primary metrics: |
| |
| - known-contributor precision |
| - known-contributor recall |
| - known-contributor F1 |
| - `num_known_in_sample` accuracy |
| - `unknown_present` accuracy |
| - `unknown_present` F1 |
| |
| Secondary metrics: |
| |
| - false inclusion rate |
| - false exclusion rate |
| - per-NOC breakdown using `total_contributors` |
| - mean and standard deviation across all frozen splits |
| |
| ## Suggested Baselines |
| |
| - sample-level baseline using only `samples_master.csv` + split labels |
| - marker-level baseline using `marker_table.csv` |
| - peak-level baseline using `peak_table.csv` |
| |
| ## Leakage Policy |
| |
| - family-level leakage across train/dev/test is forbidden |
| - the canonical leakage check is the JSON audit shipped inside each split folder |
| """ |
| (out_dir / "README.md").write_text(readme, encoding="utf-8") |
| (out_dir / "SCHEMA.md").write_text(schema, encoding="utf-8") |
| (out_dir / "PROTOCOL.md").write_text(protocol, encoding="utf-8") |
|
|
|
|
| def write_summary( |
| out_dir: Path, |
| spec: PaperBenchmarkSpec, |
| universe_size: int, |
| sample_count: int, |
| split_audits: List[Dict[str, object]], |
| ) -> None: |
| summary = { |
| "benchmark_id": spec.dataset_id, |
| "study_id": spec.study_id, |
| "source_mode": spec.source_mode, |
| "panels": [panel.panel for panel in spec.panels], |
| "reference_universe_size": universe_size, |
| "num_samples": sample_count, |
| "num_splits": len(spec.splits), |
| "known_count_per_split": spec.known_count, |
| "unknown_count_per_split": spec.unknown_count, |
| "splits": [ |
| { |
| "split_id": audit["split_id"], |
| "donor_seed": audit["donor_seed"], |
| "partition_seed": audit["partition_seed"], |
| "family_leakage_detected": audit["family_leakage_detected"], |
| "sample_leakage_detected": audit["sample_leakage_detected"], |
| } |
| for audit in split_audits |
| ], |
| } |
| write_json(out_dir / "benchmark_summary.json", summary) |
|
|
|
|
| def build_paper_benchmark(spec: PaperBenchmarkSpec) -> None: |
| out_dir = PROCESSED_ROOT / spec.dataset_id |
| splits_dir = out_dir / "splits" |
| out_dir.mkdir(parents=True, exist_ok=True) |
| splits_dir.mkdir(parents=True, exist_ok=True) |
|
|
| _, reference_rows, all_ids = load_reference_donors(spec.panels) |
| sample_map = collect_canonical_samples( |
| BenchmarkSpec( |
| benchmark_id=spec.dataset_id, |
| study_id=spec.study_id, |
| source_mode=spec.source_mode, |
| seed=0, |
| known_count=spec.known_count, |
| unknown_count=spec.unknown_count, |
| panels=spec.panels, |
| ) |
| ) |
|
|
| sample_master_rows = build_samples_master_rows(spec, sample_map) |
| write_reference_donors(out_dir, reference_rows) |
| write_samples_master(out_dir, sample_master_rows) |
| build_marker_and_peak_tables(out_dir, spec, sample_map, sample_master_rows) |
|
|
| split_rows_all: List[Dict[str, str]] = [] |
| split_audits: List[Dict[str, object]] = [] |
|
|
| for split in spec.splits: |
| known_ids, unknown_ids = make_known_unknown_split( |
| all_ids, spec.known_count, spec.unknown_count, split.donor_seed |
| ) |
| partition_map = make_partition_map(sample_map, split.partition_seed) |
| sample_label_rows = build_sample_label_rows( |
| spec, split, sample_map, known_ids, unknown_ids, partition_map |
| ) |
|
|
| split_dir = splits_dir / split.split_id |
| split_dir.mkdir(parents=True, exist_ok=True) |
| write_manifest(split_dir, spec, split, known_ids, unknown_ids, partition_map) |
| write_sample_labels(split_dir / "sample_labels.csv", sample_label_rows) |
|
|
| audit = build_leakage_audit(spec, split, sample_label_rows, partition_map) |
| write_json(split_dir / "leakage_audit.json", audit) |
| split_audits.append(audit) |
| split_rows_all.extend(sample_label_rows.values()) |
|
|
| write_sample_labels_all_splits(out_dir, split_rows_all) |
| write_docs(out_dir, spec, len(all_ids), len(sample_master_rows), len(spec.splits)) |
| write_summary(out_dir, spec, len(all_ids), len(sample_master_rows), split_audits) |
|
|
|
|
| def write_top_level_protocol() -> None: |
| docs_dir = ROOT / "docs" |
| docs_dir.mkdir(parents=True, exist_ok=True) |
| protocol = """# Shared Experimental Protocol |
| |
| This project uses frozen PROVEDIt benchmark releases for two collaborators who share identical data artifacts and split manifests but may implement different modeling pipelines. |
| |
| ## Benchmark Order |
| |
| 1. `rd14-fullref-50_multisplit_v2` |
| 2. `rd12-fullref-61_multisplit_v2` |
| |
| ## Shared Rules |
| |
| - do not rebuild donor splits independently |
| - do not reshuffle train/dev/test independently |
| - always join split-specific labels from `sample_labels_all_splits.csv` or `splits/<split_id>/sample_labels.csv` |
| - always verify leakage status with `splits/<split_id>/leakage_audit.json` |
| |
| ## Required Reporting |
| |
| - report primary metrics on every split |
| - report mean and standard deviation across all splits |
| - report both collaborator pipelines on the same splits |
| - keep the dataset release fixed during model comparisons |
| """ |
| (docs_dir / "EXPERIMENT_PROTOCOL.md").write_text(protocol, encoding="utf-8") |
|
|
|
|
| def main() -> None: |
| build_paper_benchmark(RD14_PAPER_SPEC) |
| build_paper_benchmark(RD12_PAPER_SPEC) |
| write_top_level_protocol() |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
