| |
| """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() |
|
|
