Add self-contained scripts (build_qa, parquet_to_jsonl)

scripts/build_qa.py

@@ -0,0 +1,315 @@
+#!/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
+------
+``<output-dir>/<split>-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 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 _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": 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:
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument(
+        "--input-dir",
+        type=Path,
+        default=Path("hf_repo"),
+        help="Directory containing the upstream data_*.zst shards.",
+    )
+    p.add_argument("--output-dir", type=Path, default=Path("qa"))
+    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 :],
+    }
+
+    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()

scripts/parquet_to_jsonl.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""Convert any Parquet file in this dataset back to JSONL (one row = one line).
+
+Works for ``demographics.parquet``, ``statements_meta.parquet``, and the
+``qa/*.parquet`` shards. Reads compressed Parquet (ZSTD / Snappy / GZIP / etc.)
+transparently via PyArrow.
+
+Self-contained: only depends on ``pyarrow``. No chiron imports.
+
+Examples:
+
+    # Single file -> single JSONL
+    python parquet_to_jsonl.py --src demographics.parquet --dst demographics.jsonl
+
+    # Whole qa/ split (multiple shards merged into one JSONL per split)
+    python parquet_to_jsonl.py --src qa/ --dst qa_jsonl/ --by-split
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+from pathlib import Path
+
+import numpy as np
+import pyarrow.parquet as pq
+
+
+_SPLIT_RE = re.compile(r"^(?P<split>[A-Za-z0-9_-]+)-(?P<shard>\d{5})-of-\d{5}\.parquet$")
+
+
+def _to_python(obj):
+    """Recursively turn pyarrow / numpy scalars into JSON-friendly Python objects."""
+    if obj is None:
+        return None
+    if isinstance(obj, dict):
+        return {k: _to_python(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_to_python(v) for v in obj]
+    if isinstance(obj, np.ndarray):
+        return [_to_python(v) for v in obj.tolist()]
+    if isinstance(obj, (np.integer,)):
+        return int(obj)
+    if isinstance(obj, (np.floating,)):
+        return float(obj)
+    if isinstance(obj, (np.bool_,)):
+        return bool(obj)
+    return obj
+
+
+def write_table_to_jsonl(table_path: Path, out_handle, *, batch_rows: int = 1024) -> int:
+    """Stream rows from one Parquet file to the open JSONL writer."""
+    pf = pq.ParquetFile(table_path)
+    n = 0
+    for batch in pf.iter_batches(batch_size=batch_rows):
+        rows = batch.to_pylist()
+        for r in rows:
+            out_handle.write(json.dumps(_to_python(r), ensure_ascii=False) + "\n")
+            n += 1
+    return n
+
+
+def _split_of(path: Path) -> str | None:
+    m = _SPLIT_RE.match(path.name)
+    return m.group("split") if m else None
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--src", type=Path, required=True, help="Parquet file or directory of Parquet shards.")
+    p.add_argument(
+        "--dst",
+        type=Path,
+        required=True,
+        help="Output JSONL file (when src is a single file or --by-split is off) or directory (with --by-split).",
+    )
+    p.add_argument(
+        "--by-split",
+        action="store_true",
+        help="If set, treat src as a directory of HF-style sharded files <split>-NNNNN-of-MMMMM.parquet "
+        "and emit one <dst>/<split>.jsonl per detected split.",
+    )
+    p.add_argument("--batch-rows", type=int, default=1024)
+    return p.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    src: Path = args.src
+    dst: Path = args.dst
+
+    if src.is_file():
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        with dst.open("w", encoding="utf-8") as fh:
+            n = write_table_to_jsonl(src, fh, batch_rows=args.batch_rows)
+        print(json.dumps({"src": str(src), "dst": str(dst), "rows": n}, indent=2))
+        return
+
+    if not src.is_dir():
+        raise SystemExit(f"src not found: {src}")
+
+    files = sorted(src.glob("*.parquet"))
+    if not files:
+        raise SystemExit(f"no .parquet files in {src}")
+
+    if args.by_split:
+        dst.mkdir(parents=True, exist_ok=True)
+        groups: dict[str, list[Path]] = {}
+        for f in files:
+            split = _split_of(f) or f.stem
+            groups.setdefault(split, []).append(f)
+        report = {}
+        for split, shards in groups.items():
+            out_path = dst / f"{split}.jsonl"
+            n_total = 0
+            with out_path.open("w", encoding="utf-8") as fh:
+                for shard in shards:
+                    n_total += write_table_to_jsonl(shard, fh, batch_rows=args.batch_rows)
+            report[split] = {"shards": [str(s) for s in shards], "dst": str(out_path), "rows": n_total}
+        print(json.dumps(report, indent=2))
+        return
+
+    # Concatenate all parquet files in dir into a single JSONL.
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    n_total = 0
+    with dst.open("w", encoding="utf-8") as fh:
+        for f in files:
+            n_total += write_table_to_jsonl(f, fh, batch_rows=args.batch_rows)
+    print(json.dumps({"src_dir": str(src), "dst": str(dst), "files": len(files), "rows": n_total}, indent=2))
+
+
+if __name__ == "__main__":
+    main()