wenjieshu's picture
Add files using upload-large-folder tool
b8ea052 verified
Raw History Blame Contribute Delete
22 kB
"""Compile audited rubrics plus resolved plans into executable v2 procedures.
The compiler is deliberately conservative. A novel free-form decision-rule
name never becomes executable merely because it resembles a registered
checker. Only explicit normalizers may create deterministic predicates.
"""
from __future__ import annotations
from dataclasses import dataclass
from typing import Any, Mapping
from pvr_eval.question_eval.schema import DecisionSpec, EvidenceNodeSpec, PredicateSpec, QuestionRubric, QuestionSpec
OBJECT_CHECKERS = {
"object_zone_checker",
"object_presence_checker",
"object_preservation_checker",
"source_vacated_checker",
"forbidden_overlap",
"vehicle_slot_checker",
"vehicle_penalty_checker",
}
TEXT_CHECKERS = {"text_ocr_checker", "date_window_digit_checker"}
ROUTE_CHECKERS = {"route_mask_checker", "endpoint_checker", "line_connectivity_checker"}
STATE_CHECKERS = {
"state_checker",
"state_image_proxy_checker",
"symbol_checker",
"symbol_delta_checker",
"checkbox_symbol_checker",
"color_classifier",
"watch_hand_angle_parser",
}
PREDICATE_CHECKERS = {
"count_in_region": OBJECT_CHECKERS,
"source_normalized_clearance": OBJECT_CHECKERS,
"attribute_object_in_region": OBJECT_CHECKERS,
"text_match": TEXT_CHECKERS,
"change_fraction": {"preservation"},
}
CHECKER_TOOLS = {
"object": {"yolo_world_roi", "fastsam_roi", "object_fact_deriver"},
"text": {"rapidocr_roi"},
"preservation": {"image_registration", "change_analysis_roi"},
}
def _strings(value: Any) -> tuple[str, ...]:
if isinstance(value, str):
return tuple(item.strip() for item in value.split("|") if item.strip())
if isinstance(value, (list, tuple, set)):
return tuple(str(item).strip() for item in value if str(item).strip())
return ()
def _regions(check: Mapping[str, Any]) -> tuple[dict[str, Any], ...]:
raw = check.get("regions", [])
return tuple(dict(item) for item in raw if isinstance(item, Mapping) and (item.get("region_id") or item.get("id")))
def _region_ids(check: Mapping[str, Any], parameters: Mapping[str, Any]) -> tuple[str, ...]:
values = [str(item.get("region_id") or item.get("id")) for item in _regions(check)]
for key in ("search_scope", "slot", "target_region", "region_id"):
candidate = str(parameters.get(key) or "")
if not candidate or candidate in values:
continue
if not values:
values.append(candidate)
return tuple(dict.fromkeys(value for value in values if value))
def _manual_predicate(check: Mapping[str, Any]) -> PredicateSpec:
rule = check.get("decision_rule") if isinstance(check.get("decision_rule"), Mapping) else {}
return PredicateSpec(
kind="manual_review",
subject_queries=_strings(check.get("object_queries")),
region_ids=_region_ids(check, rule.get("parameters", {}) if isinstance(rule.get("parameters"), Mapping) else {}),
parameters={
"pass_condition": str(rule.get("pass_condition", "")),
"partial_condition": str(rule.get("partial_condition", "")),
"fail_condition": str(rule.get("fail_condition", "")),
},
deterministic=False,
source_rule_type=str(rule.get("type", "")),
)
def normalize_decision_spec(check: Mapping[str, Any]) -> tuple[DecisionSpec, tuple[str, ...]]:
explicit = check.get("decision_spec")
if isinstance(explicit, Mapping):
try:
spec = DecisionSpec.from_mapping(explicit)
except (TypeError, ValueError) as exc:
predicate = _manual_predicate(check)
reason = f"invalid_decision_spec:{type(exc).__name__}:{exc}"
return DecisionSpec("manual_only", predicate, manual_reasons=(reason,)), (reason,)
declared_regions = {str(item.get("region_id") or item.get("id")) for item in _regions(check)}
missing_regions = (set(spec.subject_region_ids) | set(spec.target_region_ids)) - declared_regions
if missing_regions:
reason = f"decision_spec_references_unknown_regions:{'|'.join(sorted(missing_regions))}"
predicate = _manual_predicate(check)
return DecisionSpec("manual_only", predicate, manual_reasons=(reason,)), (reason,)
checker = str(check.get("primary_checker") or "")
allowed_checkers = PREDICATE_CHECKERS.get(spec.predicate.kind, set())
if spec.mode == "objective" and checker not in allowed_checkers:
reason = f"objective_predicate_checker_mismatch:{spec.predicate.kind}:{checker or '<missing>'}"
predicate = _manual_predicate(check)
return DecisionSpec("manual_only", predicate, manual_reasons=(reason,)), (reason,)
if spec.mode == "objective" and not spec.target_region_ids and spec.predicate.kind in {
"count_in_region", "source_normalized_clearance", "attribute_object_in_region",
"text_match", "change_fraction",
}:
reason = "objective_decision_spec_missing_target_regions"
predicate = _manual_predicate(check)
return DecisionSpec("manual_only", predicate, manual_reasons=(reason,)), (reason,)
if spec.mode == "objective":
family = "object" if checker in OBJECT_CHECKERS else "text" if checker in TEXT_CHECKERS else "preservation"
unsupported_tools = set(spec.required_tools) - CHECKER_TOOLS[family]
if unsupported_tools:
reason = f"objective_decision_spec_has_unsupported_tools:{'|'.join(sorted(unsupported_tools))}"
predicate = _manual_predicate(check)
return DecisionSpec("manual_only", predicate, manual_reasons=(reason,)), (reason,)
return spec, tuple(spec.manual_reasons)
rule = check.get("decision_rule") if isinstance(check.get("decision_rule"), Mapping) else {}
rule_type = str(rule.get("type") or "")
parameters = dict(rule.get("parameters", {}) or {}) if isinstance(rule.get("parameters"), Mapping) else {}
subjects = _strings(check.get("object_queries"))
region_ids = _region_ids(check, parameters)
if rule_type == "forbidden_instance_count":
predicate = PredicateSpec(
kind="count_in_region",
metric="output_count_inside",
subject_queries=subjects,
region_ids=region_ids,
bands={
"pass": {"max": 0.0},
"partial": {"min": 1.0, "max": 2.0},
"fail": {"min": 3.0},
},
parameters={**parameters, "count_semantics": "forbidden_residual_instances"},
deterministic=True,
source_rule_type=rule_type,
)
return DecisionSpec("objective", predicate, target_region_ids=region_ids), ()
if rule_type == "nonexempt_center_object_count":
predicate = PredicateSpec(
kind="count_in_region",
metric="output_count_inside",
subject_queries=subjects,
region_ids=region_ids,
bands={
"pass": {"max": 0.0},
"partial": {"min": 1.0, "max": 1.0},
"fail": {"min": 2.0},
},
parameters={**parameters, "count_semantics": "nonexempt_residual_instances"},
deterministic=True,
source_rule_type=rule_type,
)
return DecisionSpec("objective", predicate, target_region_ids=region_ids), ()
if rule_type == "source_normalized_zone_clearance":
partial_max = float(parameters.get("partial_remaining_fraction_max", 0.4))
predicate = PredicateSpec(
kind="source_normalized_clearance",
metric="remaining_fraction",
subject_queries=subjects,
region_ids=region_ids,
bands={
"pass": {"max": 0.0},
"partial": {"min": 1e-12, "max": partial_max},
"fail": {"min": partial_max + 1e-12},
},
parameters=parameters,
deterministic=True,
source_rule_type=rule_type,
)
return DecisionSpec("objective", predicate, target_region_ids=region_ids), ()
if rule_type == "assigned_vehicle_slot_predicate":
pass_containment = float(parameters.get("pass_mask_containment", 0.85))
partial_containment = float(parameters.get("partial_mask_containment", 0.65))
predicate = PredicateSpec(
kind="attribute_object_in_region",
metric="mask_containment",
subject_queries=subjects,
region_ids=region_ids,
bands={
"pass": {"min": pass_containment},
"partial": {"min": partial_containment, "max": pass_containment - 1e-12},
"fail": {"max": partial_containment - 1e-12},
},
parameters=parameters,
deterministic=True,
source_rule_type=rule_type,
)
return DecisionSpec("objective", predicate, target_region_ids=region_ids), ()
predicate = _manual_predicate(check)
reason = "unregistered_decision_rule" if rule_type else "missing_decision_rule_type"
detail = f"{reason}:{rule_type or '<missing>'}"
return DecisionSpec("manual_only", predicate, manual_reasons=(detail,)), (detail,)
def normalize_predicate(check: Mapping[str, Any]) -> tuple[PredicateSpec, tuple[str, ...]]:
"""Compatibility wrapper returning the predicate from the decision spec."""
decision, reasons = normalize_decision_spec(check)
return decision.predicate, reasons
def _region_node(region: Mapping[str, Any]) -> EvidenceNodeSpec:
region_id = str(region.get("region_id") or region.get("id"))
method = str(region.get("proposal_method") or "")
has_geometry = any(region.get(key) for key in ("bbox", "rect", "polygon", "points"))
if has_geometry or method in {"manual_bbox", "manual_polygon"}:
tool = "contract_region"
elif "vlm" in method:
tool = "vlm_region_proposer"
else:
tool = "grounding_dino_region"
roles = _strings(region.get("source_image")) or ("pred",)
if roles == ("both",):
roles = ("input", "pred")
return EvidenceNodeSpec(
node_id=f"region:{region_id}",
operation="resolve_region",
tool=tool,
image_roles=roles,
region_ids=(region_id,),
parameters={
"proposal_method": method,
"query_or_rule": str(region.get("query_or_rule") or ""),
"description": str(region.get("description") or ""),
**{key: region[key] for key in ("bbox", "rect", "polygon", "points") if key in region},
},
)
def build_evidence_nodes(check: Mapping[str, Any], predicate: PredicateSpec) -> tuple[EvidenceNodeSpec, ...]:
checker = str(check.get("primary_checker") or "vlm_audit")
relevant_region_ids = set(predicate.region_ids)
region_nodes_list = [
_region_node(region)
for region in _regions(check)
if not relevant_region_ids or str(region.get("region_id") or region.get("id")) in relevant_region_ids
]
if predicate.kind in {"count_in_region", "attribute_object_in_region", "text_match"}:
region_nodes_list = [
EvidenceNodeSpec(
node_id=node.node_id,
operation=node.operation,
tool=node.tool,
image_roles=("pred",),
depends_on=node.depends_on,
region_ids=node.region_ids,
inputs=node.inputs,
required=node.required,
parameters=node.parameters,
)
for node in region_nodes_list
]
elif predicate.kind == "source_normalized_clearance":
region_nodes_list = [
EvidenceNodeSpec(
node_id=node.node_id,
operation=node.operation,
tool=node.tool,
image_roles=("input", "pred"),
depends_on=node.depends_on,
region_ids=node.region_ids,
inputs=node.inputs,
required=node.required,
parameters=node.parameters,
)
for node in region_nodes_list
]
# Resolved parking plans keep the authoritative slot bbox in the decision
# rule rather than duplicating it in the region proposal. Copy it into the
# executable region node so replay never has to parse prose.
slot_bbox = predicate.parameters.get("slot_bbox")
slot_id = str(predicate.parameters.get("slot") or "")
if isinstance(slot_bbox, (list, tuple)) and len(slot_bbox) == 4:
for index, node in enumerate(region_nodes_list):
if not slot_id or slot_id in node.region_ids or f"{slot_id}_exact" in node.region_ids:
region_nodes_list[index] = EvidenceNodeSpec(
node_id=node.node_id,
operation=node.operation,
tool="contract_region",
image_roles=node.image_roles,
depends_on=node.depends_on,
region_ids=node.region_ids,
inputs=node.inputs,
required=node.required,
parameters={**node.parameters, "bbox": list(slot_bbox)},
)
region_nodes = tuple(region_nodes_list)
region_dependencies = tuple(node.node_id for node in region_nodes)
declared_region_ids = tuple(node.region_ids[0] for node in region_nodes)
region_ids = predicate.region_ids or declared_region_ids
query_params = {
"queries": list(predicate.subject_queries),
"roi_required": bool(region_ids),
"roi_region_ids": list(region_ids),
}
if checker in OBJECT_CHECKERS:
detect = EvidenceNodeSpec(
node_id="detect_objects",
operation="detect_objects",
tool="yolo_world_roi",
image_roles=("input", "pred") if checker in {"object_preservation_checker", "source_vacated_checker"} else ("pred",),
depends_on=region_dependencies,
region_ids=region_ids,
inputs=tuple(f"roi:{region_id}" for region_id in region_ids),
parameters=query_params,
)
mask = EvidenceNodeSpec(
node_id="refine_masks",
operation="refine_masks",
tool="fastsam_roi",
image_roles=detect.image_roles,
depends_on=(*region_dependencies, detect.node_id),
region_ids=region_ids,
inputs=("detections:detect_objects",),
parameters={"bbox_fallback_allowed": False},
)
derive = EvidenceNodeSpec(
node_id="derive_facts",
operation="derive_predicate_facts",
tool="object_fact_deriver",
image_roles=detect.image_roles,
depends_on=(*region_dependencies, detect.node_id, mask.node_id),
region_ids=region_ids,
inputs=("detections:detect_objects", "masks:refine_masks"),
parameters={"predicate": predicate.to_dict()},
)
overlay = EvidenceNodeSpec(
node_id="render_overlay",
operation="render_evidence_overlay",
tool="overlay_renderer",
image_roles=("pred",),
depends_on=(*region_dependencies, derive.node_id),
region_ids=region_ids,
inputs=("facts:derive_facts",),
)
return (*region_nodes, detect, mask, derive, overlay)
if checker in TEXT_CHECKERS:
ocr = EvidenceNodeSpec(
node_id="read_text",
operation="ocr",
tool="rapidocr_roi",
image_roles=("pred",),
depends_on=region_dependencies,
region_ids=region_ids,
inputs=tuple(f"roi:{region_id}" for region_id in region_ids),
parameters={"predicate": predicate.to_dict()},
)
overlay = EvidenceNodeSpec(
node_id="render_overlay",
operation="render_evidence_overlay",
tool="overlay_renderer",
image_roles=("pred",),
depends_on=(*region_dependencies, ocr.node_id),
region_ids=region_ids,
parameters={"predicate": predicate.to_dict()},
)
return (*region_nodes, ocr, overlay)
if checker in ROUTE_CHECKERS:
route = EvidenceNodeSpec(
node_id="parse_route",
operation="parse_route",
tool="route_parser_roi",
image_roles=("pred",),
depends_on=region_dependencies,
region_ids=region_ids,
inputs=tuple(f"roi:{region_id}" for region_id in region_ids),
)
overlay = EvidenceNodeSpec(
node_id="render_overlay",
operation="render_evidence_overlay",
tool="overlay_renderer",
image_roles=("pred",),
depends_on=(*region_dependencies, route.node_id),
region_ids=region_ids,
)
return (*region_nodes, route, overlay)
if checker == "preservation":
registration = EvidenceNodeSpec(
node_id="register_images",
operation="image_registration",
tool="image_registration",
image_roles=("input", "pred"),
)
change = EvidenceNodeSpec(
node_id="measure_change",
operation="change_analysis",
tool="change_analysis_roi",
image_roles=("input", "pred"),
# The cached change-analysis row already contains exact metrics
# keyed by the contract region IDs. Re-resolving those regions is
# unnecessary and can invalidate otherwise auditable evidence.
depends_on=(registration.node_id,),
region_ids=region_ids,
parameters={"predicate": predicate.to_dict()},
)
overlay = EvidenceNodeSpec(
node_id="render_overlay",
operation="render_evidence_overlay",
tool="overlay_renderer",
image_roles=("pred",),
depends_on=(change.node_id,),
region_ids=region_ids,
)
return (registration, change, overlay)
if checker in STATE_CHECKERS:
parser = EvidenceNodeSpec(
node_id="parse_state",
operation="parse_state",
tool="structured_state_parser",
image_roles=("pred",),
depends_on=region_dependencies,
region_ids=region_ids,
)
overlay = EvidenceNodeSpec(
node_id="render_overlay",
operation="render_evidence_overlay",
tool="overlay_renderer",
image_roles=("pred",),
depends_on=(*region_dependencies, parser.node_id),
region_ids=region_ids,
)
return (*region_nodes, parser, overlay)
crop = EvidenceNodeSpec(
node_id="render_overlay",
operation="render_evidence_overlay",
tool="overlay_renderer",
image_roles=("input", "pred"),
depends_on=region_dependencies,
region_ids=region_ids,
parameters={"semantic_vlm_packet": True},
)
return (*region_nodes, crop)
def _contract_questions(contract: Mapping[str, Any]) -> dict[str, Mapping[str, Any]]:
questions = list(contract.get("atomic_checks", []))
if not questions:
questions = [
*({"role": "reward", **item} for item in contract.get("reward_questions", []) if isinstance(item, Mapping)),
*({"role": "penalty", **item} for item in contract.get("penalty_questions", []) if isinstance(item, Mapping)),
]
return {str(item.get("id") or item.get("check_id")): item for item in questions if isinstance(item, Mapping)}
def compile_case(contract: Mapping[str, Any], resolved_plan: Mapping[str, Any]) -> tuple[QuestionSpec, ...]:
case_id = str(contract.get("case_id") or resolved_plan.get("case_id") or "")
questions = _contract_questions(contract)
procedures: list[QuestionSpec] = []
seen: set[str] = set()
for check in resolved_plan.get("checks", []):
if not isinstance(check, Mapping):
continue
check_id = str(check.get("id") or "")
source = questions.get(check_id)
if source is None:
continue
seen.add(check_id)
rubric = QuestionRubric.from_contract_item(case_id, source)
decision_spec, reasons = normalize_decision_spec(check)
predicate = decision_spec.predicate
answer_mode = "deterministic" if decision_spec.mode == "objective" else "manual_only"
procedures.append(
QuestionSpec(
rubric=rubric,
predicate=predicate,
nodes=build_evidence_nodes(check, predicate),
answer_mode=answer_mode,
compile_status="executable" if decision_spec.mode == "objective" else "manual_required",
compile_reasons=reasons,
gt_policy="not_allowed",
source_decision_rule=dict(check.get("decision_rule", {}) or {}),
decision_spec=decision_spec,
)
)
for check_id, source in questions.items():
if check_id in seen:
continue
rubric = QuestionRubric.from_contract_item(case_id, source)
predicate = PredicateSpec(kind="manual_review", deterministic=False, source_rule_type="")
reason = "missing_resolved_check"
decision_spec = DecisionSpec("manual_only", predicate, manual_reasons=(reason,))
procedures.append(
QuestionSpec(
rubric=rubric,
predicate=predicate,
nodes=(),
answer_mode="manual_only",
compile_status="manual_required",
compile_reasons=(reason,),
gt_policy="not_allowed",
decision_spec=decision_spec,
)
)
return tuple(procedures)