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),
    )