Download code/utils/evaluation_inputs.py from chiron-group/chiron-data: direct link, hf CLI and curl.
- Browser
- Download file 10.2 kB
-
https://huggingface.co/datasets/chiron-group/chiron-data/resolve/main/code/utils/evaluation_inputs.py
- Command line
-
hf download hf://datasets/chiron-group/chiron-data/code/utils/evaluation_inputs.py
-
curl -L -o evaluation_inputs.py https://huggingface.co/datasets/chiron-group/chiron-data/resolve/main/code/utils/evaluation_inputs.py
10.2 kB
| """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("<person_records>") != 1 or user.count("</person_records>") != 1: | |
| raise ValueError("Measurement input requires one person_records block") | |
| if not user.split("<person_records>", 1)[1].split("</person_records>", 1)[0].strip(): | |
| raise ValueError("Person records are empty") | |
| if user.index("</person_records>") < user.index("<person_records>"): | |
| 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") | |