Datasets:
Download code/src/pvr_eval/question_eval/compiler.py from wenjieshu/solveedit_benchmark_2728: direct link, hf CLI and curl.
- Browser
- Download file 22 kB
-
https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/question_eval/compiler.py
- Command line
-
hf download hf://datasets/wenjieshu/solveedit_benchmark_2728/code/src/pvr_eval/question_eval/compiler.py
-
curl -L -o compiler.py https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/question_eval/compiler.py
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) | |