wenjieshu's picture
Add files using upload-large-folder tool
b8ea052 verified
Raw History Blame Contribute Delete
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]
@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),
)