Datasets:
File size: 7,038 Bytes
b8ea052 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 | """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]
@dataclass(frozen=True)
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),
)
|