"""Deterministic pose-guided beam search for reference task difficulty.""" from __future__ import annotations import argparse import json import time from collections import defaultdict from pathlib import Path from typing import Any from tqdm import tqdm from benchmark_core import Pose, _euler_to_matrix, _mat_mul, get_last_render_backend, iou, render_views_fast from bfs_iou_oracle import ACTION_DIRECTIONS, INVERSE_AXIS, _matrix_to_euler_local, matrix_key, resolve_size, score_batch_cuda from guided_iou_bfs import ( CANONICAL_TASK_COUNT, CANONICAL_TASKS_SHA256, guided_actions, reconstruct_path, sha256_file, transpose, ) from render_protocol import ( RENDER_PARAMETER_SCHEMA, STANDARD_CANDIDATE_BATCH_SIZE, STANDARD_DISPLAY_SIZE, STANDARD_IMAGE_SIZE, require_cuda_backend, STANDARD_POINT_BATCH_SIZE, ) try: import torch except Exception: torch = None def residual_bucket(matrix, target_matrix, bucket_degrees: int) -> tuple[int, int, int]: relative = _mat_mul(target_matrix, transpose(matrix)) residual = _matrix_to_euler_local(relative) return tuple(round(value / bucket_degrees) for value in residual) def residual_magnitude(matrix, target_matrix) -> float: relative = _mat_mul(target_matrix, transpose(matrix)) return sum(abs(value) for value in _matrix_to_euler_local(relative)) def prefilter_candidates(candidates, limit: int): if len(candidates) <= limit: return candidates by_parent = defaultdict(list) parent_scores = {} for candidate in candidates: parent_key, parent_score = candidate[3], candidate[4] by_parent[parent_key].append(candidate) parent_scores[parent_key] = parent_score parent_keys = sorted(by_parent, key=lambda key: (-parent_scores[key], key)) for values in by_parent.values(): values.sort(key=lambda item: (item[5], item[1])) selected = [] child_rank = 0 while len(selected) < limit: added = False for parent_key in parent_keys: values = by_parent[parent_key] if child_rank < len(values): selected.append(values[child_rank]) added = True if len(selected) == limit: break if not added: break child_rank += 1 return selected def select_beam(frontier, scores, target_matrix, beam_width: int, bucket_degrees: int, max_per_bucket: int): ranked = sorted(range(len(frontier)), key=lambda index: (-scores[index], frontier[index][1])) selected = [] selected_set = set() bucket_counts = defaultdict(int) for index in ranked: bucket = residual_bucket(frontier[index][0], target_matrix, bucket_degrees) if bucket_counts[bucket] >= max_per_bucket: continue selected.append(index) selected_set.add(index) bucket_counts[bucket] += 1 if len(selected) == beam_width: break if len(selected) < beam_width: for index in ranked: if index not in selected_set: selected.append(index) if len(selected) == beam_width: break return selected def score_frontier(task, frontier, target_eval, display_size, eval_size, score_chunk_size, threshold): all_scores = [] success_index = None success_iou = None for chunk_start in range(0, len(frontier), score_chunk_size): chunk = frontier[chunk_start : chunk_start + score_chunk_size] matrices = [item[0] for item in chunk] 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))) all_scores.extend(scores) for chunk_index, value in enumerate(scores): if value >= threshold: success_index = chunk_start + chunk_index success_iou = value break if success_index is not None: break return all_scores, success_index, success_iou def search_task( task: dict[str, Any], *, beam_width: int, max_scored_per_depth: int, max_depth: int, max_states: int, score_chunk_size: int, bucket_degrees: int, max_per_bucket: int, ) -> dict[str, Any]: started = time.perf_counter() target_pose = Pose.from_dict(task["target_pose"]) initial_pose = Pose.from_dict(task["init_pose"]) display_size = STANDARD_DISPLAY_SIZE eval_size = STANDARD_IMAGE_SIZE threshold = float(task.get("tau_success", 0.9)) _, target_eval, _ = render_views_fast( task, target_pose, display_size=display_size, eval_size=eval_size, need_oblique=False ) require_cuda_backend(get_last_render_backend(), context="Beam target renderer") target_matrix = _euler_to_matrix(target_pose.roll, target_pose.pitch, target_pose.yaw) initial_matrix = _euler_to_matrix(initial_pose.roll, initial_pose.pitch, initial_pose.yaw) initial_key = matrix_key(initial_matrix) frontier = [(initial_matrix, initial_key, None)] visited = {initial_key} parents = {initial_key: None} layer_stats = [] best_iou = -1.0 best_depth = 0 if torch is not None and torch.cuda.is_available(): torch.cuda.reset_peak_memory_stats() for depth in range(max_depth + 1): score_started = time.perf_counter() scores, success_index, success_iou = score_frontier( task, frontier, target_eval, display_size, eval_size, score_chunk_size, threshold ) layer_best = max(scores) if layer_best > best_iou: best_iou, best_depth = layer_best, depth layer = { "depth": depth, "candidate_states": len(frontier), "scored_states": len(scores), "score_seconds": round(time.perf_counter() - score_started, 6), "best_iou": round(layer_best, 9), } layer_stats.append(layer) if success_index is not None: elapsed = time.perf_counter() - started return { "sample_id": task["sample_id"], "beam_width": beam_width, "search_status": "success", "reference_steps": depth, "success_iou": round(float(success_iou), 9), "path": reconstruct_path(parents, frontier[success_index][1]), "expanded_states": sum(row["scored_states"] for row in layer_stats), "visited_states": len(visited), "elapsed_seconds": round(elapsed, 6), "layer_stats": layer_stats, "gpu_peak_reserved_gb": round(torch.cuda.max_memory_reserved() / 1024**3, 6) if torch is not None and torch.cuda.is_available() else 0.0, } if depth >= max_depth: break selected_indices = select_beam( frontier, scores, target_matrix, beam_width, bucket_degrees, max_per_bucket ) selected = [(frontier[index], scores[index]) for index in selected_indices] layer["retained_states"] = len(selected) generation_started = time.perf_counter() candidates = [] for (matrix, key, previous_action), parent_score in selected: for axis, angle, delta in guided_actions(matrix, target_matrix, 1): if previous_action == (INVERSE_AXIS[axis], angle): continue next_matrix = _mat_mul(delta, matrix) next_key = matrix_key(next_matrix) if next_key in visited: continue visited.add(next_key) parents[next_key] = (key, axis, angle) candidates.append(( next_matrix, next_key, (axis, angle), key, parent_score, residual_magnitude(next_matrix, target_matrix), )) if len(visited) >= max_states: return { "sample_id": task["sample_id"], "beam_width": beam_width, "search_status": "state_limit_reached", "reference_steps": None, "best_iou": round(best_iou, 9), "best_depth": best_depth, "expanded_states": sum(row["scored_states"] for row in layer_stats), "visited_states": len(visited), "elapsed_seconds": round(time.perf_counter() - started, 6), "layer_stats": layer_stats, } layer["generated_states"] = len(candidates) candidates = prefilter_candidates(candidates, max_scored_per_depth) layer["candidates_after_prefilter"] = len(candidates) layer["generation_seconds"] = round(time.perf_counter() - generation_started, 6) frontier = [(item[0], item[1], item[2]) for item in candidates] if not frontier: break return { "sample_id": task["sample_id"], "beam_width": beam_width, "search_status": "not_found_within_depth", "reference_steps": None, "best_iou": round(best_iou, 9), "best_depth": best_depth, "expanded_states": sum(row["scored_states"] for row in layer_stats), "visited_states": len(visited), "elapsed_seconds": round(time.perf_counter() - started, 6), "layer_stats": layer_stats, } def main() -> None: parser = argparse.ArgumentParser(description="Deterministic guided IoU beam calibration") parser.add_argument("--tasks-file", default="data/tasks_674.jsonl") parser.add_argument("--ids", default="", help="Comma-separated IDs; empty or 'all' selects all canonical tasks") parser.add_argument("--beam-widths", default="256") parser.add_argument("--max-scored-per-depth", type=int, default=5000) parser.add_argument("--max-depth", type=int, default=16) parser.add_argument("--max-states", type=int, default=1_000_000) parser.add_argument("--candidate-batch-size", type=int, default=STANDARD_CANDIDATE_BATCH_SIZE) parser.add_argument("--point-batch-size", type=int, default=STANDARD_POINT_BATCH_SIZE) parser.add_argument("--score-chunk-size", type=int, default=4096) parser.add_argument("--gpu-memory-fraction", type=float, default=0.48) parser.add_argument("--bucket-degrees", type=int, default=10) parser.add_argument("--max-per-bucket", type=int, default=4) parser.add_argument("--output-dir", default="artifacts/guided_iou_beam_256_320_v2") args = parser.parse_args() if torch is not None and torch.cuda.is_available(): torch.cuda.set_per_process_memory_fraction(args.gpu_memory_fraction, 0) tasks_path = Path(args.tasks_file) if sha256_file(tasks_path) != CANONICAL_TASKS_SHA256: raise RuntimeError("Canonical tasks SHA-256 mismatch") requested_ids = {value.strip() for value in args.ids.split(",") if value.strip()} tasks = [] source_ids = [] with tasks_path.open(encoding="utf-8") as handle: for line in handle: task = json.loads(line) source_ids.append(task["sample_id"]) if not requested_ids or "all" in requested_ids or task["sample_id"] in requested_ids: task["display_size"] = {"width": STANDARD_IMAGE_SIZE, "height": STANDARD_IMAGE_SIZE} task["eval_size"] = STANDARD_IMAGE_SIZE task["bfs_candidate_batch_size"] = args.candidate_batch_size task["cuda_point_batch_size"] = args.point_batch_size tasks.append(task) if len(source_ids) != CANONICAL_TASK_COUNT or len(set(source_ids)) != CANONICAL_TASK_COUNT: raise RuntimeError("Canonical source must contain exactly 676 unique tasks") selected_ids = {task["sample_id"] for task in tasks} if requested_ids and "all" not in requested_ids and selected_ids != requested_ids: raise RuntimeError("Requested task IDs were not found") tasks.sort(key=lambda task: task["sample_id"]) beam_widths = [int(value) for value in args.beam_widths.split(",")] if any(width <= 0 for width in beam_widths): raise ValueError("Beam widths must be positive") output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) manifest = { "protocol_version": "beam256_cuda320_difficulty_v2", "task_ids": [task["sample_id"] for task in tasks], "beam_widths": beam_widths, "display_size": [STANDARD_IMAGE_SIZE, STANDARD_IMAGE_SIZE], "eval_size": STANDARD_IMAGE_SIZE, "candidate_batch_size": args.candidate_batch_size, "point_batch_size": args.point_batch_size, "render_parameters": RENDER_PARAMETER_SCHEMA, "max_scored_per_depth": args.max_scored_per_depth, "max_depth": args.max_depth, "nearest_angle_count_per_axis": 1, "directions_per_state": 6, "bucket_degrees": args.bucket_degrees, "max_per_bucket": args.max_per_bucket, "scope": "deterministic reference search; not a global optimality proof", } manifest_path = output_dir / "manifest.json" if manifest_path.exists() and json.loads(manifest_path.read_text(encoding="utf-8")) != manifest: raise RuntimeError("Calibration manifest mismatch") manifest_path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") completed_by_width = {} for beam_width in beam_widths: output = output_dir / f"beam_{beam_width}.jsonl" completed = set() if output.exists(): rows = [json.loads(line) for line in output.read_text(encoding="utf-8").splitlines() if line.strip()] if any(row.get("beam_width") != beam_width for row in rows): raise RuntimeError(f"Existing results have the wrong width: {output}") completed = {row["sample_id"] for row in rows} completed_by_width[beam_width] = completed progress = tqdm( total=len(beam_widths) * len(tasks), initial=sum(len(values) for values in completed_by_width.values()), desc="beam calibration", unit="run", mininterval=1.0, ) for beam_width in beam_widths: output = output_dir / f"beam_{beam_width}.jsonl" completed = completed_by_width[beam_width] with output.open("a", encoding="utf-8") as handle: for task in tasks: if task["sample_id"] in completed: continue progress.set_postfix(width=beam_width, task=task["sample_id"]) print(json.dumps({"event": "start", "sample_id": task["sample_id"], "beam_width": beam_width}), flush=True) result = search_task( task, beam_width=beam_width, max_scored_per_depth=args.max_scored_per_depth, max_depth=args.max_depth, max_states=args.max_states, score_chunk_size=args.score_chunk_size, bucket_degrees=args.bucket_degrees, max_per_bucket=args.max_per_bucket, ) result["render_backend"] = get_last_render_backend() result["scoring_backend"] = "cuda_batch" if torch is not None and torch.cuda.is_available() else "renderer_per_state" handle.write(json.dumps(result, ensure_ascii=False) + "\n") handle.flush() print(json.dumps(result, ensure_ascii=False), flush=True) progress.update(1) progress.set_postfix( width=beam_width, task=task["sample_id"], last_seconds=result["elapsed_seconds"], ) progress.close() if __name__ == "__main__": main()