#!/usr/bin/env python """Search long-tail events with a reward-conditioned GPUDrive policy. This script is optimized for high-throughput scanning rather than rendering. It loads one reward-conditioned checkpoint, assigns multiple risk-taking agents per world, rolls out many batches, and writes collision / near-miss records. """ from __future__ import annotations import argparse import json import math import time from dataclasses import fields from pathlib import Path from typing import Any import torch import yaml from gpudrive.datatypes.observation import AGENT_SCALE from gpudrive.env.config import EnvConfig, RenderConfig from gpudrive.env.dataset import SceneDataLoader from gpudrive.env.env_torch import GPUDriveTorchEnv from gpudrive.networks.late_fusion import NeuralNet def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser() parser.add_argument("--config", default="baselines/ppo/config/ppo_mini_reward_conditioned.yaml") parser.add_argument("--checkpoint", default="") parser.add_argument("--data-dir", default="/mingli01/data/GPUDrive_mini/training") parser.add_argument("--output-dir", default="longtail_outputs/reward_conditioned_search") parser.add_argument("--num-worlds", type=int, default=1000) parser.add_argument("--dataset-size", type=int, default=864) parser.add_argument("--num-batches", type=int, default=10) parser.add_argument("--steps", type=int, default=91) parser.add_argument("--seed", type=int, default=42) parser.add_argument("--shard-id", type=int, default=0) parser.add_argument("--num-shards", type=int, default=1) parser.add_argument("--device", default="cuda") parser.add_argument("--deterministic", type=int, default=0) parser.add_argument("--risk-agents-per-world", type=int, default=3) parser.add_argument("--normal-mode", choices=["policy", "expert"], default="policy") parser.add_argument("--normal-style", default="balanced") parser.add_argument("--risk-style", default="risk_taker") parser.add_argument("--risk-collision-weight", type=float, default=0.0) parser.add_argument("--risk-goal-weight", type=float, default=2.0) parser.add_argument("--risk-offroad-weight", type=float, default=-0.4) parser.add_argument("--near-miss-threshold-m", type=float, default=2.0) parser.add_argument("--save-offroad", type=int, default=0) parser.add_argument("--obs-radius", type=float, default=None) parser.add_argument("--polyline-reduction-threshold", type=float, default=None) parser.add_argument("--save-event-traces", type=int, default=1) parser.add_argument("--trace-pre-steps", type=int, default=50) parser.add_argument("--trace-post-steps", type=int, default=10) parser.add_argument("--trace-include-all-agents", type=int, default=1) parser.add_argument("--trace-top-k-agents", type=int, default=16) parser.add_argument("--trace-map-radius-m", type=float, default=80.0) parser.add_argument("--trace-map-top-k", type=int, default=256) parser.add_argument("--trace-dt", type=float, default=0.1) return parser.parse_args() def load_config(path: str) -> dict[str, Any]: with open(path, "r", encoding="utf-8") as f: return yaml.safe_load(f) def find_latest_checkpoint() -> Path: patterns = [ "runs/PPO_MINI_RC*/model_*.pt", "gpudrive/runs/PPO_MINI_RC*/model_*.pt", "runs/*MINI*RC*/model_*.pt", "gpudrive/runs/*MINI*RC*/model_*.pt", ] for pattern in patterns: candidates = list(Path(".").glob(pattern)) if candidates: return max(candidates, key=lambda p: p.stat().st_mtime) raise FileNotFoundError("No reward-conditioned checkpoint found. Pass --checkpoint.") def reward_preset(config: EnvConfig, style: str, device: str) -> torch.Tensor: presets = { "cautious": [ config.collision_weight_lb * 0.9, config.goal_achieved_weight_ub * 0.7, config.off_road_weight_lb * 0.9, ], "aggressive": [ config.collision_weight_lb * 0.5, config.goal_achieved_weight_ub * 0.9, config.off_road_weight_lb * 0.6, ], "balanced": [ (config.collision_weight_lb + config.collision_weight_ub) / 2, (config.goal_achieved_weight_lb + config.goal_achieved_weight_ub) / 2, (config.off_road_weight_lb + config.off_road_weight_ub) / 2, ], "risk_taker": [ config.collision_weight_lb * 0.3, config.goal_achieved_weight_ub, config.off_road_weight_lb * 0.4, ], } if style not in presets: raise ValueError(f"Unknown style={style}. Available: {sorted(presets)}") return torch.tensor(presets[style], dtype=torch.float32, device=device) def make_env_config(raw_env: dict[str, Any], args: argparse.Namespace) -> EnvConfig: env_fields = {field.name for field in fields(EnvConfig)} cfg = {k: v for k, v in raw_env.items() if k in env_fields} cfg["num_worlds"] = args.num_worlds cfg["reward_type"] = "reward_conditioned" cfg["condition_mode"] = "random" if args.obs_radius is not None: cfg["obs_radius"] = args.obs_radius if args.polyline_reduction_threshold is not None: cfg["polyline_reduction_threshold"] = args.polyline_reduction_threshold steer_disc = int(raw_env.get("action_space_steer_disc", 13)) accel_disc = int(raw_env.get("action_space_accel_disc", 7)) cfg["steer_actions"] = torch.round(torch.linspace(-torch.pi, torch.pi, steer_disc), decimals=3) cfg["accel_actions"] = torch.round(torch.linspace(-4.0, 4.0, accel_disc), decimals=3) return EnvConfig(**cfg) def load_policy(checkpoint_path: Path, config: dict[str, Any], device: str) -> NeuralNet: saved = torch.load(checkpoint_path, map_location=device, weights_only=False) arch = saved["model_arch"] arch_get = arch.get if hasattr(arch, "get") else lambda key, default=None: getattr(arch, key, default) policy = NeuralNet( input_dim=arch_get("input_dim"), action_dim=saved["action_dim"], hidden_dim=arch_get("hidden_dim"), dropout=arch_get("dropout", 0.0), config=config["environment"], ).to(device) policy.load_state_dict(saved["parameters"]) policy.eval() return policy def choose_risk_agents( control_mask: torch.Tensor, risk_agents_per_world: int, generator: torch.Generator, ) -> torch.Tensor: risk_mask = torch.zeros_like(control_mask, dtype=torch.bool) for world_idx in range(control_mask.shape[0]): agents = torch.where(control_mask[world_idx])[0] if len(agents) == 0: continue num_risk = min(risk_agents_per_world, len(agents)) perm = torch.randperm(len(agents), generator=generator, device=control_mask.device) risk_mask[world_idx, agents[perm[:num_risk]]] = True return risk_mask def finite_min_scatter( values: torch.Tensor, world_ids: torch.Tensor, num_worlds: int, device: str, ) -> torch.Tensor: out = torch.full((num_worlds,), float("inf"), dtype=torch.float32, device=device) if values.numel() == 0: return out if hasattr(out, "scatter_reduce_"): out.scatter_reduce_(0, world_ids, values, reduce="amin", include_self=True) else: for world_id, value in zip(world_ids.tolist(), values.tolist()): out[world_id] = min(out[world_id], value) return out def compute_near_miss( env: GPUDriveTorchEnv, risk_mask: torch.Tensor, ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: abs_obs = env.sim.absolute_self_observation_tensor().to_torch().to(env.device) pos = abs_obs[:, :, :2] lengths = abs_obs[:, :, 10] * AGENT_SCALE widths = abs_obs[:, :, 11] * AGENT_SCALE valid = ( (torch.abs(pos[:, :, 0]) < 1000) & (torch.abs(pos[:, :, 1]) < 1000) & (lengths > 0.5) & (widths > 0.5) ) risk_world_ids, risk_agent_ids = torch.where(risk_mask) if risk_world_ids.numel() == 0: inf = torch.full((env.num_worlds,), float("inf"), device=env.device) minus = torch.full((env.num_worlds,), -1, dtype=torch.long, device=env.device) return inf, minus, minus risk_pos = pos[risk_world_ids, risk_agent_ids] other_pos = pos[risk_world_ids] dists = torch.linalg.norm(other_pos - risk_pos[:, None, :], dim=-1) agent_ids = torch.arange(env.max_agent_count, device=env.device).view(1, -1) other_valid = valid[risk_world_ids] & (agent_ids != risk_agent_ids[:, None]) dists = dists.masked_fill(~other_valid, float("inf")) min_dist_per_risk, partner_ids = dists.min(dim=1) world_min = finite_min_scatter(min_dist_per_risk, risk_world_ids, env.num_worlds, env.device) best_risk = torch.full((env.num_worlds,), -1, dtype=torch.long, device=env.device) best_partner = torch.full((env.num_worlds,), -1, dtype=torch.long, device=env.device) for idx in torch.where(torch.isfinite(min_dist_per_risk))[0].tolist(): world = int(risk_world_ids[idx].item()) if min_dist_per_risk[idx] <= world_min[world]: best_risk[world] = risk_agent_ids[idx] best_partner[world] = partner_ids[idx] return world_min, best_risk, best_partner def tensor_agent_lists(mask: torch.Tensor) -> list[list[int]]: return [torch.where(mask[w])[0].detach().cpu().tolist() for w in range(mask.shape[0])] def as_jsonable(value: Any, digits: int = 4) -> Any: if isinstance(value, torch.Tensor): return as_jsonable(value.detach().cpu().tolist(), digits=digits) if isinstance(value, dict): return {str(k): as_jsonable(v, digits=digits) for k, v in value.items()} if isinstance(value, (list, tuple)): return [as_jsonable(v, digits=digits) for v in value] if isinstance(value, bool) or value is None: return value if isinstance(value, int): return value if isinstance(value, float): if not math.isfinite(value): return None return round(value, digits) return value def tensor_series(tensor: torch.Tensor, digits: int = 4) -> list[Any]: return as_jsonable(tensor, digits=digits) def capture_state(env: GPUDriveTorchEnv) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: states = env.sim.absolute_self_observation_tensor().to_torch().detach().cpu().clone() infos = env.sim.info_tensor().to_torch().detach().cpu().clone() dones = env.get_dones().detach().cpu().clone().bool() return states, infos, dones def capture_actions( env: GPUDriveTorchEnv, actions: torch.Tensor, ) -> tuple[torch.Tensor, torch.Tensor]: if actions.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8): action_index = actions.detach().cpu().clone().long() action_values = env.action_keys_tensor[actions.to(dtype=torch.long, device=env.device)] else: action_index = torch.full( actions.shape[:2], -1, dtype=torch.long, device=actions.device, ) action_values = actions return action_index, action_values.detach().cpu().clone().float() def valid_agent_mask(states: torch.Tensor) -> torch.Tensor: pos = states[:, :, :2] lengths = states[:, :, 10] * AGENT_SCALE widths = states[:, :, 11] * AGENT_SCALE return ( torch.isfinite(pos).all(dim=-1) & (pos[:, :, 0].abs() < 1000) & (pos[:, :, 1].abs() < 1000) & (lengths > 0.5) & (widths > 0.5) ) def wrap_angle(angle: torch.Tensor) -> torch.Tensor: return torch.atan2(torch.sin(angle), torch.cos(angle)) def safe_step(step: int, num_steps: int) -> int: if num_steps <= 0: return 0 return max(0, min(int(step), num_steps - 1)) def event_step_from_record(record: dict[str, Any], num_steps: int) -> int: if record["first_collision_step"] >= 0: return safe_step(record["first_collision_step"], num_steps) if record["min_distance_step"] >= 0: return safe_step(record["min_distance_step"], num_steps) if record["first_offroad_step"] >= 0: return safe_step(record["first_offroad_step"], num_steps) return num_steps - 1 def pick_trace_window( event_step: int, num_states: int, pre_steps: int, post_steps: int, ) -> tuple[int, int]: start = max(0, event_step - max(0, pre_steps)) end = min(num_states, event_step + max(0, post_steps) + 1) return start, end def compute_kinematics(states: torch.Tensor, dt: float) -> dict[str, torch.Tensor]: dt = max(float(dt), 1e-6) pos = states[:, :, :2] yaw = states[:, :, 7] vel = torch.zeros_like(pos) vel[1:] = (pos[1:] - pos[:-1]) / dt speed = torch.linalg.norm(vel, dim=-1) accel = torch.zeros_like(speed) accel[1:] = (speed[1:] - speed[:-1]) / dt jerk = torch.zeros_like(speed) jerk[1:] = (accel[1:] - accel[:-1]) / dt yaw_rate = torch.zeros_like(yaw) yaw_rate[1:] = wrap_angle(yaw[1:] - yaw[:-1]) / dt pos_jump = torch.zeros_like(speed) pos_jump[1:] = torch.linalg.norm(pos[1:] - pos[:-1], dim=-1) return { "velocity": vel, "speed": speed, "accel": accel, "jerk": jerk, "yaw_rate": yaw_rate, "pos_jump": pos_jump, } def finite_stat(values: torch.Tensor, mode: str, default: float = 0.0) -> float: values = values[torch.isfinite(values)] if values.numel() == 0: return default if mode == "max": return float(values.max().item()) if mode == "min": return float(values.min().item()) if mode == "mean": return float(values.mean().item()) raise ValueError(mode) def select_trace_agents( record: dict[str, Any], states: torch.Tensor, control_mask: torch.Tensor, risk_mask: torch.Tensor, include_all_agents: bool, top_k_agents: int, local_event_step: int, ) -> list[int]: valid_any = valid_agent_mask(states).any(dim=0) if not bool(valid_any.any()): return [] if include_all_agents: return torch.where(valid_any)[0].tolist() selected = set(record["risk_agents"]) selected.update(record["collided_agents"]) selected.update(record["offroad_agents"]) if record["min_distance_risk_agent"] >= 0: selected.add(record["min_distance_risk_agent"]) if record["min_distance_partner_agent"] >= 0: selected.add(record["min_distance_partner_agent"]) event_step = safe_step(local_event_step, states.shape[0]) key_agents = [a for a in selected if 0 <= a < states.shape[1] and bool(valid_any[a])] if not key_agents: key_agents = torch.where((control_mask | risk_mask) & valid_any)[0].tolist() if key_agents: center = states[event_step, key_agents, :2].mean(dim=0) else: center = states[event_step, valid_any, :2].mean(dim=0) distances = torch.linalg.norm(states[event_step, :, :2] - center[None, :], dim=-1) distances = distances.masked_fill(~valid_any, float("inf")) k = min(max(top_k_agents, len(key_agents)), int(valid_any.sum().item())) if k > 0: nearest = torch.topk(-distances, k=k).indices.tolist() selected.update(nearest) return sorted(a for a in selected if 0 <= a < states.shape[1] and bool(valid_any[a])) def reward_weights_for_agent( agent_idx: int, control_mask: torch.Tensor, risk_mask: torch.Tensor, normal_weights: torch.Tensor, risk_weights: torch.Tensor, ) -> list[float] | None: if not bool(control_mask[agent_idx]): return None weights = risk_weights if bool(risk_mask[agent_idx]) else normal_weights return [float(v) for v in weights.tolist()] def build_agent_metadata( selected_agents: list[int], states: torch.Tensor, infos: torch.Tensor, response_type: torch.Tensor, control_mask: torch.Tensor, risk_mask: torch.Tensor, normal_weights: torch.Tensor, risk_weights: torch.Tensor, ) -> list[dict[str, Any]]: metadata = [] valid_any = valid_agent_mask(states).any(dim=0) first_valid = valid_agent_mask(states).float().argmax(dim=0) for agent_idx in selected_agents: first_step = int(first_valid[agent_idx].item()) if bool(valid_any[agent_idx]) else 0 state = states[first_step, agent_idx] raw_type = int(infos[first_step, agent_idx, 4].item()) if infos.shape[-1] > 4 else None response = int(response_type[agent_idx].item()) if agent_idx < response_type.shape[0] else None metadata.append( { "agent_index": agent_idx, "sim_agent_id": int(state[13].item()), "is_controlled": bool(control_mask[agent_idx]), "is_risk_agent": bool(risk_mask[agent_idx]), "response_type": response, "raw_agent_type": raw_type, "reward_weights": reward_weights_for_agent( agent_idx, control_mask, risk_mask, normal_weights, risk_weights ), "length_m": float(state[10].item() * AGENT_SCALE), "width_m": float(state[11].item() * AGENT_SCALE), "height_m": float(state[12].item()), "goal_xy": [float(state[8].item()), float(state[9].item())], } ) return metadata def pair_candidates(record: dict[str, Any]) -> list[tuple[int, int]]: pairs: list[tuple[int, int]] = [] risk = int(record["min_distance_risk_agent"]) partner = int(record["min_distance_partner_agent"]) if risk >= 0 and partner >= 0 and risk != partner: pairs.append((risk, partner)) risk_agents = [int(a) for a in record.get("risk_agents", [])] for risk_agent in risk_agents: for other_agent in record.get("collided_agents", []): other_agent = int(other_agent) if risk_agent != other_agent: pairs.append((risk_agent, other_agent)) seen = set() unique_pairs = [] for a, b in pairs: key = (a, b) if key not in seen: seen.add(key) unique_pairs.append(key) return unique_pairs[:12] def compute_pair_trace( states: torch.Tensor, kin: dict[str, torch.Tensor], agent_a: int, agent_b: int, dt: float, ) -> dict[str, Any]: pos_a = states[:, agent_a, :2] pos_b = states[:, agent_b, :2] yaw_a = states[:, agent_a, 7] yaw_b = states[:, agent_b, 7] rel = pos_b - pos_a distance = torch.linalg.norm(rel, dim=-1) vel_rel = kin["velocity"][:, agent_b] - kin["velocity"][:, agent_a] denom = distance.clamp_min(1e-6) closing_speed = -torch.sum(rel * vel_rel, dim=-1) / denom ttc = torch.full_like(distance, float("inf")) approaching = closing_speed > 0.1 ttc[approaching] = distance[approaching] / closing_speed[approaching] longitudinal = rel[:, 0] * torch.cos(yaw_a) + rel[:, 1] * torch.sin(yaw_a) lateral = -rel[:, 0] * torch.sin(yaw_a) + rel[:, 1] * torch.cos(yaw_a) rel_heading = wrap_angle(yaw_b - yaw_a) finite_distance = distance.masked_fill(~torch.isfinite(distance), float("inf")) min_idx = int(torch.argmin(finite_distance).item()) ttc_valid = ttc[torch.isfinite(ttc)] return { "agent_a": agent_a, "agent_b": agent_b, "distance_m": tensor_series(distance), "closing_speed_mps": tensor_series(closing_speed), "ttc_s": tensor_series(ttc), "relative_heading_rad": tensor_series(rel_heading), "longitudinal_gap_m": tensor_series(longitudinal), "lateral_offset_m": tensor_series(lateral), "min_distance_m": float(finite_distance[min_idx].item()), "min_distance_step": min_idx, "min_ttc_s": float(ttc_valid.min().item()) if ttc_valid.numel() > 0 else None, "time_ttc_below_1s": float(((ttc < 1.0) & torch.isfinite(ttc)).sum().item() * dt), "time_ttc_below_2s": float(((ttc < 2.0) & torch.isfinite(ttc)).sum().item() * dt), "relative_speed_at_min_mps": float(torch.linalg.norm(vel_rel[min_idx]).item()), "closing_speed_at_min_mps": float(closing_speed[min_idx].item()), "lateral_offset_at_min_m": float(lateral[min_idx].item()), "longitudinal_gap_at_min_m": float(longitudinal[min_idx].item()), "relative_heading_at_min_rad": float(rel_heading[min_idx].item()), } def build_pairwise_trace( record: dict[str, Any], states: torch.Tensor, kin: dict[str, torch.Tensor], selected_agents: list[int], dt: float, ) -> list[dict[str, Any]]: selected = set(selected_agents) traces = [] for agent_a, agent_b in pair_candidates(record): if agent_a in selected and agent_b in selected: traces.append(compute_pair_trace(states, kin, agent_a, agent_b, dt)) return traces def score_naturalness( states: torch.Tensor, infos: torch.Tensor, kin: dict[str, torch.Tensor], selected_agents: list[int], record: dict[str, Any], ) -> dict[str, Any]: if not selected_agents: return {"score": 0.0, "reasons": ["no_valid_agents"]} selected = torch.tensor(selected_agents, dtype=torch.long) valid = valid_agent_mask(states)[:, selected] max_speed = finite_stat(kin["speed"][:, selected][valid], "max") max_accel = finite_stat(kin["accel"][:, selected][valid], "max") max_decel = -finite_stat(kin["accel"][:, selected][valid], "min") max_yaw_rate = finite_stat(kin["yaw_rate"][:, selected].abs()[valid], "max") max_jerk = finite_stat(kin["jerk"][:, selected].abs()[valid], "max") max_jump = finite_stat(kin["pos_jump"][:, selected][valid], "max") offroad_before_collision = ( record["first_offroad_step"] >= 0 and record["first_collision_step"] >= 0 and record["first_offroad_step"] < record["first_collision_step"] ) penalties = [] score = 100.0 if max_speed > 45: penalties.append("extreme_speed") score -= min(30.0, (max_speed - 45.0) * 1.5) if max_accel > 8: penalties.append("high_acceleration") score -= min(20.0, (max_accel - 8.0) * 2.0) if max_decel > 10: penalties.append("hard_deceleration") score -= min(20.0, (max_decel - 10.0) * 1.5) if max_yaw_rate > 1.6: penalties.append("high_yaw_rate") score -= min(20.0, (max_yaw_rate - 1.6) * 8.0) if max_jerk > 40: penalties.append("high_jerk") score -= min(20.0, (max_jerk - 40.0) * 0.5) if max_jump > 8: penalties.append("position_jump") score -= 35.0 if offroad_before_collision: penalties.append("offroad_before_collision") score -= 25.0 return { "score": max(0.0, min(100.0, score)), "max_speed_mps": max_speed, "max_accel_mps2": max_accel, "max_decel_mps2": max_decel, "max_abs_yaw_rate_radps": max_yaw_rate, "max_abs_jerk_mps3": max_jerk, "max_position_jump_m": max_jump, "offroad_before_collision": offroad_before_collision, "penalties": penalties, } def score_interaction( record: dict[str, Any], pair_traces: list[dict[str, Any]], risk_mask: torch.Tensor, response_type: torch.Tensor, ) -> dict[str, Any]: risk_involved = any(int(a) in set(record.get("risk_agents", [])) for a in record.get("collided_agents", [])) primary_partner = int(record.get("min_distance_partner_agent", -1)) partner_dynamic = ( primary_partner >= 0 and primary_partner < response_type.shape[0] and int(response_type[primary_partner].item()) != 2 ) best_pair = pair_traces[0] if pair_traces else None min_ttc = best_pair.get("min_ttc_s") if best_pair else None rel_speed = best_pair.get("relative_speed_at_min_mps") if best_pair else 0.0 score = 40.0 reasons = [] if risk_involved: score += 20.0 else: reasons.append("risk_agent_not_directly_collided") if partner_dynamic: score += 15.0 else: reasons.append("partner_may_be_static_or_padding") if min_ttc is not None and min_ttc <= 3.0: score += 15.0 if rel_speed >= 1.0: score += 10.0 else: reasons.append("low_relative_speed") return { "score": max(0.0, min(100.0, score)), "risk_involved_in_collision": risk_involved, "primary_partner_dynamic": partner_dynamic, "primary_min_ttc_s": min_ttc, "primary_relative_speed_at_min_mps": rel_speed, "notes": reasons, } def score_criticality( record: dict[str, Any], pair_traces: list[dict[str, Any]], ) -> dict[str, Any]: score = 0.0 if record["collision"]: score += 55.0 if record["near_miss"]: score += 20.0 min_dist = record.get("min_distance_m") if min_dist is not None: score += max(0.0, min(15.0, (3.0 - float(min_dist)) * 7.5)) impact_speed = 0.0 ttc_exposure_2s = 0.0 if pair_traces: impact_speed = float(pair_traces[0].get("relative_speed_at_min_mps") or 0.0) ttc_exposure_2s = float(pair_traces[0].get("time_ttc_below_2s") or 0.0) if impact_speed >= 2.0: score += min(10.0, impact_speed) return { "score": max(0.0, min(100.0, score)), "has_collision": bool(record["collision"]), "has_near_miss": bool(record["near_miss"]), "min_distance_m": min_dist, "impact_or_min_relative_speed_mps": impact_speed, "time_ttc_below_2s": ttc_exposure_2s, } def semantic_candidates(pair_traces: list[dict[str, Any]]) -> list[dict[str, Any]]: candidates = [] for pair in pair_traces[:3]: lat = float(pair.get("lateral_offset_at_min_m") or 0.0) lon = float(pair.get("longitudinal_gap_at_min_m") or 0.0) heading = abs(float(pair.get("relative_heading_at_min_rad") or 0.0)) rel_speed = float(pair.get("relative_speed_at_min_mps") or 0.0) if abs(lat) < 1.5 and lon > 0 and heading < 0.6: label = "rear_end_or_following_conflict" elif abs(lat) < 3.5 and heading < 0.8: label = "same_direction_side_conflict_or_cut_in" elif heading > 0.8: label = "crossing_or_intersection_conflict" else: label = "generic_close_interaction" candidates.append( { "pair": [pair["agent_a"], pair["agent_b"]], "label": label, "relative_speed_mps": rel_speed, "lateral_offset_m": lat, "longitudinal_gap_m": lon, "relative_heading_rad": heading, } ) return candidates def build_map_context( map_obs: torch.Tensor, states: torch.Tensor, selected_agents: list[int], event_step: int, radius_m: float, top_k: int, ) -> dict[str, Any]: if selected_agents: selected = torch.tensor(selected_agents, dtype=torch.long) selected_valid = valid_agent_mask(states)[event_step, selected] selected = selected[selected_valid] center = states[event_step, selected, :2].mean(dim=0) if selected.numel() else None else: center = None if center is None: valid = valid_agent_mask(states)[event_step] center = states[event_step, valid, :2].mean(dim=0) if bool(valid.any()) else torch.zeros(2) xy = map_obs[:, :2] valid = torch.isfinite(xy).all(dim=-1) & (xy[:, 0].abs() < 1000) & (xy[:, 1].abs() < 1000) dist = torch.linalg.norm(xy - center[None, :], dim=-1) keep = valid & (dist <= radius_m) candidate_ids = torch.where(keep)[0] if candidate_ids.numel() > top_k: nearest = torch.topk(-dist[candidate_ids], k=top_k).indices candidate_ids = candidate_ids[nearest] points = [] type_counts: dict[str, int] = {} for idx in candidate_ids.tolist(): point = map_obs[idx] road_type = int(point[6].item()) type_counts[str(road_type)] = type_counts.get(str(road_type), 0) + 1 points.append( { "x": float(point[0].item()), "y": float(point[1].item()), "segment_length": float(point[2].item()), "segment_width": float(point[3].item()), "orientation": float(point[5].item()), "type": road_type, "id": int(point[7].item()), "vbd_type": int(point[8].item()), } ) return { "center_xy": [float(center[0].item()), float(center[1].item())], "radius_m": radius_m, "num_points": len(points), "type_counts": type_counts, "points": points, } def build_event_trace_record( record: dict[str, Any], state_history: list[torch.Tensor], info_history: list[torch.Tensor], done_history: list[torch.Tensor], action_index_history: list[torch.Tensor], action_value_history: list[torch.Tensor], response_type_batch: torch.Tensor, map_obs_batch: torch.Tensor, control_mask_batch: torch.Tensor, risk_mask_batch: torch.Tensor, normal_weights: torch.Tensor, risk_weights: torch.Tensor, args: argparse.Namespace, ) -> dict[str, Any]: world_idx = int(record["world_idx"]) all_states = torch.stack(state_history, dim=0)[:, world_idx] all_infos = torch.stack(info_history, dim=0)[:, world_idx] all_dones = torch.stack(done_history, dim=0)[:, world_idx] actions_index = torch.stack(action_index_history, dim=0)[:, world_idx] if action_index_history else None actions_value = torch.stack(action_value_history, dim=0)[:, world_idx] if action_value_history else None response_type = response_type_batch[world_idx] if response_type.ndim > 1: response_type = response_type.squeeze(-1) control_mask = control_mask_batch[world_idx] risk_mask = risk_mask_batch[world_idx] event_step = event_step_from_record(record, all_states.shape[0]) start, end = pick_trace_window( event_step, all_states.shape[0], args.trace_pre_steps, args.trace_post_steps, ) states = all_states[start:end] infos = all_infos[start:end] dones = all_dones[start:end] kin = compute_kinematics(states, args.trace_dt) selected_agents = select_trace_agents( record, states, control_mask, risk_mask, bool(args.trace_include_all_agents), args.trace_top_k_agents, event_step - start, ) agent_metadata = build_agent_metadata( selected_agents, states, infos, response_type, control_mask, risk_mask, normal_weights.detach().cpu(), risk_weights.detach().cpu(), ) agent_traces = {} for agent_idx in selected_agents: agent_slice = states[:, agent_idx] info_slice = infos[:, agent_idx] trace: dict[str, Any] = { "pos_x_m": tensor_series(agent_slice[:, 0]), "pos_y_m": tensor_series(agent_slice[:, 1]), "yaw_rad": tensor_series(agent_slice[:, 7]), "speed_mps": tensor_series(kin["speed"][:, agent_idx]), "accel_mps2": tensor_series(kin["accel"][:, agent_idx]), "yaw_rate_radps": tensor_series(kin["yaw_rate"][:, agent_idx]), "valid": tensor_series(valid_agent_mask(states)[:, agent_idx]), "done": tensor_series(dones[:, agent_idx]), "off_road": tensor_series(info_slice[:, 0]), "collided": tensor_series(info_slice[:, 1:3].sum(dim=-1)), "goal_achieved": tensor_series(info_slice[:, 3]), } if actions_index is not None and actions_value is not None: action_start = max(0, start) action_end = max(action_start, min(end - 1, actions_index.shape[0])) trace["action_index"] = tensor_series(actions_index[action_start:action_end, agent_idx]) trace["action_value"] = tensor_series(actions_value[action_start:action_end, agent_idx]) agent_traces[str(agent_idx)] = trace pair_traces = build_pairwise_trace(record, states, kin, selected_agents, args.trace_dt) naturalness = score_naturalness(states, infos, kin, selected_agents, record) interaction = score_interaction(record, pair_traces, risk_mask, response_type) criticality = score_criticality(record, pair_traces) validity_gate = { "has_collision_or_near_miss": bool(record["collision"] or record["near_miss"]), "enough_controlled_agents": int(record["controlled_agents"]) >= 2, "motion_natural_enough": float(naturalness["score"]) >= 50.0, "interaction_meaningful_enough": float(interaction["score"]) >= 45.0, } final_score = ( 0.35 * float(criticality["score"]) + 0.30 * float(naturalness["score"]) + 0.35 * float(interaction["score"]) ) return { "schema_version": "longtail_event_trace_v1", "event": record, "generation_context": { "checkpoint": str(args.checkpoint), "config": str(args.config), "data_dir": str(args.data_dir), "seed": int(args.seed), "shard_id": int(args.shard_id), "num_shards": int(args.num_shards), "num_worlds": int(args.num_worlds), "normal_mode": args.normal_mode, "normal_style": args.normal_style, "risk_style": args.risk_style, "risk_agents_per_world": int(args.risk_agents_per_world), "dt": float(args.trace_dt), }, "trace_window": { "start_step": int(start), "end_step_exclusive": int(end), "event_step": int(event_step), "num_frames": int(end - start), "selected_agents": selected_agents, "include_all_agents": bool(args.trace_include_all_agents), }, "agent_metadata": agent_metadata, "agent_traces": agent_traces, "pairwise_trace": pair_traces, "map_context": build_map_context( map_obs_batch[world_idx], states, selected_agents, safe_step(event_step - start, states.shape[0]), args.trace_map_radius_m, args.trace_map_top_k, ), "naturalness_metrics": naturalness, "interaction_metrics": interaction, "criticality_metrics": criticality, "semantic_candidates": semantic_candidates(pair_traces), "quality_scores": { "validity_gate": validity_gate, "final_score": max(0.0, min(100.0, final_score)), }, "replay_context": { "note": "This stores observed rollout states and actions for evaluation. Recreating the exact rollout still requires the same checkpoint, seed, data file, and simulator version.", "action_space": "discrete_index_plus_action_value" if actions_index is not None else "unknown", }, "visualization_hints": { "center_agent": int(record["min_distance_risk_agent"]) if int(record["min_distance_risk_agent"]) >= 0 else (selected_agents[0] if selected_agents else -1), "partner_agent": int(record["min_distance_partner_agent"]), "zoom_radius_m": max(25.0, min(120.0, float(args.trace_map_radius_m))), "event_frame_index": int(event_step - start), }, } def main() -> None: args = parse_args() device = args.device if torch.cuda.is_available() or args.device == "cpu" else "cpu" config = load_config(args.config) checkpoint = Path(args.checkpoint) if args.checkpoint else find_latest_checkpoint() args.checkpoint = str(checkpoint) output_dir = Path(args.output_dir) / f"shard_{args.shard_id:03d}" output_dir.mkdir(parents=True, exist_ok=True) seed = args.seed + args.shard_id * 100_000 torch.manual_seed(seed) generator = torch.Generator(device=device) generator.manual_seed(seed) env_config = make_env_config(config["environment"], args) data_loader = SceneDataLoader( root=args.data_dir, batch_size=args.num_worlds, dataset_size=args.dataset_size, sample_with_replacement=True, shuffle=True, seed=seed, ) env = GPUDriveTorchEnv( config=env_config, data_loader=data_loader, max_cont_agents=env_config.max_controlled_agents, device=device, render_config=RenderConfig(render_3d=False), ) policy = load_policy(checkpoint, config, device) normal_weights = reward_preset(env_config, args.normal_style, device) risk_weights = torch.tensor( [ args.risk_collision_weight, args.risk_goal_weight, args.risk_offroad_weight, ], dtype=torch.float32, device=device, ) events_path = output_dir / "events.jsonl" traces_path = output_dir / "event_traces.jsonl" summary: dict[str, Any] = { "checkpoint": str(checkpoint), "data_dir": str(data_loader.root), "shard_id": args.shard_id, "num_shards": args.num_shards, "num_worlds": args.num_worlds, "num_batches": args.num_batches, "steps": args.steps, "risk_agents_per_world": args.risk_agents_per_world, "normal_mode": args.normal_mode, "normal_weights": normal_weights.detach().cpu().tolist(), "risk_weights": risk_weights.detach().cpu().tolist(), "near_miss_threshold_m": args.near_miss_threshold_m, "save_event_traces": bool(args.save_event_traces), "event_traces_path": str(traces_path) if args.save_event_traces else None, "trace_pre_steps": args.trace_pre_steps, "trace_post_steps": args.trace_post_steps, "trace_include_all_agents": bool(args.trace_include_all_agents), "trace_map_radius_m": args.trace_map_radius_m, "total_worlds": 0, "event_worlds": 0, "collision_worlds": 0, "near_miss_worlds": 0, "offroad_worlds": 0, "best_min_distance_m": float("inf"), "start_time": time.time(), } print( "[search] start:", f"checkpoint={checkpoint}", f"data_dir={data_loader.root}", f"dataset_files={len(data_loader.dataset)}", f"device={device}", f"shard={args.shard_id}/{args.num_shards}", f"num_worlds={args.num_worlds}", f"num_batches={args.num_batches}", f"risk_agents_per_world={args.risk_agents_per_world}", f"risk_weights={summary['risk_weights']}", f"save_event_traces={bool(args.save_event_traces)}", flush=True, ) events_f = open(events_path, "w", encoding="utf-8") trace_f = open(traces_path, "w", encoding="utf-8") if args.save_event_traces else None try: scan_start = time.time() for batch_idx in range(args.num_batches): batch_start = time.time() if batch_idx > 0: env.swap_data_batch() env.reset() control_mask = env.cont_agent_mask.clone() risk_mask = choose_risk_agents(control_mask, args.risk_agents_per_world, generator) normal_mask = control_mask & ~risk_mask env.reward_weights_tensor[:] = normal_weights env.reward_weights_tensor[risk_mask] = risk_weights response_type_batch = None map_obs_batch = None control_mask_batch = None risk_mask_batch = None state_history: list[torch.Tensor] = [] info_history: list[torch.Tensor] = [] done_history: list[torch.Tensor] = [] action_index_history: list[torch.Tensor] = [] action_value_history: list[torch.Tensor] = [] if args.save_event_traces: response_type_batch = ( env.sim.response_type_tensor().to_torch().detach().cpu().clone() ) map_obs_batch = env.sim.map_observation_tensor().to_torch().detach().cpu().clone() control_mask_batch = control_mask.detach().cpu().clone() risk_mask_batch = risk_mask.detach().cpu().clone() state, info, done = capture_state(env) state_history.append(state) info_history.append(info) done_history.append(done) live_mask = control_mask.clone() collided = torch.zeros_like(control_mask, dtype=torch.bool, device=device) offroad = torch.zeros_like(control_mask, dtype=torch.bool, device=device) goal = torch.zeros_like(control_mask, dtype=torch.bool, device=device) first_collision_step = torch.full((env.num_worlds,), -1, dtype=torch.long, device=device) first_offroad_step = torch.full((env.num_worlds,), -1, dtype=torch.long, device=device) best_min_dist = torch.full((env.num_worlds,), float("inf"), dtype=torch.float32, device=device) best_min_step = torch.full((env.num_worlds,), -1, dtype=torch.long, device=device) best_risk_agent = torch.full((env.num_worlds,), -1, dtype=torch.long, device=device) best_partner_agent = torch.full((env.num_worlds,), -1, dtype=torch.long, device=device) expert_actions = None if args.normal_mode == "expert": expert_actions, _, _, _ = env.get_expert_actions() for step in range(args.steps): active = live_mask & control_mask if args.normal_mode == "expert": action_step = min(step, expert_actions.shape[2] - 1) actions = expert_actions[:, :, action_step, :].clone() active_risk = active & risk_mask if bool(active_risk.any().item()): risk_obs = env.get_obs(active_risk) with torch.no_grad(): risk_action, _, _, _ = policy( risk_obs, deterministic=bool(args.deterministic) ) actions[active_risk] = env.action_keys_tensor[ risk_action.to(dtype=torch.long, device=device) ] else: actions = torch.zeros( (env.num_worlds, env.max_agent_count), dtype=torch.int64, device=device, ) if bool(active.any().item()): active_obs = env.get_obs(active) with torch.no_grad(): action, _, _, _ = policy( active_obs, deterministic=bool(args.deterministic) ) actions[active] = action.to(dtype=torch.int64, device=device) if args.save_event_traces: action_index, action_value = capture_actions(env, actions) action_index_history.append(action_index) action_value_history.append(action_value) env.step_dynamics(actions) infos = env.get_infos() if args.save_event_traces: state, info, done = capture_state(env) state_history.append(state) info_history.append(info) done_history.append(done) new_collision = (infos.collided > 0).bool() & control_mask & ~collided new_offroad = (infos.off_road > 0).bool() & control_mask & ~offroad new_collision_world = new_collision.any(dim=1) & (first_collision_step < 0) new_offroad_world = new_offroad.any(dim=1) & (first_offroad_step < 0) first_collision_step[new_collision_world] = step + 1 first_offroad_step[new_offroad_world] = step + 1 collided |= (infos.collided > 0).bool() & control_mask offroad |= (infos.off_road > 0).bool() & control_mask goal |= (infos.goal_achieved > 0).bool() & control_mask min_dist, min_risk, min_partner = compute_near_miss(env, risk_mask & live_mask) improved = min_dist < best_min_dist best_min_dist[improved] = min_dist[improved] best_min_step[improved] = step + 1 best_risk_agent[improved] = min_risk[improved] best_partner_agent[improved] = min_partner[improved] live_mask &= ~env.get_dones().bool() if not bool(live_mask.any().item()): break collision_world = (collided & control_mask).any(dim=1) near_miss_world = best_min_dist <= args.near_miss_threshold_m offroad_world = (offroad & control_mask).any(dim=1) event_world = collision_world | near_miss_world if args.save_offroad: event_world |= offroad_world risk_agent_lists = tensor_agent_lists(risk_mask) controlled_counts = control_mask.sum(dim=1).detach().cpu().tolist() files = [str(Path(path).name) for path in env.data_batch] for world_idx in torch.where(event_world)[0].detach().cpu().tolist(): record = { "shard_id": args.shard_id, "batch_idx": batch_idx, "world_idx": world_idx, "scenario_file": files[world_idx], "controlled_agents": int(controlled_counts[world_idx]), "risk_agents": risk_agent_lists[world_idx], "collision": bool(collision_world[world_idx].item()), "near_miss": bool(near_miss_world[world_idx].item()), "offroad": bool(offroad_world[world_idx].item()), "first_collision_step": int(first_collision_step[world_idx].item()), "first_offroad_step": int(first_offroad_step[world_idx].item()), "min_distance_m": round(float(best_min_dist[world_idx].item()), 4), "min_distance_step": int(best_min_step[world_idx].item()), "min_distance_risk_agent": int(best_risk_agent[world_idx].item()), "min_distance_partner_agent": int(best_partner_agent[world_idx].item()), "collided_agents": torch.where(collided[world_idx] & control_mask[world_idx])[0].detach().cpu().tolist(), "offroad_agents": torch.where(offroad[world_idx] & control_mask[world_idx])[0].detach().cpu().tolist(), "goal_agents": int((goal[world_idx] & control_mask[world_idx]).sum().item()), } events_f.write(json.dumps(record) + "\n") if trace_f is not None: trace_record = build_event_trace_record( record=record, state_history=state_history, info_history=info_history, done_history=done_history, action_index_history=action_index_history, action_value_history=action_value_history, response_type_batch=response_type_batch, map_obs_batch=map_obs_batch, control_mask_batch=control_mask_batch, risk_mask_batch=risk_mask_batch, normal_weights=normal_weights, risk_weights=risk_weights, args=args, ) trace_f.write(json.dumps(as_jsonable(trace_record), ensure_ascii=False) + "\n") events_f.flush() if trace_f is not None: trace_f.flush() batch_min = float(best_min_dist.min().item()) summary["total_worlds"] += args.num_worlds summary["event_worlds"] += int(event_world.sum().item()) summary["collision_worlds"] += int(collision_world.sum().item()) summary["near_miss_worlds"] += int(near_miss_world.sum().item()) summary["offroad_worlds"] += int(offroad_world.sum().item()) summary["best_min_distance_m"] = min(summary["best_min_distance_m"], batch_min) completed_batches = batch_idx + 1 elapsed = time.time() - scan_start batch_elapsed = time.time() - batch_start batches_left = args.num_batches - completed_batches eta_sec = (elapsed / completed_batches) * batches_left if completed_batches else 0.0 scanned_worlds = completed_batches * args.num_worlds event_rate = summary["event_worlds"] / scanned_worlds if scanned_worlds else 0.0 print( "[search] progress:", f"shard={args.shard_id}", f"batch={batch_idx + 1}/{args.num_batches}", f"progress={100.0 * completed_batches / args.num_batches:.1f}%", f"batch_sec={batch_elapsed:.1f}", f"elapsed={elapsed / 60.0:.1f}m", f"eta={eta_sec / 60.0:.1f}m", f"scanned_worlds={scanned_worlds}", f"cum_events={summary['event_worlds']}", f"event_rate={event_rate:.4f}", f"events={int(event_world.sum().item())}", f"collisions={int(collision_world.sum().item())}", f"near_miss={int(near_miss_world.sum().item())}", f"offroad={int(offroad_world.sum().item())}", f"best_min_dist={batch_min:.3f}", flush=True, ) finally: events_f.close() if trace_f is not None: trace_f.close() summary["elapsed_sec"] = round(time.time() - summary["start_time"], 3) if math.isinf(summary["best_min_distance_m"]): summary["best_min_distance_m"] = None with open(output_dir / "summary.json", "w", encoding="utf-8") as f: json.dump(summary, f, indent=2) print("[search] done:", summary, flush=True) if __name__ == "__main__": main()