gpudrive-main/scripts/search_longtail_reward_conditioned.py

#!/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()