#!/usr/bin/env python3 """Build the per-individual QA dataset (Parquet shards) for the Blog domain. Input ----- ``data_*.zst``: zstd-compressed JSON arrays. Each element is one individual with fields ``observations`` (list[str]), ``predictions`` (list of ``{question, ground_truth}``), ``data_source`` (str), ``split`` (str), and ``extra_info`` (dict). The upstream split label is ignored — this script re-derives train / val / test deterministically. Output ------ ``/-00000-of-00001.parquet`` for split in {train, val, test}. Per-row schema ~~~~~~~~~~~~~~ :: observations: list[str] predictions: list[{question, ground_truth}] data_source: str ("Blog Authorship Corpus") split: str ("train" | "val" | "test") held_out_predictions: list[{question, ground_truth}] # train only; absent on val/test extra_info: {interview_id, n_observations, n_predictions, [n_held_out_predictions]} Selection / split policy ~~~~~~~~~~~~~~~~~~~~~~~~ * Drop individuals with fewer than ``MIN_OBSERVATIONS`` observations. * If observations exceed ``MAX_OBSERVATIONS``, deterministically subsample. * Per individual, shuffle predictions with ``SEED + interview_id`` and split ~2/3 -> ``predictions`` and ~1/3 -> ``held_out``. * Drop individuals with fewer than ``MIN_PREDICTIONS`` predictions or fewer than ``MIN_HELD_OUT`` held-out items. * Globally shuffle qualified individuals with ``SEED`` and assign 90/5/5 to train/val/test. * For val/test, the held-out slice is folded into ``predictions`` so the eval pool is the union; the ``held_out_predictions`` field is dropped. Self-contained: depends only on ``pyarrow`` (+ ``zstd`` binary on PATH). No chiron imports. """ from __future__ import annotations import argparse import json import random import re import subprocess from dataclasses import dataclass from pathlib import Path from typing import Any, Iterator import pyarrow as pa import pyarrow.parquet as pq # --- fixed policy ----------------------------------------------------------- SEED = 42 MIN_OBSERVATIONS = 20 MAX_OBSERVATIONS = 200 HELD_OUT_FRACTION = 1.0 / 3.0 # 2/3 -> predictions, 1/3 -> held-out MIN_PREDICTIONS = 5 MIN_HELD_OUT = 3 TRAIN_RATIO = 0.9 VAL_RATIO = 0.05 TEST_RATIO = 0.05 DATA_SOURCE = "Blog Authorship Corpus" # --- helpers ----------------------------------------------------------------- @dataclass class _Row: interview_id: str observations: list[str] predictions: list[dict[str, str]] held_out: list[dict[str, str]] def _decompress_zst(path: Path) -> bytes: return subprocess.check_output(["zstd", "-dcf", str(path)]) def _iter_records(input_dir: Path) -> Iterator[dict]: files = sorted(input_dir.glob("data_*.zst")) if not files: raise SystemExit(f"no data_*.zst files in {input_dir}") for p in files: arr = json.loads(_decompress_zst(p)) for r in arr: yield r def _interview_seed(interview_id: str) -> int: try: return SEED + int(interview_id) except (TypeError, ValueError): return SEED + (hash(str(interview_id)) & 0x7FFFFFFF) def _normalize_ground_truth(value: str) -> str: """Return number-only labels; accepts legacy values like 'Option 2'.""" m = re.search(r"(?:option\s*)?(\d+)", value.strip(), re.IGNORECASE) if not m: raise ValueError(f"cannot parse ground_truth: {value!r}") return m.group(1) def _record_to_row(rec: dict) -> _Row | None: extra = rec.get("extra_info") or {} interview_id = str(extra.get("interview_id") or "") if not interview_id: return None observations = list(rec.get("observations") or []) predictions = list(rec.get("predictions") or []) if len(observations) < MIN_OBSERVATIONS: return None if not predictions: return None rng = random.Random(_interview_seed(interview_id)) # Cap observations by deterministic subsample (preserve order after sample). if len(observations) > MAX_OBSERVATIONS: idxs = sorted(rng.sample(range(len(observations)), MAX_OBSERVATIONS)) observations = [observations[i] for i in idxs] # Per-individual split predictions -> (predictions, held_out). pred_pool = list(predictions) rng.shuffle(pred_pool) n_held = max(1, int(round(len(pred_pool) * HELD_OUT_FRACTION))) n_held = min(n_held, len(pred_pool) - 1) # ensure at least one prediction left if n_held < 1: return None n_pred = len(pred_pool) - n_held if n_pred < MIN_PREDICTIONS or n_held < MIN_HELD_OUT: return None pred_slice = pred_pool[:n_pred] held_slice = pred_pool[n_pred:] def _clean(items: list[dict]) -> list[dict[str, str]]: out = [] for it in items: q = it.get("question") gt = it.get("ground_truth") if not isinstance(q, str) or not isinstance(gt, str): continue out.append({"question": q, "ground_truth": _normalize_ground_truth(gt)}) return out pred_clean = _clean(pred_slice) held_clean = _clean(held_slice) if len(pred_clean) < MIN_PREDICTIONS or len(held_clean) < MIN_HELD_OUT: return None return _Row( interview_id=interview_id, observations=observations, predictions=pred_clean, held_out=held_clean, ) def _partition_split_counts(n: int) -> tuple[int, int, int]: n_val = round(n * VAL_RATIO) n_test = round(n * TEST_RATIO) n_train = n - n_val - n_test if n_train < 1 and n > 0: half = max(0, n - 1) // 2 n_train, n_val, n_test = 1, half, n - 1 - half return n_train, n_val, n_test def _record_to_dict(rec: _Row, split: str) -> dict[str, Any]: extra: dict[str, Any] = { "interview_id": rec.interview_id, "n_observations": len(rec.observations), } if split == "train": out = { "observations": rec.observations, "predictions": rec.predictions, "data_source": DATA_SOURCE, "split": "train", "held_out_predictions": rec.held_out, } extra["n_predictions"] = len(rec.predictions) extra["n_held_out_predictions"] = len(rec.held_out) else: merged = list(rec.predictions) + list(rec.held_out) out = { "observations": rec.observations, "predictions": merged, "data_source": DATA_SOURCE, "split": split, } extra["n_predictions"] = len(merged) out["extra_info"] = extra return out # --- arrow schemas (explicit so train and val/test are stable) --------------- _PRED_TYPE = pa.struct([ pa.field("question", pa.string()), pa.field("ground_truth", pa.string()), ]) _TRAIN_SCHEMA = pa.schema([ pa.field("observations", pa.list_(pa.string())), pa.field("predictions", pa.list_(_PRED_TYPE)), pa.field("data_source", pa.string()), pa.field("split", pa.string()), pa.field("held_out_predictions", pa.list_(_PRED_TYPE)), pa.field("extra_info", pa.struct([ pa.field("interview_id", pa.string()), pa.field("n_observations", pa.int32()), pa.field("n_predictions", pa.int32()), pa.field("n_held_out_predictions", pa.int32()), ])), ]) _EVAL_SCHEMA = pa.schema([ pa.field("observations", pa.list_(pa.string())), pa.field("predictions", pa.list_(_PRED_TYPE)), pa.field("data_source", pa.string()), pa.field("split", pa.string()), pa.field("extra_info", pa.struct([ pa.field("interview_id", pa.string()), pa.field("n_observations", pa.int32()), pa.field("n_predictions", pa.int32()), ])), ]) def _write_split(records: list[dict], split: str, output_dir: Path, *, compression: str | None, compression_level: int | None) -> Path: schema = _TRAIN_SCHEMA if split == "train" else _EVAL_SCHEMA table = pa.Table.from_pylist(records, schema=schema) out_path = output_dir / f"{split}-00000-of-00001.parquet" pq.write_table( table, out_path, compression=compression, compression_level=compression_level, use_dictionary=True, ) return out_path def parse_args() -> argparse.Namespace: domain_dir = Path(__file__).resolve().parent.parent p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) p.add_argument( "--input-dir", type=Path, default=domain_dir / "upstream", help="Directory containing the upstream data_*.zst shards.", ) p.add_argument("--output-dir", type=Path, default=domain_dir / "qa_parquet") p.add_argument("--max-rows", type=int, default=0, help="Debug: stop after this many input rows (0 = all).") p.add_argument("--compression", default="zstd", choices=["zstd", "gzip", "snappy", "brotli", "lz4", "none"]) p.add_argument("--compression-level", type=int, default=None) return p.parse_args() def main() -> None: args = parse_args() args.output_dir.mkdir(parents=True, exist_ok=True) pool: list[_Row] = [] raw_seen = 0 skipped = 0 for rec in _iter_records(args.input_dir): raw_seen += 1 if args.max_rows and raw_seen > args.max_rows: break row = _record_to_row(rec) if row is None: skipped += 1 continue pool.append(row) rng = random.Random(SEED) rng.shuffle(pool) n = len(pool) n_train, n_val, _n_test = _partition_split_counts(n) splits = { "train": pool[:n_train], "val": pool[n_train : n_train + n_val], "test": pool[n_train + n_val :], } # Preserve the published IID test policy: exclude the historical training # prefix, then retain only the first test row for each adapter identity. train_ids = {str(rec.interview_id) for rec in splits["train"][:4366]} seen_test_ids: set[str] = set() clean_test: list[_Row] = [] for rec in splits["test"]: sample_id = str(rec.interview_id) if sample_id in train_ids or sample_id in seen_test_ids: continue seen_test_ids.add(sample_id) clean_test.append(rec) splits["test"] = clean_test comp = None if args.compression == "none" else args.compression written: dict[str, dict] = {} for split_name, recs in splits.items(): if not recs: continue records = [_record_to_dict(r, split_name) for r in recs] path = _write_split(records, split_name, args.output_dir, compression=comp, compression_level=args.compression_level) written[split_name] = {"rows": len(records), "path": str(path)} print(json.dumps({ "raw_lines_seen": raw_seen, "samples_built": n, "skipped_insufficient_data": skipped, "split_counts": {k: len(v) for k, v in splits.items()}, "written": written, }, indent=2)) if __name__ == "__main__": main()