#!/usr/bin/env python3 """Assemble all three supervision signals into one shuffled SFT JSONL. Inputs (relative to this repository): data/sft/prediction/train.jsonl (already x2), data/sft/measurement/{item_response,llm_intensity,prediction_reuse,human_gold}/train.jsonl, data/sft/population/{train.jsonl,train_index.jsonl}, data/raw/measurement/construct_vocab.json. Output: data/sft/joint_train.jsonl only; existing output is replaced atomically. python code/build_joint_training.py Default recipe: prediction unchanged, measurement x2, population x5; seed 42. Rows always have sample_id, signal, domain, messages, measurement. The tuple (signal, domain, sample_id) identifies a source sample; copies keep that ID. IDs start at 1. Measurement construct indices separately range from 0 to 108. Prediction IDs omit the redundant domain prefix. Population IDs are condition:rN. No model, API or third-party Python package is needed. Sources remain unchanged. Disk-backed shuffling bounds memory usage; temporary files are removed on exit. Use the Chiron training entry point to infer loss masking from signal. An unmodified ShareGPT reader does not suppress CE on measurement-only examples. """ from __future__ import annotations import argparse from collections import Counter from contextlib import ExitStack import json import math from pathlib import Path import random import tempfile ROOT = Path(__file__).resolve().parents[1] SFT = ROOT / "data/sft" OUTPUT = SFT / "joint_train.jsonl" FIELDS = ("sample_id", "signal", "domain", "messages", "measurement") MEASUREMENT_SOURCES = ( ("item_response", 10900), ("llm_intensity", 15250), ("prediction_reuse", 23424), ("human_gold", 3499), ) def positive_integer(value): number = int(value) if number < 1: raise argparse.ArgumentTypeError("repeat counts must be positive integers") return number def load_vocab(): vocab = json.loads((ROOT / "data/raw/measurement/construct_vocab.json").read_text(encoding="utf-8")) if (not isinstance(vocab, dict) or len(vocab) != 109 or any(type(value) is not int for value in vocab.values()) or sorted(vocab.values()) != list(range(109))): raise ValueError("Expected 109 construct names with indices 0 through 108") return vocab def validate_row(row, vocab): """Reject invalid supervision instead of silently dropping or clipping it.""" if tuple(row) != FIELDS: raise ValueError("Expected exactly the five joint fields in their standard order") if row["signal"] not in {"prediction", "measurement", "population"}: raise ValueError("Unknown signal") if any(not isinstance(row[key], str) or not row[key].strip() for key in ("sample_id", "domain")): raise ValueError("Sample and domain identifiers must be nonempty strings") messages = row["messages"] if (not isinstance(messages, list) or len(messages) != 3 or any(not isinstance(m, dict) or set(m) != {"role", "content"} for m in messages) or [m["role"] for m in messages] != ["system", "user", "assistant"] or any(not isinstance(m["content"], str) for m in messages)): raise ValueError("Expected system, user, assistant messages with string content") if not messages[0]["content"].strip() or not messages[1]["content"].strip(): raise ValueError("Empty system or user input") user, assistant = messages[1]["content"], messages[2]["content"] if (user.count("") != 1 or user.count("") != 1 or user.index("") >= user.index("")): raise ValueError("Missing or ambiguous person-record boundary") measurement = row["measurement"] if not isinstance(measurement, dict) or set(measurement) != {"targets"} or not isinstance(measurement["targets"], list): raise ValueError("Measurement must contain a targets list, including when empty") targets = measurement["targets"] if row["signal"] == "measurement": if assistant != "" or not targets: raise ValueError("Measurement rows require targets and an empty assistant") elif not assistant.strip() or targets: raise ValueError("Prediction/population rows require an answer and no measurement targets") if "" in assistant or "" in assistant: raise ValueError("Reasoning tags are not direct SFT targets") ids = set() for target in targets: if not isinstance(target, dict) or set(target) != {"construct_id", "construct", "score"}: raise ValueError("Unexpected measurement target fields") cid, name, score = target["construct_id"], target["construct"], target["score"] if type(cid) is not int or not isinstance(name, str) or vocab.get(name) != cid or cid in ids: raise ValueError("Unknown, mismatched or duplicate construct") if type(score) not in (int, float) or not math.isfinite(score) or not -1 <= score <= 1: raise ValueError("Measurement scores must be finite and within [-1, 1]") ids.add(cid) def normalize(row, signal, index=None): if signal == "population": domain = index["study_id"] respondent = index["respondent_index"] if type(respondent) is not int or respondent < 1: raise ValueError("Population respondent indices must start at 1") sid = f"{index['condition_id']}:r{respondent}" else: domain, sid = row["domain"], row["sample_id"] if not isinstance(sid, str) or not isinstance(domain, str): raise ValueError("Expected string source identifiers") if signal == "prediction": prefix = domain + ":" if not sid.startswith(prefix): raise ValueError("Prediction source ID must carry its domain prefix") sid = sid[len(prefix):] if not sid.isdecimal() or int(sid) < 1: raise ValueError("Source sample IDs must start at 1") if signal == "measurement" and row.get("chiron_repr_only") is not True: raise ValueError("Measurement source is not marked measurement-only") return {"sample_id": sid, "signal": signal, "domain": domain, "messages": row["messages"], "measurement": row["measurement"] if signal == "measurement" else {"targets": []}} def build(output=OUTPUT, *, measurement_repeat=2, population_repeat=5, seed=42): if type(seed) is not int or any(type(n) is not int or n < 1 for n in (measurement_repeat, population_repeat)): raise ValueError("Seed must be an integer and repeat counts positive integers") output = Path(output).expanduser().resolve() if not output.is_relative_to(SFT) or output.parent != SFT or output.suffix != ".jsonl": raise ValueError("Joint output must be a .jsonl directly inside data/sft") vocab = load_vocab() sources = [(SFT / "prediction/train.jsonl", "prediction", 220096, 1)] sources += [(SFT / "measurement" / name / "train.jsonl", "measurement", count, measurement_repeat) for name, count in MEASUREMENT_SOURCES] sources += [(SFT / "population/train.jsonl", "population", 23191, population_repeat)] counts, target_counts = Counter(), Counter() seen_constructs = set() identities = {} offsets = [] temporary_output = None try: with ExitStack() as stack: spool = stack.enter_context(tempfile.TemporaryFile(mode="w+b", dir=SFT)) population_index = stack.enter_context((SFT / "population/train_index.jsonl").open(encoding="utf-8")) for path, signal, expected, repeat in sources: source_offsets = [] with path.open(encoding="utf-8") as handle: for number, line in enumerate(handle, 1): try: source = json.loads(line) index = None if signal == "population": index = json.loads(next(population_index)) if type(index["sample_id"]) is not int or index["sample_id"] != number: raise ValueError("Population index is not aligned to SFT row order") row = normalize(source, signal, index) validate_row(row, vocab) except (KeyError, TypeError, ValueError, StopIteration) as exc: raise ValueError(f"{path.relative_to(ROOT)} line {number}: {exc}") from exc payload = (json.dumps(row, ensure_ascii=False, allow_nan=False) + "\n").encode("utf-8") offset = spool.tell() identity = (signal, row["domain"], row["sample_id"]) if identity in identities: previous_offset, length = identities[identity] spool.seek(previous_offset) same = spool.read(length) == payload spool.seek(offset) if not same: raise ValueError(f"One sample ID refers to different content: {identity}") else: identities[identity] = (offset, len(payload)) spool.write(payload) source_offsets.append((offset, len(payload))) for target in row["measurement"]["targets"]: seen_constructs.add(target["construct_id"]) target_counts[target["construct_id"]] += repeat if len(source_offsets) != expected: raise ValueError(f"{path.relative_to(ROOT)}: expected {expected} rows, found {len(source_offsets)}") # Repeat the complete source block; source rows retain their order. offsets.extend(source_offsets * repeat) counts[signal] += expected * repeat if next(population_index, None) is not None: raise ValueError("Population index contains extra rows") if seen_constructs != set(range(109)): raise ValueError("The measurement mixture does not cover all 109 constructs") random.Random(seed).shuffle(offsets) with tempfile.NamedTemporaryFile(mode="wb", dir=SFT, prefix=".joint_train.", suffix=".tmp", delete=False) as handle: temporary_output = Path(handle.name) for offset, length in offsets: spool.seek(offset) payload = spool.read(length) if len(payload) != length: raise ValueError("Incomplete intermediate row") handle.write(payload) # Read the actual output before publishing it; invalid input leaves # any previous joint file untouched and all temporary files cleaned. actual = Counter() actual_targets = Counter() with temporary_output.open(encoding="utf-8") as handle: for line in handle: row = json.loads(line) validate_row(row, vocab) actual[row["signal"]] += 1 actual_targets.update(target["construct_id"] for target in row["measurement"]["targets"]) if actual != counts or actual_targets != target_counts: raise ValueError("Written mixture counts do not match the source recipe") temporary_output.replace(output) print(json.dumps({"output": str(output.relative_to(ROOT)), "rows": sum(counts.values()), "signals": dict(counts), "constructs": len(seen_constructs), "seed": seed}, ensure_ascii=False)) finally: if temporary_output is not None: temporary_output.unlink(missing_ok=True) return dict(counts) def main(): parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument("--measurement-repeat", type=positive_integer, default=2) parser.add_argument("--population-repeat", type=positive_integer, default=5) parser.add_argument("--seed", type=int, default=42) args = parser.parse_args() build(measurement_repeat=args.measurement_repeat, population_repeat=args.population_repeat, seed=args.seed) if __name__ == "__main__": main()