gpudrive-main/scripts/visualize_longtail_search.py

#!/usr/bin/env python
"""Render MP4 videos for reward-conditioned long-tail search records."""

from __future__ import annotations

import argparse
import json
import time
from collections import defaultdict
from dataclasses import fields
from pathlib import Path
from typing import Any

import mediapy as media
import torch
import yaml

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
from gpudrive.visualize.utils import img_from_fig


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("--search-dir", default="longtail_outputs/reward_conditioned_search")
    parser.add_argument("--events-file", default="")
    parser.add_argument("--data-dir", default="")
    parser.add_argument("--output-dir", default="longtail_outputs/reward_conditioned_search/videos")
    parser.add_argument("--replay-mode", choices=["exact", "fast"], default="exact")
    parser.add_argument("--event-type", choices=["any", "collision", "near_miss", "offroad"], default="any")
    parser.add_argument("--max-videos", type=int, default=4)
    parser.add_argument("--num-worlds", type=int, default=0)
    parser.add_argument("--dataset-size", type=int, default=864)
    parser.add_argument("--steps", type=int, default=0)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--device", default="cuda")
    parser.add_argument("--deterministic", type=int, default=0)
    parser.add_argument("--normal-mode", choices=["policy", "expert", ""], default="")
    parser.add_argument("--normal-style", default="balanced")
    parser.add_argument("--risk-style", default="risk_taker")
    parser.add_argument("--risk-agents-per-world", type=int, default=0)
    parser.add_argument("--risk-collision-weight", type=float, default=None)
    parser.add_argument("--risk-goal-weight", type=float, default=None)
    parser.add_argument("--risk-offroad-weight", type=float, default=None)
    parser.add_argument("--render-every", type=int, default=1)
    parser.add_argument("--fps", type=int, default=5)
    parser.add_argument("--stop-on-collision", type=int, default=1)
    parser.add_argument("--render-3d", type=int, default=0)
    parser.add_argument("--zoom-radius", type=float, default=70.0)
    parser.add_argument("--obs-radius", type=float, default=None)
    parser.add_argument("--polyline-reduction-threshold", type=float, default=None)
    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 normalize_event_record(record: dict[str, Any]) -> dict[str, Any]:
    """Accept raw search events or LLM evaluation wrapper records."""
    if isinstance(record.get("event"), dict):
        event = dict(record["event"])
        for key in ("event_key", "final_valid", "final_score", "final_priority"):
            if key in record:
                event[f"llm_{key}"] = record[key]
        if isinstance(record.get("llm_eval"), dict):
            event["llm_eval"] = record["llm_eval"]
        if isinstance(record.get("rule_eval"), dict):
            event["rule_eval"] = record["rule_eval"]
        return event
    return record


def load_json_records(path: Path) -> list[dict[str, Any]]:
    if path.suffix == ".jsonl":
        records = []
        with open(path, "r", encoding="utf-8") as f:
            for line in f:
                if line.strip():
                    records.append(normalize_event_record(json.loads(line)))
        return records

    with open(path, "r", encoding="utf-8") as f:
        data = json.load(f)
    if isinstance(data, list):
        return [normalize_event_record(record) for record in data]
    raise ValueError(f"Expected a JSON list or JSONL records: {path}")


def load_records(search_dir: Path, events_file: str) -> list[dict[str, Any]]:
    if events_file:
        return load_json_records(Path(events_file))

    top_files = sorted(search_dir.glob("top_*.json"))
    if top_files:
        return load_json_records(max(top_files, key=lambda p: p.stat().st_mtime))

    records = []
    for path in sorted(search_dir.glob("shard_*/events.jsonl")):
        records.extend(load_json_records(path))
    return records


def load_shard_summaries(search_dir: Path) -> dict[int, dict[str, Any]]:
    summaries: dict[int, dict[str, Any]] = {}
    for path in sorted(search_dir.glob("shard_*/summary.json")):
        with open(path, "r", encoding="utf-8") as f:
            summary = json.load(f)
        summaries[int(summary.get("shard_id", len(summaries)))] = summary
    return summaries


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 resolve_checkpoint(args_checkpoint: str, first_summary: dict[str, Any] | None) -> Path:
    if args_checkpoint:
        return Path(args_checkpoint)
    if first_summary and first_summary.get("checkpoint"):
        return Path(first_summary["checkpoint"])
    return find_latest_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 tensor_from_summary_or_preset(
    summary: dict[str, Any] | None,
    key: str,
    fallback: torch.Tensor,
    device: str,
) -> torch.Tensor:
    if summary and key in summary and summary[key] is not None:
        return torch.tensor(summary[key], dtype=torch.float32, device=device)
    return fallback


def apply_weight_overrides(weights: torch.Tensor, args: argparse.Namespace) -> torch.Tensor:
    weights = weights.clone()
    if args.risk_collision_weight is not None:
        weights[0] = args.risk_collision_weight
    if args.risk_goal_weight is not None:
        weights[1] = args.risk_goal_weight
    if args.risk_offroad_weight is not None:
        weights[2] = args.risk_offroad_weight
    return weights


def make_env_config(raw_env: dict[str, Any], num_worlds: int, 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"] = 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, model_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=model_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 risk_mask_from_records(env: GPUDriveTorchEnv, records: list[dict[str, Any]]) -> torch.Tensor:
    mask = torch.zeros_like(env.cont_agent_mask, dtype=torch.bool, device=env.device)
    for world_idx, record in enumerate(records):
        for agent_idx in record.get("risk_agents", []):
            if 0 <= int(agent_idx) < mask.shape[1]:
                mask[world_idx, int(agent_idx)] = True
    return mask & env.cont_agent_mask


def center_agent_for_record(record: dict[str, Any], control_mask: torch.Tensor, world_idx: int) -> int | None:
    for key in ("min_distance_risk_agent",):
        agent_idx = int(record.get(key, -1))
        if 0 <= agent_idx < control_mask.shape[1] and bool(control_mask[world_idx, agent_idx].item()):
            return agent_idx
    for agent_idx in record.get("risk_agents", []):
        agent_idx = int(agent_idx)
        if 0 <= agent_idx < control_mask.shape[1] and bool(control_mask[world_idx, agent_idx].item()):
            return agent_idx
    agents = torch.where(control_mask[world_idx])[0]
    return int(agents[0].item()) if len(agents) else None


def render(
    env: GPUDriveTorchEnv,
    frames: dict[int, list],
    worlds: list[int],
    center_agents: dict[int, int | None],
    time_step: int,
    policy_masks: dict[str, tuple[NeuralNet, torch.Tensor]],
    zoom_radius: float,
    live_mask: torch.Tensor | None = None,
) -> None:
    render_policy_masks = {}
    for name, (policy_fn, mask) in policy_masks.items():
        draw_mask = mask
        if live_mask is not None:
            draw_mask = draw_mask & live_mask
        render_policy_masks[name] = (policy_fn, draw_mask.detach().cpu())

    figures = env.vis.plot_simulator_state(
        env_indices=worlds,
        time_steps=[time_step] * len(worlds),
        center_agent_indices=[center_agents.get(world) for world in worlds],
        zoom_radius=zoom_radius,
        policy_masks=render_policy_masks,
    )
    for world, fig in zip(worlds, figures):
        frames[world].append(img_from_fig(fig))


def rollout(
    env: GPUDriveTorchEnv,
    policy: NeuralNet,
    steps: int,
    normal_mode: str,
    deterministic: bool,
    risk_mask: torch.Tensor,
    normal_weights: torch.Tensor,
    risk_weights: torch.Tensor,
    render_worlds: list[int] | None,
    center_agents: dict[int, int | None],
    frames: dict[int, list],
    render_every: int,
    stop_on_collision: bool,
    zoom_radius: float,
) -> dict[str, torch.Tensor]:
    control_mask = env.cont_agent_mask.clone()
    normal_mask = control_mask & ~risk_mask
    env.reward_weights_tensor[:] = normal_weights
    env.reward_weights_tensor[risk_mask] = risk_weights

    policy_masks = {
        "risk_taker": (policy, risk_mask),
        "balanced": (policy, normal_mask),
    }
    live_mask = control_mask.clone()
    collided = torch.zeros_like(control_mask, dtype=torch.bool, device=env.device)
    offroad = torch.zeros_like(control_mask, dtype=torch.bool, device=env.device)
    goal = torch.zeros_like(control_mask, dtype=torch.bool, device=env.device)
    stopped_render_worlds = torch.zeros(env.num_worlds, dtype=torch.bool, device=env.device)

    if render_worlds:
        render(
            env,
            frames,
            render_worlds,
            center_agents,
            0,
            policy_masks,
            zoom_radius,
            live_mask=live_mask,
        )

    expert_actions = None
    if normal_mode == "expert":
        expert_actions, _, _, _ = env.get_expert_actions()

    for step in range(steps):
        active = live_mask & control_mask
        if 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()):
                obs = env.get_obs(active_risk)
                with torch.no_grad():
                    action, _, _, _ = policy(obs, deterministic=deterministic)
                actions[active_risk] = env.action_keys_tensor[action.to(dtype=torch.long, device=env.device)]
        else:
            actions = torch.zeros((env.num_worlds, env.max_agent_count), dtype=torch.int64, device=env.device)
            if bool(active.any().item()):
                obs = env.get_obs(active)
                with torch.no_grad():
                    action, _, _, _ = policy(obs, deterministic=deterministic)
                actions[active] = action.to(dtype=torch.int64, device=env.device)

        env.step_dynamics(actions)
        infos = env.get_infos()
        collided |= (infos.collided > 0).bool() & active
        offroad |= (infos.off_road > 0).bool() & active
        goal |= (infos.goal_achieved > 0).bool() & active
        live_mask &= ~env.get_dones().bool()

        render_worlds_alive: list[int] = []
        render_collision_worlds = torch.zeros(env.num_worlds, dtype=torch.bool, device=env.device)
        if render_worlds:
            render_collision_worlds = (collided & control_mask).any(dim=1)
            render_worlds_alive = [
                world for world in render_worlds
                if not bool(stopped_render_worlds[world].item())
            ]

        should_render = bool(render_worlds_alive) and (
            (step + 1) % render_every == 0
            or (
                stop_on_collision
                and any(bool(render_collision_worlds[world].item()) for world in render_worlds_alive)
            )
        )
        if should_render:
            render(
                env,
                frames,
                render_worlds_alive,
                center_agents,
                step + 1,
                policy_masks,
                zoom_radius,
                live_mask=live_mask,
            )

        if stop_on_collision and render_worlds:
            for world in render_worlds:
                if bool(render_collision_worlds[world].item()):
                    stopped_render_worlds[world] = True
            if all(bool(stopped_render_worlds[world].item()) for world in render_worlds):
                print(f"[visualize] all rendered worlds stopped on collision at step={step + 1}", flush=True)
                break

        if not bool(live_mask.any().item()):
            break

    return {"collided": collided, "offroad": offroad, "goal": goal}


def event_sort_key(record: dict[str, Any]) -> tuple[int, float]:
    min_dist = record.get("min_distance_m", 1e9)
    try:
        min_dist_f = float(min_dist)
    except (TypeError, ValueError):
        min_dist_f = 1e9
    return (0 if record.get("collision") else 1, min_dist_f)


def select_records(records: list[dict[str, Any]], event_type: str, max_videos: int) -> list[dict[str, Any]]:
    if event_type != "any":
        records = [r for r in records if bool(r.get(event_type))]
    records = sorted(records, key=event_sort_key)
    return records[:max_videos]


def scenario_path(data_dir: Path, record: dict[str, Any]) -> Path:
    scenario_file = Path(str(record["scenario_file"]))
    return scenario_file if scenario_file.is_absolute() else data_dir / scenario_file.name


def write_videos(
    output_dir: Path,
    frames: dict[int, list],
    records_by_world: dict[int, dict[str, Any]],
    fps: int,
    prefix: str,
) -> dict[tuple[int, int, int], str]:
    written = {}
    for world_idx, world_frames in frames.items():
        if not world_frames:
            continue
        record = records_by_world[world_idx]
    shard_id = int(record.get("shard_id", 0))
    batch_idx = int(record.get("batch_idx", 0))
    original_world_idx = int(record.get("world_idx", world_idx))
    tag = "collision" if record.get("collision") else "near_miss" if record.get("near_miss") else "event"
    eval_tag = ""
    if record.get("llm_final_priority"):
        eval_tag = f"_{record['llm_final_priority']}"
    path = output_dir / (
        f"{prefix}_shard{shard_id:03d}"
        f"_batch{batch_idx:03d}"
        f"_world{original_world_idx:04d}_{tag}{eval_tag}.mp4"
    )
    media.write_video(path, world_frames, fps=fps)
    written[(shard_id, batch_idx, original_world_idx)] = str(path)
    print(f"[visualize] wrote {path}", flush=True)
    return written


def run_fast(
    args: argparse.Namespace,
    records: list[dict[str, Any]],
    config: dict[str, Any],
    policy: NeuralNet,
    env_config: EnvConfig,
    data_dir: Path,
    normal_mode: str,
    normal_weights: torch.Tensor,
    risk_weights: torch.Tensor,
) -> list[dict[str, Any]]:
    data_batch = [str(scenario_path(data_dir, record)) for record in records]
    loader = SceneDataLoader(
        root=str(data_dir),
        batch_size=len(records),
        dataset_size=max(args.dataset_size, len(records)),
        sample_with_replacement=False,
        shuffle=False,
        seed=args.seed,
    )
    env = GPUDriveTorchEnv(
        config=env_config,
        data_loader=loader,
        max_cont_agents=env_config.max_controlled_agents,
        device=args.device,
        render_config=RenderConfig(render_3d=bool(args.render_3d)),
    )
    env.swap_data_batch(data_batch)
    env.reset()

    risk_mask = risk_mask_from_records(env, records)
    worlds = list(range(len(records)))
    centers = {world: center_agent_for_record(records[world], env.cont_agent_mask, world) for world in worlds}
    frames = {world: [] for world in worlds}
    stats = rollout(
        env=env,
        policy=policy,
        steps=args.steps or env_config.episode_len,
        normal_mode=normal_mode,
        deterministic=bool(args.deterministic),
        risk_mask=risk_mask,
        normal_weights=normal_weights,
        risk_weights=risk_weights,
        render_worlds=worlds,
        center_agents=centers,
        frames=frames,
        render_every=args.render_every,
        stop_on_collision=bool(args.stop_on_collision),
        zoom_radius=args.zoom_radius,
    )

    records_by_world = {world: records[world] for world in worlds}
    videos = write_videos(Path(args.output_dir), frames, records_by_world, args.fps, "fast")
    return build_render_summaries(records_by_world, stats, videos, world_index_mode="local")


def build_render_summaries(
    records_by_world: dict[int, dict[str, Any]],
    stats: dict[str, torch.Tensor],
    videos: dict[tuple[int, int, int], str],
    world_index_mode: str,
) -> list[dict[str, Any]]:
    summaries = []
    for world, record in records_by_world.items():
        if world_index_mode == "original":
            stats_world = int(record["world_idx"])
        else:
            stats_world = world
        risk_agents = [int(a) for a in record.get("risk_agents", [])]
        risk_collided = any(
            0 <= agent < stats["collided"].shape[1] and bool(stats["collided"][stats_world, agent].item())
            for agent in risk_agents
        )
        video_key = (
            int(record.get("shard_id", 0)),
            int(record.get("batch_idx", 0)),
            int(record.get("world_idx", world)),
        )
        summaries.append(
            {
                "record": record,
                "video_path": videos.get(video_key),
                "risk_agents": risk_agents,
                "rerun_collision": bool(stats["collided"][stats_world].any().item()),
                "rerun_risk_collision": risk_collided,
                "rerun_offroad": bool(stats["offroad"][stats_world].any().item()),
                "rerun_goal_agents": int(stats["goal"][stats_world].sum().item()),
            }
        )
    return summaries


def run_exact_group(
    args: argparse.Namespace,
    records: list[dict[str, Any]],
    summary: dict[str, Any],
    config: dict[str, Any],
    policy: NeuralNet,
    data_dir: Path,
    normal_mode: str,
    normal_weights: torch.Tensor,
    risk_weights: torch.Tensor,
) -> list[dict[str, Any]]:
    shard_id = int(records[0].get("shard_id", summary.get("shard_id", 0)))
    batch_idx = int(records[0].get("batch_idx", 0))
    seed = args.seed + shard_id * 100_000
    num_worlds = args.num_worlds or int(summary.get("num_worlds", 1000))
    dataset_size = args.dataset_size
    steps = args.steps or int(summary.get("steps", 91))
    risk_agents_per_world = args.risk_agents_per_world or int(summary.get("risk_agents_per_world", 3))
    env_config = make_env_config(config["environment"], num_worlds, args)

    torch.manual_seed(seed)
    generator = torch.Generator(device=args.device)
    generator.manual_seed(seed)

    loader = SceneDataLoader(
        root=str(data_dir),
        batch_size=num_worlds,
        dataset_size=dataset_size,
        sample_with_replacement=True,
        shuffle=True,
        seed=seed,
    )
    env = GPUDriveTorchEnv(
        config=env_config,
        data_loader=loader,
        max_cont_agents=env_config.max_controlled_agents,
        device=args.device,
        render_config=RenderConfig(render_3d=bool(args.render_3d)),
    )

    target_records_by_world = {int(record["world_idx"]): record for record in records}
    frames = {world: [] for world in target_records_by_world}
    final_stats = None

    for current_batch in range(batch_idx + 1):
        if current_batch > 0:
            env.swap_data_batch()
        env.reset()
        risk_mask = choose_risk_agents(env.cont_agent_mask.clone(), risk_agents_per_world, generator)

        render_worlds = None
        centers: dict[int, int | None] = {}
        if current_batch == batch_idx:
            for world, record in target_records_by_world.items():
                actual = Path(env.data_batch[world]).name
                expected = str(record.get("scenario_file", ""))
                if expected and Path(expected).name != actual:
                    print(
                        "[visualize] warning:",
                        f"record scenario_file={expected} but replay batch has {actual}",
                        flush=True,
                    )
                expected_risk = sorted(int(a) for a in record.get("risk_agents", []))
                actual_risk = sorted(torch.where(risk_mask[world])[0].detach().cpu().tolist())
                if expected_risk and expected_risk != actual_risk:
                    print(
                        "[visualize] warning:",
                        f"record risk_agents={expected_risk} but replay risk_agents={actual_risk}",
                        flush=True,
                    )
                centers[world] = center_agent_for_record(record, env.cont_agent_mask, world)
            render_worlds = list(target_records_by_world)

        stats = rollout(
            env=env,
            policy=policy,
            steps=steps,
            normal_mode=normal_mode,
            deterministic=bool(args.deterministic),
            risk_mask=risk_mask,
            normal_weights=normal_weights,
            risk_weights=risk_weights,
            render_worlds=render_worlds,
            center_agents=centers,
            frames=frames,
            render_every=args.render_every,
            stop_on_collision=bool(args.stop_on_collision),
            zoom_radius=args.zoom_radius,
        )
        if current_batch == batch_idx:
            final_stats = stats

    videos = write_videos(Path(args.output_dir), frames, target_records_by_world, args.fps, "exact")
    return build_render_summaries(target_records_by_world, final_stats, videos, world_index_mode="original")


def main() -> None:
    args = parse_args()
    args.device = args.device if torch.cuda.is_available() or args.device == "cpu" else "cpu"
    search_dir = Path(args.search_dir)
    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    records = load_records(search_dir, args.events_file)
    if not records:
        raise RuntimeError(f"No event records found under {search_dir}")
    records = select_records(records, args.event_type, args.max_videos)
    if not records:
        raise RuntimeError(f"No records matched event_type={args.event_type}")

    shard_summaries = load_shard_summaries(search_dir)
    first_summary = shard_summaries.get(int(records[0].get("shard_id", 0)), None)
    config = load_config(args.config)
    data_dir = Path(args.data_dir or (first_summary or {}).get("data_dir", "/mingli01/data/GPUDrive_mini/training"))
    checkpoint = resolve_checkpoint(args.checkpoint, first_summary)

    num_worlds_for_config = len(records) if args.replay_mode == "fast" else int((first_summary or {}).get("num_worlds", args.num_worlds or 1000))
    env_config = make_env_config(config["environment"], num_worlds_for_config, args)
    normal_mode = args.normal_mode or str((first_summary or {}).get("normal_mode", "policy"))

    normal_weights = tensor_from_summary_or_preset(
        first_summary,
        "normal_weights",
        reward_preset(env_config, args.normal_style, args.device),
        args.device,
    )
    risk_weights = tensor_from_summary_or_preset(
        first_summary,
        "risk_weights",
        reward_preset(env_config, args.risk_style, args.device),
        args.device,
    )
    risk_weights = apply_weight_overrides(risk_weights, args)

    policy = load_policy(checkpoint, config, args.device)
    print(
        "[visualize] start:",
        f"mode={args.replay_mode}",
        f"records={len(records)}",
        f"checkpoint={checkpoint}",
        f"data_dir={data_dir}",
        f"normal_mode={normal_mode}",
        f"normal_weights={normal_weights.detach().cpu().tolist()}",
        f"risk_weights={risk_weights.detach().cpu().tolist()}",
        flush=True,
    )

    start = time.time()
    if args.replay_mode == "fast":
        summaries = run_fast(
            args=args,
            records=records,
            config=config,
            policy=policy,
            env_config=make_env_config(config["environment"], len(records), args),
            data_dir=data_dir,
            normal_mode=normal_mode,
            normal_weights=normal_weights,
            risk_weights=risk_weights,
        )
    else:
        summaries = []
        groups: dict[tuple[int, int], list[dict[str, Any]]] = defaultdict(list)
        for record in records:
            groups[(int(record.get("shard_id", 0)), int(record.get("batch_idx", 0)))].append(record)
        for (shard_id, batch_idx), group_records in sorted(groups.items()):
            summary = shard_summaries.get(shard_id, first_summary or {})
            print(
                "[visualize] exact group:",
                f"shard={shard_id}",
                f"batch={batch_idx}",
                f"worlds={[int(r['world_idx']) for r in group_records]}",
                flush=True,
            )
            summaries.extend(
                run_exact_group(
                    args=args,
                    records=group_records,
                    summary=summary,
                    config=config,
                    policy=policy,
                    data_dir=data_dir,
                    normal_mode=normal_mode,
                    normal_weights=normal_weights,
                    risk_weights=risk_weights,
                )
            )

    output_summary = {
        "search_dir": str(search_dir),
        "output_dir": str(output_dir),
        "replay_mode": args.replay_mode,
        "checkpoint": str(checkpoint),
        "data_dir": str(data_dir),
        "normal_mode": normal_mode,
        "normal_weights": normal_weights.detach().cpu().tolist(),
        "risk_weights": risk_weights.detach().cpu().tolist(),
        "stop_on_collision": bool(args.stop_on_collision),
        "render_3d": bool(args.render_3d),
        "rendered_records": len(summaries),
        "videos": [s.get("video_path") for s in summaries if s.get("video_path")],
        "elapsed_sec": round(time.time() - start, 3),
        "records": summaries,
    }
    with open(output_dir / "render_summary.json", "w", encoding="utf-8") as f:
        json.dump(output_summary, f, indent=2)
    print(json.dumps({k: v for k, v in output_summary.items() if k != "records"}, indent=2), flush=True)


if __name__ == "__main__":
    main()