"""Pure input preparation and validation for Chiron evaluation datasets.""" from __future__ import annotations import json import math import re from prompt.base.prediction_sft import SYSTEM_PROMPT, USER_PROMPT def render_user_prompt(template, adapter, observations, questions): return (template .replace("{record_context}", adapter.record_context()) .replace("{observations}", adapter.format_observations_block(observations)) .replace("{questions}", adapter.format_question_block(questions))) def prepare_case(sample, sample_index, adapter, args): """Freeze the exact input and complete scoring denominator before requesting a model.""" observations = adapter.select_observations(sample, seed=args.seed, sample_index=sample_index) predictions = adapter.select_target_predictions( sample, seed=args.seed, sample_index=sample_index, min_questions=args.min_questions, max_questions=args.max_questions, ) if not observations or any(not isinstance(s, str) or not s.strip() for s in observations): raise ValueError("No usable observations") if not predictions or any(not p.ground_truth.strip() for p in predictions): raise ValueError("No usable prediction questions or ground truths") # Some adapters render a fixed question (for example Twitter), so their # raw question field can be empty. Preserve the adapter rendering policy. questions = [p.question for p in predictions] golds = [p.ground_truth for p in predictions] reference = adapter.score_predictions(golds, golds) failure_details = {"n_correct": 0} if "n_traits" in reference: failure_details["n_traits"] = reference["n_traits"] return { # A person can have several QA records; each input row is evaluated once. "domain": adapter.name, "row_id": sample_index + 1, "sample_id": str(adapter.get_sample_id(sample)), "data_source": sample.data_source, "split": sample.split, "messages": [ {"role": "system", "content": SYSTEM_PROMPT.strip()}, {"role": "user", "content": render_user_prompt( USER_PROMPT.strip(), adapter, observations, questions)}, ], "raw_output": "", "answer_text": "", "predictions": [], "questions": questions, "ground_truths": golds, "score": 0.0, "metric": adapter.metric_name(), "metric_details": failure_details, "n_questions": len(predictions), "n_observations": len(observations), "extra_info": sample.extra_info, } def read_records(path, limit=None): with path.open(encoding="utf-8") as handle: count = 0 for line in handle: if not line.strip(): continue if limit is not None and count >= limit: break row = json.loads(line) if not isinstance(row, dict): raise ValueError("Each evaluation row must be an object") count += 1 yield row def input_messages(messages): """Accept frozen system/user inputs, optionally followed by an empty SFT answer.""" if not isinstance(messages, list): raise ValueError("messages must contain system and user text") if any(not isinstance(m, dict) for m in messages): raise ValueError("Each message must be an object") messages = [dict(m) for m in messages] if messages and messages[-1].get("role") == "assistant": if messages[-1].get("content") != "": raise ValueError("Evaluation input must not contain an assistant answer") messages.pop() if [m.get("role") for m in messages] != ["system", "user"]: raise ValueError("Exactly one system message and one user message are required") if any(not isinstance(m.get("content"), str) or not m["content"].strip() for m in messages): raise ValueError("Message contents must be nonempty text") return [{"role": m["role"], "content": m["content"]} for m in messages] def prepare_measurement_case(row, index, vocab): if row.get("signal", "measurement") != "measurement": raise ValueError("Expected a measurement row") messages = input_messages(row.get("messages")) user = messages[1]["content"] if user.count("") != 1 or user.count("") != 1: raise ValueError("Measurement input requires one person_records block") if not user.split("", 1)[1].split("", 1)[0].strip(): raise ValueError("Person records are empty") if user.index("") < user.index(""): raise ValueError("Person record boundaries are reversed") measurement = row.get("measurement") if not isinstance(measurement, dict): raise ValueError("measurement must be an object containing targets") targets = measurement.get("targets") if not isinstance(targets, list) or not targets: raise ValueError("Measurement targets are required") names = {value: key for key, value in vocab.items()} seen, checked = set(), [] for target in targets: if not isinstance(target, dict): raise ValueError("Each measurement target must be an object") cid, name, score = target.get("construct_id"), target.get("construct"), target.get("score") if type(cid) is not int or cid not in names or cid in seen or name != names[cid]: raise ValueError("Target must use a unique ID and name from the 109-construct vocabulary") if type(score) not in (int, float) or not math.isfinite(score) or not -1 <= score <= 1: raise ValueError("Measurement target scores must be finite and in [-1, 1]") seen.add(cid) checked.append({"construct_id": cid, "construct": name, "gold": float(score)}) return {"domain": row["domain"], "row_id": index + 1, "sample_id": str(row.get("sample_id", index + 1)), "messages": messages, "targets": checked} def validate_population_studies(studies): """Validate complete study contracts before starting any generation.""" if not studies: raise ValueError("Test data is empty") seen_studies, seen_conditions, seen_cells, seen_effects, seen_indices = set(), set(), set(), set(), set() for study in studies: sid = study.get("domain") if not isinstance(sid, str) or not sid or sid in seen_studies: raise ValueError("Each population study must have a unique name") seen_studies.add(sid) if not isinstance(study.get("prompts"), list) or not study["prompts"]: raise ValueError(f"{sid}: condition prompts are required") if not isinstance(study.get("effects"), list) or not study["effects"]: raise ValueError(f"{sid}: human effect definitions are required") study_cells = set() for prompt in study["prompts"]: key = prompt.get("condition_key") if not isinstance(key, str) or not key or key in seen_conditions or prompt.get("study_id") != sid: raise ValueError(f"{sid}: invalid or duplicate condition") if not isinstance(prompt.get("condition_id"), str) or not prompt["condition_id"]: raise ValueError(f"{sid}: condition_id is required") seen_conditions.add(key) if type(prompt.get("original_n")) is not int or prompt["original_n"] < 1: raise ValueError(f"{key}: original_n must be a positive integer") prompt["messages"] = input_messages(prompt.get("messages")) if not isinstance(prompt.get("questions"), list) or not prompt["questions"]: raise ValueError(f"{key}: question definitions are required") # Each ordered Q block must have a corresponding answer-scale definition. numbers = [int(n) for n in re.findall(r"(?m)^Q(\d+)[.:]", prompt["messages"][1]["content"])] if numbers != list(range(1, len(prompt["questions"]) + 1)): raise ValueError(f"{key}: prompt question order does not match the definitions") for q in prompt["questions"]: cell = q.get("cell_id") if not isinstance(cell, str) or not cell or cell in seen_cells: raise ValueError(f"{key}: duplicate or missing cell_id") seen_cells.add(cell); study_cells.add(cell) options = q.get("options") if not isinstance(options, list) or not options: raise ValueError(f"{cell}: response options are required") ids = [o.get("id") for o in options] if any(type(i) is not int or i < 1 for i in ids) or len(ids) != len(set(ids)): raise ValueError(f"{cell}: option IDs must be unique positive integers") if any(type(o.get("analysis_value")) not in (int, float) or not math.isfinite(o["analysis_value"]) for o in options): raise ValueError(f"{cell}: finite analysis values are required") index = prompt.get("_eval_index") if type(index) is not int or index < 0 or index in seen_indices: raise ValueError("Population conditions require unique frozen _eval_index values") seen_indices.add(index) for effect in study["effects"]: key = effect.get("effect_key") if not isinstance(key, str) or not key or key in seen_effects or effect.get("study_id") != sid: raise ValueError(f"{sid}: invalid or duplicate effect") seen_effects.add(key) for field in ("human_target", "statistic_spec", "identifiability"): if not isinstance(effect.get(field), dict): raise ValueError(f"{key}: {field} is required") if effect.get("indicator") not in {"d", "b", "eta-square", "f", "chi-square"}: raise ValueError(f"{key}: unsupported effect indicator") if not effect.get("cells") or any(c.get("cell_id") not in study_cells for c in effect["cells"]): raise ValueError(f"{key}: effect references missing condition cells")