| """Exact BFS difficulty under the benchmark action set and IoU success rule.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import hashlib |
| import json |
| import platform |
| import sys |
| import time |
| from collections import deque |
| from pathlib import Path |
| from typing import Any |
|
|
| from benchmark_core import ( |
| Pose, |
| _euler_to_matrix, |
| _mat_mul, |
| _rot_x, |
| _rot_y, |
| _rot_z, |
| iou, |
| render_views_fast, |
| ) |
| try: |
| import cv2 |
| import numpy as np |
| import torch |
| from benchmark_core import _prepare_spherical_cuda_geometry, _cuda_disk_offsets |
| except Exception: |
| cv2 = None |
| np = None |
| torch = None |
| _prepare_spherical_cuda_geometry = None |
| _cuda_disk_offsets = None |
|
|
| ANGLES = (30,) |
| ACTION_DIRECTIONS = ( |
| ("PITCH_POS", _rot_x), |
| ("PITCH_NEG", lambda x: _rot_x(-x)), |
| ("YAW_POS", _rot_y), |
| ("YAW_NEG", lambda x: _rot_y(-x)), |
| ("ROLL_POS", _rot_z), |
| ("ROLL_NEG", lambda x: _rot_z(-x)), |
| ) |
| INVERSE_AXIS = { |
| "PITCH_POS": "PITCH_NEG", "PITCH_NEG": "PITCH_POS", |
| "YAW_POS": "YAW_NEG", "YAW_NEG": "YAW_POS", |
| "ROLL_POS": "ROLL_NEG", "ROLL_NEG": "ROLL_POS", |
| } |
|
|
|
|
| def matrix_key(matrix) -> tuple[int, ...]: |
| return tuple(round(value * 1_000_000_000) for row in matrix for value in row) |
|
|
|
|
| def apply_matrix(matrix, delta): |
| return _mat_mul(delta, matrix) |
|
|
|
|
| def action_deltas() -> tuple[tuple[str, int, tuple[tuple[float, ...], ...]], ...]: |
| return tuple((axis, angle, fn(angle)) for axis, fn in ACTION_DIRECTIONS for angle in ANGLES) |
|
|
|
|
| DELTAS = action_deltas() |
|
|
|
|
| def resolve_size(value: Any) -> tuple[int, int]: |
| if isinstance(value, dict): |
| return int(value.get("width", 640)), int(value.get("height", 360)) |
| if isinstance(value, (list, tuple)): |
| return int(value[0]), int(value[1]) |
| return int(value or 640), int(value or 640) |
|
|
|
|
| def score_batch_cuda(task: dict[str, Any], matrices: list, target_eval) -> list[float] | None: |
| if torch is None or cv2 is None or np is None or not torch.cuda.is_available(): |
| return None |
| geometry = _prepare_spherical_cuda_geometry(task) |
| if geometry is None: |
| return None |
| eval_size = int(task.get("eval_size", 320)) |
| ew = eh = eval_size |
| scale = min(ew, eh) / 64.0 |
| cx, cy = ew / 2.0, eh / 2.0 |
| radius = max(1, int(round(scale * (0.36 if task.get("source_dataset") == "game_icons" else 0.2)))) |
| ox, oy, _ = _cuda_disk_offsets(radius) |
| target = target_eval > 0 |
| outputs = [] |
| candidate_batch = max(1, int(task.get("bfs_candidate_batch_size", 4))) |
| point_batch = max(20_000, int(task.get("cuda_point_batch_size", 800_000))) |
| kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)) |
| for candidate_start in range(0, len(matrices), candidate_batch): |
| candidate_matrices = matrices[candidate_start : candidate_start + candidate_batch] |
| candidate_count = len(candidate_matrices) |
| pose_tensor = torch.as_tensor(np.asarray(candidate_matrices), dtype=torch.float32, device="cuda") |
| masks = torch.zeros((candidate_count, ew * eh), dtype=torch.uint8, device="cuda") |
| for start in range(0, int(geometry.shape[0]), point_batch): |
| points = geometry[start : start + point_batch] |
| coords = torch.matmul(points[None, :, :], pose_tensor.transpose(1, 2)) |
| xi = torch.round(cx + coords[:, :, 0] * scale).to(torch.int64) |
| yi = torch.round(cy + coords[:, :, 1] * scale).to(torch.int64) |
| for offset_x, offset_y in zip(ox, oy): |
| xx = xi + offset_x |
| yy = yi + offset_y |
| valid = (xx >= 0) & (xx < ew) & (yy >= 0) & (yy < eh) |
| flat = yy.clamp(0, eh - 1) * ew + xx.clamp(0, ew - 1) |
| values = valid.to(dtype=torch.uint8) * 255 |
| masks.scatter_reduce_(1, flat, values, reduce="amax", include_self=True) |
| masks = masks.reshape(candidate_count, eh, ew).cpu().numpy() |
| for mask in masks: |
| closed = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel, iterations=1) |
| a = closed > 0 |
| b = target |
| union = np.count_nonzero(a | b) |
| outputs.append(float(np.count_nonzero(a & b) / union) if union else 1.0) |
| return outputs |
|
|
|
|
| def search_task(task: dict[str, Any], max_depth: int = 16) -> dict[str, Any]: |
| started = time.perf_counter() |
| target = Pose.from_dict(task["target_pose"]) |
| initial = Pose.from_dict(task["init_pose"]) |
| display_size = resolve_size(task.get("display_size")) |
| eval_size = int(task.get("eval_size", 320)) |
| threshold = float(task.get("tau_success", 0.9)) |
| _, target_eval, _ = render_views_fast( |
| task, target, display_size=display_size, eval_size=eval_size, need_oblique=False |
| ) |
|
|
| initial_matrix = _euler_to_matrix(initial.roll, initial.pitch, initial.yaw) |
| frontier = [(initial_matrix, None)] |
| visited = {matrix_key(initial_matrix)} |
| expanded = 0 |
| best_iou = -1.0 |
| best_depth = None |
| for depth in range(max_depth + 1): |
| if not frontier: |
| break |
| matrices = [item[0] for item in frontier] |
| scores = score_batch_cuda(task, matrices, target_eval) |
| if scores is None: |
| scores = [] |
| for matrix in matrices: |
| roll, pitch, yaw = _matrix_to_euler_local(matrix) |
| _, current_eval, _ = render_views_fast( |
| task, Pose(roll, pitch, yaw), display_size=display_size, eval_size=eval_size, need_oblique=False |
| ) |
| scores.append(float(iou(target_eval, current_eval))) |
| expanded += len(frontier) |
| for current_iou in scores: |
| if current_iou > best_iou: |
| best_iou = current_iou |
| best_depth = depth |
| success_indices = [index for index, value in enumerate(scores) if value >= threshold] |
| if success_indices: |
| index = success_indices[0] |
| return { |
| "sample_id": str(task["sample_id"]), |
| "bfs_iou_optimal_steps": depth, |
| "success_iou": round(scores[index], 9), |
| "expanded_states": expanded, |
| "visited_states": len(visited), |
| "search_status": "success", |
| "elapsed_seconds": round(time.perf_counter() - started, 6), |
| } |
| if depth >= max_depth: |
| continue |
| next_frontier = [] |
| for matrix, previous_action in frontier: |
| for axis, angle, delta in DELTAS: |
| if previous_action and (axis, angle) == (INVERSE_AXIS[previous_action[0]], previous_action[1]): |
| continue |
| next_matrix = apply_matrix(matrix, delta) |
| key = matrix_key(next_matrix) |
| if key in visited: |
| continue |
| visited.add(key) |
| next_frontier.append((next_matrix, (axis, angle))) |
| frontier = next_frontier |
| return { |
| "sample_id": str(task["sample_id"]), |
| "bfs_iou_optimal_steps": None, |
| "success_iou": round(best_iou, 9), |
| "best_depth": best_depth, |
| "expanded_states": expanded, |
| "visited_states": len(visited), |
| "search_status": "not_found_within_depth", |
| "elapsed_seconds": round(time.perf_counter() - started, 6), |
| } |
|
|
|
|
| def _matrix_to_euler_local(matrix): |
| value = max(-1.0, min(1.0, -matrix[2][0])) |
| import math |
| pitch = math.degrees(math.asin(value)) |
| cosine = math.cos(math.radians(pitch)) |
| if abs(cosine) < 1e-8: |
| return 0.0, pitch, math.degrees(math.atan2(-matrix[0][1], matrix[1][1])) |
| roll = math.degrees(math.atan2(matrix[2][1], matrix[2][2])) |
| yaw = math.degrees(math.atan2(matrix[1][0], matrix[0][0])) |
| return roll, pitch, yaw |
|
|
|
|
| def sha256_file(path: Path) -> str: |
| h = hashlib.sha256() |
| with path.open("rb") as f: |
| for chunk in iter(lambda: f.read(1024 * 1024), b""): |
| h.update(chunk) |
| return h.hexdigest() |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--tasks-file", default="data/tasks_674.jsonl") |
| parser.add_argument("--output", default="artifacts/bfs_iou_v1/results.jsonl") |
| parser.add_argument("--limit", type=int, default=0) |
| parser.add_argument("--ids-file", default="", help="JSON split file containing sample_ids") |
| parser.add_argument("--upper-bounds-csv", default="", help="CSV containing sample_id and bfs_optimal_steps") |
| parser.add_argument("--max-depth", type=int, default=16) |
| args = parser.parse_args() |
| tasks_path = Path(args.tasks_file) |
| selected_ids = None |
| if args.ids_file: |
| split_payload = json.loads(Path(args.ids_file).read_text(encoding="utf-8")) |
| selected_ids = {str(value) for value in split_payload["sample_ids"]} |
| upper_bounds = {} |
| if args.upper_bounds_csv: |
| with Path(args.upper_bounds_csv).open(encoding="utf-8", newline="") as handle: |
| for row in csv.DictReader(handle): |
| upper_bounds[str(row["sample_id"])] = int(row["bfs_optimal_steps"]) |
| output = Path(args.output) |
| output.parent.mkdir(parents=True, exist_ok=True) |
| count = 0 |
| completed_ids = set() |
| if output.exists(): |
| with output.open(encoding="utf-8") as handle: |
| completed_ids = {str(json.loads(line)["sample_id"]) for line in handle if line.strip()} |
| mode = "a" if output.exists() else "w" |
| selected_tasks = [] |
| with tasks_path.open(encoding="utf-8") as source: |
| for line in source: |
| if not line.strip(): |
| continue |
| task = json.loads(line) |
| if selected_ids is not None and str(task["sample_id"]) not in selected_ids: |
| continue |
| if str(task["sample_id"]) in completed_ids: |
| continue |
| selected_tasks.append(task) |
| selected_tasks.sort(key=lambda task: (upper_bounds.get(str(task["sample_id"]), args.max_depth), str(task["sample_id"]))) |
| with output.open(mode, encoding="utf-8") as dest: |
| for task in selected_tasks: |
| if args.limit and count >= args.limit: |
| break |
| task_max_depth = min(args.max_depth, upper_bounds.get(str(task["sample_id"]), args.max_depth)) |
| print(json.dumps({"event": "start_task", "sample_id": task["sample_id"], "max_depth": task_max_depth}), flush=True) |
| result = search_task(task, task_max_depth) |
| dest.write(json.dumps(result, ensure_ascii=False) + "\n") |
| dest.flush() |
| count += 1 |
| print(json.dumps(result, ensure_ascii=False), flush=True) |
| print(json.dumps({"processed": count, "angles": list(ANGLES), "output": str(output)}, ensure_ascii=False)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
