#!/usr/bin/env python3 """Export population responses to messages-only SFT and a separate row index. Input: data/intermediate/population/population.jsonl. Outputs: data/sft/population/{train.jsonl,train_index.jsonl}. Defaults are relative to the repository, independent of the working directory. The index uses one-based sample, respondent, item, and presentation indices. Population arrays and all internal computations use zero-based indices. """ from __future__ import annotations import argparse import copy import itertools import json from pathlib import Path import re import sys import numpy as np REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT / "code") not in sys.path: sys.path.insert(0, str(REPO_ROOT / "code")) from prompt.base.population_sft import INTRO, ITEM_INSTRUCTION, ITEM_VARIANTS SHUFFLE_SEED = 20260909 def split_prompt(text, n): matches = list(re.finditer(r"(?m)^Q(\d+)\.\n", text)) assert [int(m.group(1)) for m in matches] == list(range(1, n + 1)) prefix = text[:matches[0].start()] blocks = [] for i, match in enumerate(matches): end = matches[i + 1].start() if i + 1 < n else len(text) blocks.append(text[match.end():end].rstrip()) assert all(ITEM_INSTRUCTION in block and "Choose exactly one option:" in block for block in blocks) return prefix, blocks def presentation_groups(q): """Move complete dependent groups; keep consecutive free items together.""" groups = copy.deepcopy(q["protected_components"]) free = q["free_items"] for _, values in itertools.groupby(enumerate(free), lambda x: x[1] - x[0]): groups.append([value for _, value in values]) groups.sort(key=lambda x: x[0]) assert sorted(j for block in groups for j in block) == list(range(len(q["questions"]))) return groups def render(q, answer, variant, order): prefix, blocks = split_prompt(q["messages"][1]["content"], len(answer)) old = INTRO[0] assert prefix.startswith(old + "\n") prefix = INTRO[variant] + prefix[len(old):] prompt = prefix + "\n\n".join( f"Q{i + 1}.\n" + blocks[j].replace(ITEM_INSTRUCTION, ITEM_VARIANTS[variant]) for i, j in enumerate(order)) output = "\n".join(f"Q{i + 1}: Option {int(answer[j])}" for i, j in enumerate(order)) return {"messages": [copy.deepcopy(q["messages"][0]), {"role": "user", "content": prompt}, {"role": "assistant", "content": output}]} def build_rows(populations): """Return rows and one-based sidecar indices without file access. Preserve the supplied condition order: a single shared RNG controls all presentation choices and the final shuffle. Each respondent appears once. """ populations = list(populations) rng = np.random.default_rng(SHUFFLE_SEED) rows, indices = [], [] conditions = set() for q in populations: n, j = q["original_n"], len(q["questions"]) assert n > 0 and j > 0 and len(q["respondents"]) == n assert [m["role"] for m in q["messages"]] == ["system", "user"] assert q["condition_key"] not in conditions groups = presentation_groups(q) _, blocks = split_prompt(q["messages"][1]["content"], j) references = any(re.search( r"\b(?:Q\d+|previous (?:question|answer)|preceding (?:question|answer)|question (?:number )?\d+)\b", block, re.I) for block in blocks) variants = rng.permutation(np.arange(n) % 4) reorder = rng.permutation(np.arange(n) % 2).astype(bool) for i, answer in enumerate(q["respondents"]): assert len(answer) == j assert all(1 <= int(value) <= len(q["questions"][k]["options"]) for k, value in enumerate(answer)) order = list(range(j)) if reorder[i] and len(groups) > 1 and not references: permutation = rng.permutation(len(groups)) if np.array_equal(permutation, np.arange(len(groups))): permutation = np.roll(permutation, 1) order = [item for k in permutation for item in groups[int(k)]] variant = int(variants[i]) rows.append(render(q, answer, variant, order)) indices.append({"study_id": q["study_id"], "condition_id": q["condition_id"], "respondent_index": i + 1, "presentation_variant": variant + 1, "presented_to_canonical_items": [item + 1 for item in order]}) conditions.add(q["condition_key"]) order = rng.permutation(len(rows)) rows = [rows[i] for i in order] indices = [{"sample_id": number, **indices[i]} for number, i in enumerate(order, 1)] return rows, indices def write_jsonl(path, rows): with path.open("w", encoding="utf-8") as handle: for row in rows: handle.write(json.dumps(row, ensure_ascii=False, allow_nan=False) + "\n") def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--input-file", type=Path, default=REPO_ROOT / "data/intermediate/population/population.jsonl") parser.add_argument("--output-dir", type=Path, default=REPO_ROOT / "data/sft/population") args = parser.parse_args() with args.input_file.open(encoding="utf-8") as handle: populations = [json.loads(line) for line in handle if line.strip()] if args.output_dir.resolve() == REPO_ROOT / "data/sft/population": split = json.loads((REPO_ROOT / "data/raw/population/split.json").read_text(encoding="utf-8")) if set(q["study_id"] for q in populations) != set(split["train_studies"]): parser.error("Default SFT output requires the complete training population") if args.output_dir.resolve().is_relative_to(REPO_ROOT / "data/raw"): parser.error("--output-dir must not be inside data/raw") rows, indices = build_rows(populations) args.output_dir.mkdir(parents=True, exist_ok=True) write_jsonl(args.output_dir / "train.jsonl", rows) write_jsonl(args.output_dir / "train_index.jsonl", indices) print(f"Wrote {len(rows)} training rows and row indices to {args.output_dir}") if __name__ == "__main__": main()