chiron-data / code /population /build_sft.py
henry-yeh's picture htr234234's picture
Chiron data release
1b86964
Raw History Blame Contribute Delete
6.31 kB
#!/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()