Datasets:
Download code/src/pvr_eval/question_eval/runner.py from wenjieshu/solveedit_benchmark_2728: direct link, hf CLI and curl.
- Browser
- Download file 7.04 kB
-
https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/question_eval/runner.py
- Command line
-
hf download hf://datasets/wenjieshu/solveedit_benchmark_2728/code/src/pvr_eval/question_eval/runner.py
-
curl -L -o runner.py https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/question_eval/runner.py
7.04 kB
| """Question-first v2 runner and role-aware score aggregation.""" | |
| from __future__ import annotations | |
| from dataclasses import dataclass | |
| from typing import Callable, Mapping, Sequence | |
| from pvr_eval.question_eval.dag import EvidenceDagExecutor, ExecutionContext, NodeAdapter | |
| from pvr_eval.question_eval.predicates import answer_deterministically | |
| from pvr_eval.question_eval.schema import AnswerRecord, EvidencePacket, EvalProcedure | |
| VlmAnswerer = Callable[[EvalProcedure, EvidencePacket, ExecutionContext], AnswerRecord] | |
| class QuestionEvalRunner: | |
| def __init__(self, adapters: Mapping[str, NodeAdapter], *, vlm_answerer: VlmAnswerer | None = None) -> None: | |
| self.executor = EvidenceDagExecutor(adapters) | |
| self.vlm_answerer = vlm_answerer | |
| def collect_evidence(self, procedure: EvalProcedure, context: ExecutionContext) -> EvidencePacket: | |
| if context.case_id != procedure.rubric.case_id or context.check_id != procedure.rubric.check_id: | |
| raise ValueError("execution context does not match question spec") | |
| results = self.executor.execute(procedure, context) | |
| required = {node.node_id for node in procedure.nodes if node.required} | |
| failed = [result for result in results if result.node_id in required and result.status != "success"] | |
| facts = {} | |
| artifacts = [] | |
| for result in results: | |
| if result.node_id == "derive_facts": | |
| facts.update(result.facts) | |
| artifacts.extend(result.artifacts) | |
| if not facts: | |
| for result in results: | |
| facts.update(result.facts) | |
| reasons = tuple( | |
| f"{result.node_id}:{result.status}:{'|'.join(result.limitations)}" for result in failed | |
| ) | |
| status = "success" if procedure.nodes and not failed else "insufficient" | |
| return EvidencePacket( | |
| case_id=context.case_id, | |
| check_id=context.check_id, | |
| procedure_hash=procedure.procedure_hash, | |
| nodes=results, | |
| derived_facts=facts, | |
| visual_artifacts=tuple(artifacts), | |
| status=status, | |
| reasons=reasons or (() if status == "success" else ("procedure_has_no_executable_evidence_nodes",)), | |
| ) | |
| def answer(self, procedure: EvalProcedure, packet: EvidencePacket, context: ExecutionContext) -> AnswerRecord: | |
| deterministic = answer_deterministically(procedure, packet) | |
| if deterministic.formal_eligible: | |
| return deterministic | |
| may_use_vlm = procedure.answer_mode in {"vlm_required", "deterministic_or_vlm"} | |
| if not may_use_vlm or self.vlm_answerer is None: | |
| return deterministic | |
| answer = self.vlm_answerer(procedure, packet, context) | |
| if packet.successful_call_ids and not (set(answer.cited_call_ids) & set(packet.successful_call_ids)): | |
| raise ValueError("VLM answer does not cite any successful evidence call from its packet") | |
| return answer | |
| def run(self, procedure: EvalProcedure, context: ExecutionContext) -> tuple[EvidencePacket, AnswerRecord]: | |
| packet = self.collect_evidence(procedure, context) | |
| return packet, self.answer(procedure, packet, context) | |
| def run_case( | |
| self, procedures: Sequence[EvalProcedure], contexts: Sequence[ExecutionContext] | |
| ) -> tuple[list[EvidencePacket], list[AnswerRecord]]: | |
| """Run a case, batching unresolved questions into one VLM request.""" | |
| if len(procedures) != len(contexts): | |
| raise ValueError("procedures and contexts must have equal length") | |
| packets = [self.collect_evidence(procedure, context) for procedure, context in zip(procedures, contexts)] | |
| answers: list[AnswerRecord | None] = [None] * len(procedures) | |
| unresolved: list[tuple[EvalProcedure, EvidencePacket, ExecutionContext]] = [] | |
| unresolved_indices: list[int] = [] | |
| for index, (procedure, packet, context) in enumerate(zip(procedures, packets, contexts)): | |
| deterministic = answer_deterministically(procedure, packet) | |
| if deterministic.formal_eligible or procedure.answer_mode not in {"vlm_required", "deterministic_or_vlm"}: | |
| answers[index] = deterministic | |
| else: | |
| unresolved.append((procedure, packet, context)) | |
| unresolved_indices.append(index) | |
| if unresolved and self.vlm_answerer is not None and hasattr(self.vlm_answerer, "answer_case"): | |
| batch_answers = self.vlm_answerer.answer_case(unresolved) # type: ignore[attr-defined] | |
| if len(batch_answers) != len(unresolved): | |
| raise ValueError("batch VLM answer count does not match unresolved question count") | |
| for index, answer in zip(unresolved_indices, batch_answers): | |
| answers[index] = answer | |
| else: | |
| for index in unresolved_indices: | |
| procedure, packet, context = procedures[index], packets[index], contexts[index] | |
| answers[index] = self.answer(procedure, packet, context) | |
| return packets, [answer for answer in answers if answer is not None] | |
| class ScoreSummary: | |
| reward_earned: float | |
| reward_possible: float | |
| penalty_deducted: float | |
| penalty_possible: float | |
| overall: float | |
| provisional_overall: float | |
| formal_eligible: bool | |
| unresolved: tuple[str, ...] | |
| manual_excluded: tuple[str, ...] | |
| def aggregate_answers(procedures: Sequence[EvalProcedure], answers: Sequence[AnswerRecord]) -> ScoreSummary: | |
| """Aggregate positive-satisfaction answers without reversing penalties early.""" | |
| by_key = {(answer.case_id, answer.check_id): answer for answer in answers} | |
| reward_earned = reward_possible = penalty_deducted = penalty_possible = 0.0 | |
| unresolved: list[str] = [] | |
| manual_excluded: list[str] = [] | |
| for procedure in procedures: | |
| rubric = procedure.rubric | |
| if procedure.compile_status == "manual_required" or procedure.answer_mode == "manual_only": | |
| manual_excluded.append(rubric.check_id) | |
| continue | |
| if rubric.role == "reward": | |
| reward_possible += rubric.weight | |
| else: | |
| penalty_possible += rubric.weight | |
| answer = by_key.get((rubric.case_id, rubric.check_id)) | |
| if answer is None or not answer.formal_eligible: | |
| unresolved.append(rubric.check_id) | |
| continue | |
| if rubric.role == "reward": | |
| reward_earned += rubric.weight * answer.score | |
| else: | |
| penalty_deducted += rubric.weight * (1.0 - answer.score) | |
| reward_score = reward_earned / reward_possible if reward_possible > 0 else 0.0 | |
| provisional = max(0.0, min(1.0, reward_score - penalty_deducted)) | |
| formal_eligible = not unresolved | |
| overall = provisional if formal_eligible else 0.0 | |
| return ScoreSummary( | |
| reward_earned, reward_possible, penalty_deducted, penalty_possible, | |
| overall, provisional, formal_eligible, tuple(unresolved), tuple(manual_excluded), | |
| ) | |