From c07d855efc6a62fddfd038c0939b24375a675de8 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 20 Mar 2025 10:01:22 -0400 Subject: [PATCH 01/81] Improve formatting tutorial 8 --- examples/tutorials/08_multiple_policies.ipynb | 160 +++++++++++------- 1 file changed, 101 insertions(+), 59 deletions(-) diff --git a/examples/tutorials/08_multiple_policies.ipynb b/examples/tutorials/08_multiple_policies.ipynb index 7b7bbd13f..04614dda4 100644 --- a/examples/tutorials/08_multiple_policies.ipynb +++ b/examples/tutorials/08_multiple_policies.ipynb @@ -1,8 +1,15 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using multiple policies in the same environment" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -16,42 +23,68 @@ "from gpudrive.env.env_torch import GPUDriveTorchEnv\n", "from gpudrive.env.dataset import SceneDataLoader\n", "from gpudrive.utils.config import load_config \n", - "import sys\n", - "import imageio\n", - "import numpy as np\n", - "import os\n", - "from gpudrive.utils.multi_policy_rollout import multi_policy_rollout\n" + "\n", + "from gpudrive.utils.rollout import multi_policy_rollout" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Helper function" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def create_policy_masks(env, num_sim_agents=2, num_worlds=10):\n", + " \"\"\"\n", + " Create policy masks for multiple agents across different worlds.\n", + " \n", + " Args:\n", + " env: The environment object containing agent mask information\n", + " num_sim_agents: Number of simultaneous agents to create policies for\n", + " num_worlds: Number of simulation worlds\n", + " \n", + " Returns:\n", + " Dictionary of policy masks with keys 'pi_1', 'pi_2', etc.\n", + " \"\"\"\n", + " # Initialize policy mask with zeros (same shape as cont_agent_mask)\n", " policy_mask = torch.zeros_like(env.cont_agent_mask, dtype=torch.int)\n", + " \n", + " # Get indices of controlled agents\n", " agent_indices = env.cont_agent_mask.nonzero(as_tuple=True)\n", "\n", + " # Assign policy numbers (1 to num_sim_agents) to each agent in a round-robin fashion\n", " for i, (world_idx, agent_idx) in enumerate(zip(*agent_indices)):\n", " policy_mask[world_idx, agent_idx] = (i % num_sim_agents) + 1\n", "\n", - " policy_masks = {f'pi_{int(policy.item())}': torch.zeros_like(env.cont_agent_mask, dtype=torch.bool,device=device) \n", - " for policy in policy_mask.unique() if policy.item() != 0}\n", - "\n", + " # Create a dictionary of empty boolean masks for each policy\n", + " policy_masks = {\n", + " f'pi_{int(policy.item())}': torch.zeros_like(\n", + " env.cont_agent_mask, \n", + " dtype=torch.bool,\n", + " device=env.cont_agent_mask.device # Use the same device as the mask\n", + " ) \n", + " for policy in policy_mask.unique() if policy.item() != 0\n", + " }\n", + "\n", + " # Fill in the boolean masks for each policy\n", " for p in range(1, num_sim_agents + 1):\n", " policy_masks[f'pi_{p}'] = (policy_mask == p).reshape(num_worlds, -1)\n", "\n", - " return policy_masks\n" + " return policy_masks" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "\n", "# Configs model has been trained with\n", "config = load_config(\"../../examples/experimental/config/reliable_agents_params\")\n", "max_agents = config.max_controlled_agents\n", @@ -61,25 +94,22 @@ "FPS = 5\n", "\n", "sim_agent1 = NeuralNet.from_pretrained(\"daphne-cornelisse/policy_S10_000_02_27\")\n", - "sim_agent2 = NeuralNet.from_pretrained(\"daphne-cornelisse/policy_S1000_02_27\")\n", - "\n", - "# Some other info\n", - "card = ModelCard.load(\"daphne-cornelisse/policy_S10_000_02_27\")\n", - "\n", - "\n", - "\n", - "\n", - "sim_agent1 = NeuralNet.from_pretrained(\"daphne-cornelisse/policy_S10_000_02_27\")\n", - "sim_agent2 = NeuralNet.from_pretrained(\"daphne-cornelisse/policy_S1000_02_27\")\n" + "sim_agent2 = NeuralNet.from_pretrained(\"daphne-cornelisse/policy_S1000_02_27\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Make environment" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "\n", "train_loader = SceneDataLoader(\n", " root='../../data/processed/examples',\n", " batch_size=NUM_ENVS,\n", @@ -111,8 +141,6 @@ " ),\n", ")\n", "\n", - "\n", - "\n", "env = GPUDriveTorchEnv(\n", " config=env_config,\n", " data_loader=train_loader,\n", @@ -121,61 +149,75 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Rollout" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "next_obs = env.reset()\n", "\n", - "\n", "control_mask = env.cont_agent_mask\n", "\n", - "policy_mask = create_policy_masks(env, 2,NUM_ENVS)\n", - "\n", - "policies_set = {'pi_1': (sim_agent1,policy_mask['pi_1']),\n", - " 'pi_2': (sim_agent2, policy_mask['pi_2'])\n", - " } \n", - " \n", + "# Create policy masks for 2 agents across NUM_ENVS worlds\n", + "policy_mask = create_policy_masks(env, num_sim_agents=2, num_worlds=NUM_ENVS)\n", "\n", + "# Define the policy set with agent models and their corresponding masks\n", + "policies_set = {\n", + " 'pi_1': (sim_agent1, policy_mask['pi_1']),\n", + " 'pi_2': (sim_agent2, policy_mask['pi_2'])\n", + "}\n", "\n", - "metrics,frames=multi_policy_rollout(\n", - "env,\n", - "policies_set, \n", - "device,\n", - "deterministic=False,\n", - "render_sim_state = True,\n", - "render_every_n_steps= 5\n", + "# Rollout with multiple policies\n", + "metrics, frames = multi_policy_rollout(\n", + " env=env,\n", + " policies=policies_set,\n", + " device=device,\n", + " deterministic=False,\n", + " render_sim_state=True,\n", + " render_every_n_steps=5\n", ")\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "env.close()\n" + "env.close()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + "
0
\n", + "
\n", + "
1
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "\n", - "mediapy.show_videos(frames, fps=15, width=500, height=500, columns=2, codec='gif')" + "mediapy.show_videos(frames, fps=10, width=500, height=500, columns=2, codec='gif')" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "gpudriveenv", + "display_name": "gpudrive", "language": "python", "name": "python3" }, @@ -189,7 +231,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.11" + "version": "3.11.9" } }, "nbformat": 4, From f1dedc0736f830b9c637650f50c625718e0ac0b0 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 20 Mar 2025 16:11:16 -0400 Subject: [PATCH 02/81] Visualize rollouts with different rewards. --- .../notebooks/04_reward_cond_agents.ipynb | 435 ++++++++++++++++++ gpudrive/env/config.py | 7 +- gpudrive/env/env_torch.py | 61 ++- gpudrive/utils/checkpoint.py | 29 ++ gpudrive/utils/env.py | 52 +++ gpudrive/utils/multi_policy_rollout.py | 195 -------- gpudrive/utils/rollout.py | 432 +++++++++++++++++ gpudrive/visualize/core.py | 426 +++++++++++------ 8 files changed, 1279 insertions(+), 358 deletions(-) create mode 100644 examples/experimental/notebooks/04_reward_cond_agents.ipynb create mode 100644 gpudrive/utils/checkpoint.py create mode 100644 gpudrive/utils/env.py delete mode 100644 gpudrive/utils/multi_policy_rollout.py create mode 100644 gpudrive/utils/rollout.py diff --git a/examples/experimental/notebooks/04_reward_cond_agents.ipynb b/examples/experimental/notebooks/04_reward_cond_agents.ipynb new file mode 100644 index 000000000..ffbf301fe --- /dev/null +++ b/examples/experimental/notebooks/04_reward_cond_agents.ipynb @@ -0,0 +1,435 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import dataclasses\n", + "import mediapy\n", + "from huggingface_hub import PyTorchModelHubMixin\n", + "from huggingface_hub import ModelCard\n", + "from gpudrive.networks.late_fusion import NeuralNet\n", + "import matplotlib.pyplot as plt\n", + "from collections import defaultdict\n", + "import random\n", + "\n", + "from gpudrive.env.config import EnvConfig\n", + "from gpudrive.env.env_torch import GPUDriveTorchEnv\n", + "from gpudrive.visualize.utils import img_from_fig\n", + "from gpudrive.env.dataset import SceneDataLoader\n", + "from gpudrive.utils.config import load_config\n", + "from gpudrive.utils.checkpoint import load_policy\n", + "from gpudrive.utils.rollout import rollout\n", + "\n", + "from PIL import Image" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'mode': 'train', 'use_rnn': False, 'eval_model_path': None, 'baseline': False, 'data_dir': 'data/processed/training', 'continue_training': False, 'model_cpt': None, 'environment': {'name': 'gpudrive', 'num_worlds': 75, 'k_unique_scenes': 75, 'max_controlled_agents': 64, 'ego_state': True, 'road_map_obs': True, 'partner_obs': True, 'norm_obs': True, 'remove_non_vehicles': False, 'lidar_obs': False, 'reward_type': 'reward_conditioned', 'collision_weight': -0.75, 'off_road_weight': -0.75, 'goal_achieved_weight': 1.0, 'dynamics_model': 'classic', 'collision_behavior': 'ignore', 'dist_to_goal_threshold': 2.0, 'polyline_reduction_threshold': 0.1, 'sampling_seed': 42, 'obs_radius': 50.0, 'action_space_steer_disc': 13, 'action_space_accel_disc': 7}, 'wandb': {'entity': '', 'project': 'kshotagents', 'group': 'reward_conditioned', 'mode': 'online', 'tags': ['ppo', 'ff']}, 'train': {'exp_id': 'PPO', 'seed': 42, 'cpu_offload': False, 'device': 'cuda', 'bptt_horizon': 1, 'compile': False, 'compile_mode': 'reduce-overhead', 'resample_scenes': True, 'resample_dataset_size': 10000, 'resample_interval': 2000000, 'sample_with_replacement': True, 'shuffle_dataset': False, 'torch_deterministic': False, 'total_timesteps': 2000000000, 'batch_size': 131072, 'minibatch_size': 8192, 'learning_rate': '3e-4', 'anneal_lr': False, 'gamma': 0.99, 'gae_lambda': 0.95, 'update_epochs': 4, 'norm_adv': True, 'clip_coef': 0.2, 'clip_vloss': False, 'vf_clip_coef': 0.2, 'ent_coef': 0.0001, 'vf_coef': 0.3, 'max_grad_norm': 0.5, 'target_kl': None, 'log_window': 1000, 'network': {'input_dim': 64, 'hidden_dim': 128, 'dropout': 0.01, 'class_name': 'NeuralNet', 'num_parameters': 0}, 'checkpoint_interval': 400, 'checkpoint_path': './runs', 'render': False, 'render_3d': True, 'render_interval': 1, 'render_k_scenarios': 10, 'render_format': 'mp4', 'render_fps': 15, 'zoom_radius': 50}, 'vec': {'backend': 'native', 'num_workers': 1, 'env_batch_size': 1, 'zero_copy': False}}\n" + ] + } + ], + "source": [ + "# Configs model has been trained with\n", + "config = load_config(\"/home/emerge/gpudrive/baselines/ppo/config/ppo_base_puffer\")\n", + "\n", + "print(config)\n", + "\n", + "num_envs = 5\n", + "device = \"cpu\"\n", + "max_agents = 64\n", + "\n", + "config.environment.reward_type = \"reward_conditioned\"\n", + "config.environment.condition_mode = \"fixed\"\n", + "config.environment.agent_type = torch.Tensor([-0.2, 1.0, -0.2])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Load model from /home/emerge/gpudrive/examples/experimental/models/model_PPO____R_10000__03_19_19_05_33_518_006000.pt\n" + ] + } + ], + "source": [ + "agent = load_policy(\n", + " model_name=\"model_PPO____R_10000__03_19_19_05_33_518_006000\",\n", + " path_to_cpt=\"/home/emerge/gpudrive/examples/experimental/models\",\n", + " env_config=config.environment,\n", + " device=device\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Create data loader\n", + "train_loader = SceneDataLoader(\n", + " root='/home/emerge/gpudrive/data/processed/training/',\n", + " batch_size=num_envs,\n", + " dataset_size=100,\n", + " sample_with_replacement=False,\n", + ")\n", + "\n", + "# Set params\n", + "config = config.environment\n", + "env_config = dataclasses.replace(\n", + " EnvConfig(),\n", + " norm_obs=config.norm_obs,\n", + " dynamics_model=config.dynamics_model,\n", + " collision_behavior=config.collision_behavior,\n", + " dist_to_goal_threshold=config.dist_to_goal_threshold,\n", + " polyline_reduction_threshold=config.polyline_reduction_threshold,\n", + " remove_non_vehicles=config.remove_non_vehicles,\n", + " lidar_obs=config.lidar_obs,\n", + " disable_classic_obs=config.lidar_obs,\n", + " obs_radius=config.obs_radius,\n", + " steer_actions = torch.round(\n", + " torch.linspace(-torch.pi, torch.pi, config.action_space_steer_disc), decimals=3 \n", + " ),\n", + " accel_actions = torch.round(\n", + " torch.linspace(-4.0, 4.0, config.action_space_accel_disc), decimals=3\n", + " ),\n", + " reward_type=config.reward_type,\n", + " condition_mode=config.condition_mode,\n", + " agent_type=config.agent_type,\n", + ")\n", + "\n", + "# Make env\n", + "env = GPUDriveTorchEnv(\n", + " config=env_config,\n", + " data_loader=train_loader,\n", + " max_cont_agents=64, #config.max_controlled_agents,\n", + " device=device,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "def run_multiple_rollouts(env, agent, num_rollouts=2, device='cpu'):\n", + " \"\"\"\n", + " Run multiple rollouts with different collision weights and store trajectories.\n", + " Stores agent positions as a tensor of shape [num_envs, num_rollouts, agents, steps, 2].\n", + " \n", + " Args:\n", + " env: The environment (can be batched with multiple environments)\n", + " agent: The policy\n", + " num_rollouts: Number of rollouts to perform\n", + " device: Device to run on\n", + " \n", + " Returns:\n", + " all_trajectories: Dictionary containing trajectories and weights\n", + " \"\"\"\n", + " import torch\n", + " import random\n", + " import numpy as np\n", + " \n", + " # Get environment info to determine dimensions\n", + " obs = env.reset(agent_type=torch.Tensor([0.0, 0.0, 0.0]))\n", + " num_envs = obs.shape[0] if hasattr(obs, 'shape') else 1\n", + " \n", + " # Lists to collect data across rollouts\n", + " all_agent_positions = []\n", + " collision_weights = []\n", + " goal_weights = []\n", + " offroad_weights = []\n", + " all_goal_achieved = []\n", + " all_collided = []\n", + " all_off_road = []\n", + " all_episode_lengths = []\n", + " \n", + " for i in range(num_rollouts):\n", + " print(f\"Running rollout {i+1}/{num_rollouts}\")\n", + " \n", + " # Sample separate weights\n", + " collision_weight = random.uniform(-3.0, 1.0)\n", + " goal_weight = 1.0\n", + " off_road_weight = -3.0\n", + " \n", + " agent_weights = torch.Tensor([collision_weight, goal_weight, off_road_weight])\n", + " print(f\"Using weights: {agent_weights}\")\n", + " \n", + " # Run rollout with these weights\n", + " (\n", + " goal_achieved_count,\n", + " frac_goal_achieved,\n", + " collided_count,\n", + " frac_collided,\n", + " off_road_count,\n", + " frac_off_road,\n", + " not_goal_nor_crash_count,\n", + " frac_not_goal_nor_crash_per_scene,\n", + " controlled_agents_per_scene,\n", + " sim_state_frames,\n", + " agent_positions,\n", + " episode_lengths\n", + " ) = rollout(\n", + " env=env,\n", + " policy=agent,\n", + " device=device,\n", + " deterministic=False,\n", + " return_agent_positions=True,\n", + " set_agent_type=True,\n", + " agent_weights=agent_weights,\n", + " )\n", + " \n", + " # Store weights and positions\n", + " collision_weights.append(collision_weight)\n", + " goal_weights.append(goal_weight)\n", + " offroad_weights.append(off_road_weight)\n", + " all_agent_positions.append(agent_positions.clone().detach())\n", + " \n", + " # Store other metrics\n", + " all_goal_achieved.append(goal_achieved_count)\n", + " all_collided.append(collided_count)\n", + " all_off_road.append(off_road_count)\n", + " all_episode_lengths.append(episode_lengths)\n", + " \n", + " # Stack agent positions along a new dimension at position 1 (after num_envs)\n", + " # From list of [num_envs, num_agents, time_steps, 2] to tensor of [num_envs, num_rollouts, num_agents, time_steps, 2]\n", + " stacked_positions = torch.stack(all_agent_positions, dim=1)\n", + " \n", + " # Return organized data\n", + " all_trajectories = {\n", + " 'collision_weights': torch.tensor(collision_weights),\n", + " 'goal_weights': torch.tensor(goal_weights),\n", + " 'offroad_weights': torch.tensor(offroad_weights),\n", + " 'agent_positions': stacked_positions, # Shape: [num_envs, num_rollouts, num_agents, time_steps, 2]\n", + " 'goal_achieved': all_goal_achieved,\n", + " 'collided': all_collided,\n", + " 'off_road': all_off_road,\n", + " 'episode_lengths': all_episode_lengths\n", + " }\n", + " \n", + " return all_trajectories" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running rollout 1/20\n", + "Using weights: tensor([-0.7195, 1.0000, -3.0000])\n", + "Running rollout 2/20\n", + "Using weights: tensor([-1.5693, 1.0000, -3.0000])\n", + "Running rollout 3/20\n", + "Using weights: tensor([-0.4519, 1.0000, -3.0000])\n", + "Running rollout 4/20\n", + "Using weights: tensor([-1.6423, 1.0000, -3.0000])\n", + "Running rollout 5/20\n", + "Using weights: tensor([-0.9070, 1.0000, -3.0000])\n", + "Running rollout 6/20\n", + "Using weights: tensor([ 0.8978, 1.0000, -3.0000])\n", + "Running rollout 7/20\n", + "Using weights: tensor([-0.3654, 1.0000, -3.0000])\n", + "Running rollout 8/20\n", + "Using weights: tensor([-2.8612, 1.0000, -3.0000])\n", + "Running rollout 9/20\n", + "Using weights: tensor([-1.7468, 1.0000, -3.0000])\n", + "Running rollout 10/20\n", + "Using weights: tensor([-2.3545, 1.0000, -3.0000])\n", + "Running rollout 11/20\n", + "Using weights: tensor([-2.1445, 1.0000, -3.0000])\n", + "Running rollout 12/20\n", + "Using weights: tensor([ 0.9851, 1.0000, -3.0000])\n", + "Running rollout 13/20\n", + "Using weights: tensor([-0.1805, 1.0000, -3.0000])\n", + "Running rollout 14/20\n", + "Using weights: tensor([ 0.2572, 1.0000, -3.0000])\n", + "Running rollout 15/20\n", + "Using weights: tensor([-2.2591, 1.0000, -3.0000])\n", + "Running rollout 16/20\n", + "Using weights: tensor([-0.6897, 1.0000, -3.0000])\n", + "Running rollout 17/20\n", + "Using weights: tensor([-0.5889, 1.0000, -3.0000])\n", + "Running rollout 18/20\n", + "Using weights: tensor([-0.6967, 1.0000, -3.0000])\n", + "Running rollout 19/20\n", + "Using weights: tensor([-1.2825, 1.0000, -3.0000])\n", + "Running rollout 20/20\n", + "Using weights: tensor([-1.3794, 1.0000, -3.0000])\n" + ] + } + ], + "source": [ + "trajs = run_multiple_rollouts(\n", + " env=env,\n", + " agent=agent,\n", + " num_rollouts=20,\n", + " device='cpu'\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([5, 20, 64, 91, 2])" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trajs['agent_positions'].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([-0.7195, -1.5693, -0.4519, -1.6423, -0.9070, 0.8978, -0.3654, -2.8612,\n", + " -1.7468, -2.3545, -2.1445, 0.9851, -0.1805, 0.2572, -2.2591, -0.6897,\n", + " -0.5889, -0.6967, -1.2825, -1.3794])" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trajs['collision_weights']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAMgAyADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3+iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAMXxR/wAgq3HrqNj/AOlURrYb7yfX+hrG8UMBYWQIPzalZjgZ/wCW6H+lbLfeWgCtZc6bGf7w3fmc/wBaW6P+k2Q/6bE/+Q3pLD/kE2n/AFyj/kKWfm+tR6b2/TH9aALDfeX61Bdf8fFl/wBdj/6Lepz99fxqC6/4+LL/AK7H/wBFvQBOn3BXOeMP+Qfpf/YZs/8A0etdGn3BXOeMP+Qfpf8A2GbP/wBHrQB0tFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAGLa/wDI76r/ANg6z/8ARlzW1WLa/wDI76r/ANg6z/8ARlzW1QA0/wCsX6H+lOpp/wBYv0P9KdQA1Pu/if506mp938T/ADp1AGLcc+N9O9tOuv8A0Zb/AOFbVYs3Pjey9tOuP/RkP+FbVABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAYviLkaVH/f1GH9Mt/7LWwThwT2B/pWPrvOo+H0/vaif0t5m/wDZa07ltkMrf3Y2NAEdiMaVaA/88o/5CnSf8hO3/wCuMh/VKdCuy0gT0VR+lMf/AJCkH/XGT/0JKALB++v41Bdf8fFl/wBdj/6Lepz99fxqvdf8fNj/ANdz/wCi3oAsJ9xfpXOeMP8AkH6X/wBhmz/9HrXRp/q1+lc54w/5B+l/9hmz/wDR60AdLRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBi2v/I76r/2DrP/ANGXNbVYtr/yOuq/9g+zH/kS5raoAaf9Yv0P9KdTT/rB9D/SnUANT7v4n+dOpqfd/E/zp1AGLJz43tvbTpv/AEZH/hW1WK/PjeH205//AEYn+FbVABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAYutc6z4cX0v3b8Pss4/rV/USRp94R1EDfyNZ2qtnxNoEe0n555MjoMRkc/8AfVaOo/8AIPvf+uDfyNAFkjGwe/8ASq5OdVUY+7Aefqw/wqw33l+v9DVcf8hRvaEf+hGgCwfvr+NQXX/HxZf9dj/6Lep2+8v1qC6/4+LL/rsf/Rb0ATp/q1+grnPGH/IP0v8A7DNn/wCj1ro0/wBWv0Fc54w/5B+l/wDYZs//AEetAHS0UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAYtn/AMjnq3/XlaD/AMfnrarFsv8AkcdY/wCvS0H/AI9NW1QA0/6xfof6U6mn/WL9D/SnUANT7v4n+dOpqfd/E/zp1AGKefG6+2nH/wBGD/CtqsUc+N29tOH/AKMP+FbVABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAYt583jLSE/u2V3J+TQL/AOzVfv8AmxuR6rt/Pj+tUJ/m8b2P/TPTrj/x6SH/AOIq/ff8ezD1mjX82UUAWW+8v1/pVdc/2q/p5C/+hGp2P7xB9agPGqD3hP6MP8aALDfeT6/0NQXX/HxZf9dj/wCi3qduqfX+hqC6/wCPiy/67H/0W9AE6f6tfoK5vxiAdP0vIz/xObL/ANKFrpE/1a/QVznjD/kH6X/2GbP/ANHrQB0tFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAGLY/8jdrP/Xvaj/0bW1WLp//ACNmtf8AXG2H6SVtUANP+sX6H+lOpp/1i/Q06gBqfd/E/wA6dTU+7+J/nTqAMNGB8dTJzkaah6cf61+/4VuVip/yO0//AGDo/wD0Y9bVABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAYqfP43m/6ZabH/49I/8A8RV+8/49x/18Rf8Aoxaz7XnxvqvHA06zGf8Atpc//WrQu+YIx63Cfo4P9KALDf65Pof6VA+RqsPoYJP0ZP8AGpm/10f41DLxqVs3rHIv/oJ/pQBYfsfcVBdf8fFl/wBdj/6Lep3+7+I/nVe6/wCPiy/67H/0W9AFhP8AVr9BXO+MRiw0v/sMWX/o9a6JP9Wv0rA8Yxs2nacwxtj1axZufW4QfzIoA6GiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDD01FHivXXCgMUtgSBycK3+NblYumc+JddP8AtQD/AMh//XraoAafvr9DTqafvr9DTqAGp938T/OnU1Pu/if506gDFj/5Ha4/7B0X/ox62qxY/wDkdrj/ALB0X/oyStqgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAMWw+bxdrLelvap+XmH/2ar9zybZfW4/kGP9KoaV83iLX29JYU/KJT/wCzVfn/ANdY/wDXc/8AoD0ATv8AfU+n+IqG64ubIj/nsQfp5b/4Cp2G5iP9mq94f3EMncTR4/FgD+hNAFl/uH86r3X/AB82X/XY/wDot6sP/q2+hpSisVJUEqcqT2OMf1oARPuCsfxT/wAgiE+mo2J/8moq2E+5+dYvi1tnh55CCRHc2znAzgCeM5/SgDcooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAxdJ58Q6+f+m0I/8AIK/41tViaMytr/iIAglbqIEZ6f6PGf61t0ANP31/GnU0/fX8adQA1Pu/if506mp938TTqAMSNj/wnNwu04/s2I7uMf62TitusUceN2/2tNH6SH/GtqgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAMXRedY8Rn01BF/D7LAf61en/1un/8AXU/+i3qhoJLal4iYjGdSGOeuLeAf0rQl5uLEe7H/AMcP+NAFn/lofoKq3+RptyQcGNS4+o+Yfyq0P9YfoP6010Egkjb7rrg/yNAD2GVI9qFOVB9qgsXMun2zt95olJ+uKmjOY1PsKABPu/if51m+JbaW88LatbQIXnks5ViUdS+07ce+cVpJ0P1P86dQBXsbuPUNPtr2E5iuIllT/dYAj+dWKwvDDNbW93o8i7JNOuGjjXPWBiWhI9tpC/VD6Vu0AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUyWWOCF5pXVI41LOzHAUDkk0AY3h91lv8AxDMpyr6lt/75ghQ/qprcrG8KRuPDdpPKjJLd77yRHGGVpmMhUjsRvx+FbNADT99fxp1NP31/GnUANT7tOpqfcFOoAw5CyeOrYFfll02Xac90ljz/AOhitysPWibXWdEv8DyxO9rK2furKuF/ORYx+IrcoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDF0D/j61w+uot/6KjH9Kvvze2g9Ec/yH9az9A+/rLeuoyfoqD+laDf8AIRth/wBMJP5pQBZH+sP0H9aD/rF+h/pQP9Y30H9aTcr+WykFTyCDkEYoAgsOLUr2SSRR7AOQP0xU8P8Aql9uKgteJ7xewmyB9UU/zzU0X3SPRjQA5O/1NOpq9W+v9KdQBha3HNp1/Br1shkSCMw30SKS0kBOQygdWQ5YDuGcDkitqGWO4hSaGRZIpFDI6HIYHkEHuKyrnUrqKacRrGVjOMEcn9azLIXmgWv2u2hkudJkZnls41LSWpJOWiHVk7mMcj+HPC07CudXRVeyv7TUrVbmyuI54W4DxtkZHUexHcdqsUhhRVG51nTbO8jtLm+gink+7GzgH8fT8avUk09ENxaV2twooopiCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKwNef+07u38PRKXFwRLfEdI7YEkhv+uhGzHcFz/DVnUdZMN1/Z2nQi81MqG8rdhIVPR5W/hHoOSewOCRLo+lnTLZzNN9ovbh/Nurjbt818Y4GThQAABk4AHXqQDRooooAY3+tj/H+VPpj/wCsj+p/lT6AGRf6sfj/ADp9Mi/1Y+p/nT6AKOs6edV0a7slk8qSWMiKXGfLkHKPj/ZYA/hTNF1JtT05ZJoxFdxMYbqEH/VSr94fTuD3Ug960awtRs7vT9SfWtNRpi6Kl5ZDA89Vzh0/6aAHHJwwwDjAIAN2iq1hf2up2cd3ZzLLC/Rh2I4II6gg8EHkEYNWaACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDD8P/AOq1Y+uoT/zA/pWk/wDyFLf/AK4Sf+hR1meHCxtNULKB/wATG5xznI3mtN/+Qpb/APXGT/0JKALA++30FVbD/kG2P/XJP/QatD77fhVWx/5Bdl/1yj/9BFADogBqdzgdYo2P1y4/oKmXhs9iSP1NQ/d1Qf8ATSH/ANBb/wCyqcDchB9T/OgBV+831/oKdUaHDsrdc8e/FSUAY0cam91KUjLKhAz24NXdK/5BsP4/zNUvMWJ9UdzgYx9TzV3Sv+QZDxjg/wAzTZKKt54csbq9a+iM9nfMMG5tJTGzem4fdfH+2DUBt/EtqrCLULC+jA+UXFu0Mh+roSpP0QVu0Uij5wme5adzOrGXcd5diWz3znvXq3g2/wBai8MWqrpElzGC2yRrpVJGTjhu1dRd6DpV9ex3l1YQS3EfR2Xr9fX8a0QABgcCuHDYN0ZuTdz08Zj44imoKNjDXVtaIO7w1OOSOLuE5Hr96nf2tq//AELd1+FzB/8AF1tUV3HmGL/a+q/9Cze/hcW//wAco/tnVP8AoWNQ/Ce3/wDjlbVFAGIutamRz4W1Mcn/AJb2v/x2l/tvUf8AoVtV/Ca1/wDj1bVFAGL/AG3qH/Qrav8A9/bT/wCP0f23qH/Qrav/AN/bT/4/W1RQBi/23qH/AEK2r/8Af20/+P0f23qH/Qrav/39tP8A4/W1RQBi/wBuX/fwvq//AH8tf/j1H9u3vfwzq/8A31bf/Hq2qKAMRtfu1x/xTWsHJxx9nOP/ACLS/wBv3Hfw9q4/4DCf/albVFAGL/wkEvfQdXH/AGyjP/s9H/CQt30TVx/27qf/AGatqigDF/4SMd9H1cf9uuf60f8ACSR99K1cf9uTGto8Csq98QWdhB5swlJJCoiKCzsegAzyaznVhTspO1ylFvYi/wCElg76bq4/7h8h/pR/wk1r3sNXH/cNnP8A7LWxG/mRq+0ruAOD1FOrTckxB4otCSBYawSP+oXOP5pS/wDCSRn7ulau3/bk4/nitqigDDXXr64LLaeHNSYg433BihT9X3Y+imk+ya/qWRe3kOmQf88dPbzZGHvK6jGfRUBHZq3aKAKmnaZZ6Ta/Z7OLYhYuxZi7ux6szMSWY+pJNW6KKACiiigBj/62P8f5U+o+sgb3wPyqSgCOL7hHoTUlRr8qq/YjmpKACiiigDHu9AjNy99pcx06/c7nkiXMcx/6ax9H+vDejCok1PXLNFGo6KLjA+abTZg49yUfaw+ilzW7RQBiDxbo4GZpri1/6+7OaDH/AH2ooHjLwuyhh4j0jBGeb2Mf1rbooAxR4x8MEZHiTSMf9f0X/wAVSjxf4ZPTxFpB/wC32P8A+KrZpCAeoBoAyB4s8OHp4g0o/wDb5H/jUkXiTQp5Uii1rTpJHYKqpdISxPQAZ5NaRijPVFP4U3yIcg+UmR0O0UASUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAYfh7/j11Qf9RC5/9CNaT/8AIUg/64yf+hJWb4f/ANRqw/6iFx/OtJ/+QpD7Qv8A+hJQBYX77VGsSwW0US52x7VGeuBgVIv3m+v9KbNym0dSR/OgCTAznHPrUauoBGcnJ6DPegYZdznp1HYUICwOPlXJ/GgBC67mBUnPak3P/ArY/wBqnqArtgdh/Wn0AYawhrjUJW+YhTweicHn3NaGm7hYRBQCuDgk4PU1SV1RdWZiAADyf+BVYsWuBp8HkxROCpzvkKnqfRTTZKL+X/ur+f8A9aj5/RfzqDzL7/n2t/8Av+3/AMRR5l9/z7W//f8Ab/4ikUT/AD/7NHz+q/lUHmX3/Ptb/wDf9v8A4ijzL7/n2t/+/wC3/wARQBPh/Vfy/wDr0Yf+8v5f/Xqv5l9/z7W/4Tn/AOIo828/59Yvwm/+xoAsYf8AvL+X/wBejD/3l/L/AOvVfzrv/n0X8JR/hQJ7rnNkf+/ooAsYf+8v5f8A16MP/eH5VX+0XP8Az5P/AN/F/wAaPtNx/wA+Mv8A32n+NAFjD/3h+VGH/vD8qg+0z/8APjP/AN9J/wDFUn2qb/nwuP8AvqP/AOKoAsYf+8Pyow/94fl/9eoPtU3/AD4XH/fUf/xVH2qb/nwuP++o/wD4qgCfD/3l/L/69GH/ALy/l/8AXqD7VN/z4XH/AH1H/wDFUfapv+fC4/76j/8AiqAJ8P8A3l/L/wCvRh/7y/l/9eoPtU3/AD4XH/fUf/xVH2qb/nwuP++o/wD4qgCfD/3l/L/69Hz+q/lVf7XKMf6Bc/nH/wDFUfa372dz+S//ABVAE7l1RjgHAPArjbGxne4/tDUArXRGI4wcrAp7D39T/Suqa8O05tbgcf3B/jXPXepQWVu084kVBx93JJ7ADua8nNG7xS8/0OrD9TqIi/kp8q/dHf8A+tTsv/dX8/8A61U7fUFNvEWt7lGKAkeSxxx04FSfb4v+edz/AOA7/wCFepH4Ucz3LGW/uj86Nzf3D+dQfb4f7lx/4DSf/E0fb4f7lx/4DSf/ABNUIn3H+436Ubj/AHG/Sq/2+HONlz/4DSf/ABNL9vh/uXH/AIDSf/E0AT7j/cb9KNx/uN+lQfb4f7lx/wCA0n/xNH2+H+5cf+A0n/xNAE28/wDPN/0/xpMu3VSB7EZpYpVmTcocDOPnQqfyIFPoAjYkJwhGOe1Dudh+VueB0qSo0OX29l6e/wD+qgB2SBjYf0puGH3QR7HGKkqGW6ihfa5cHGeEYj8wKAH7pP7g/wC+qUF/7o/Oq/8AaFr3kI+qMP6Uf2jad50H14oAsZf+6v5//Woy/wDdX8//AK1Qf2jZd7uEfVwKT+0rD/n9tv8Av6v+NAFjL/3V/P8A+tR8/ov51B/aVj/z+2//AH9X/Gj+0rH/AJ/bf/v6v+NAE/z/AOzR8/8As1B/aVj/AM/tv/39X/GkOp2A63tt/wB/V/xoAsfP6r+VHz+q/lVb+1NP/wCf62/7/L/jTk1CylcJHeW7s3RVlUk/rQBZooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoormb7SrDVPGmy/tIrlF05SqSruUHzG7HjvQBY8OFntdVkKgI2o3Owg5yFbaf1U/lWow/wCJrGf+mDf+hLS21la6dYi1sraG2t0DbYoYwiLkknAHHJJP1NIf+Qov/XE/+hCgCfO3eff+goK4X1ORk/jSDmVvbn9BSyHamfQj+dACEFnJXt1B7mhXwDuBHJp6jCgd+9In8X1oAaHTefmXoO/1p3mJ/fX86bkmRgvoMn0604IOp5PqaAMMQh5dReQ5Xny17E881p6cwWwiU5yB2B9aooQserMTgAnn86v6d/yD4f8AdpslFjePRv8Avk0bx6N/3yadRSKG7x6N/wB8mjePRv8Avk06igBu8ejfkaN49G/KnUUAN3j0b8qN/s35U6igBu/2b8qN/s35U6igBu8ejflRvHo35U6igBu8ejfkaN49G/75NOooAbvHo3/fJo3j0b/vk06igBu8ejf98mjePRv++TTqKAG7x7/kaN6+v6U6igCOSVFidieApNcZaWst3crqGoAK6/6i3JyIR6n1Y/pXbN9xvpXOTypbQPNMdkaDJJFeTmd7xt5nTh+p0Ebp5SfMv3R3p29P7y/nTYG328T4K7kBwwwRx3qSvUjsjne4m5f7w/OjI9RRgelG1f7o/KqELRTdif3V/KjYn91fyoAdRTdif3R+VBjQjG2gB1IWVepFN8mP+7+tAjUdAR9CaAF+ZvYfrSlQRjpjpjtSbB6t/wB9GjYPVv8Avo0AG4r9/j37U7rTdg9W/wC+jSeUmc4IPsTQA+imeWP7z/8AfRpdv+01ADqKbtP99v0o2n++36UAOopu0/3z+Qow3979KAHUU3D/AN4flRh/7y/l/wDXoAdRTfn9V/Kj5/8AZoAdRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABWHMip46snCjfNplwC2OcJLDgf+RDW5WJqREXinQpSQDILi3HvlA//tKgDZf/AFbfSq//ADFB/wBcf/ZqsP8Acb6VX/5ih/64/wDs1AE6D55D7j+Qol5jx6kD9aB8vmH3z+gqK3dprC3kc5dkRmPvwaALFMyRkDqWqJ3YahDGD8jRSMR6kFMfzNSJy7H0OKAHAAPgelOpv/LT8KdQBzbshl1BJpMKXOxMH5zk9a29P/5B8P8Au1IbaBiSYYyTySVFZ2o6wlhPFp1lbG61GVC8Vsnyqq5xvdsYRM9+p5wCRim2JI1JJEijaSR1RFGWZjgAepNYieLNNuQTp8d7qAyQGtLSRo2wccSECM/99UQeHFuZBda7N/aVxuDiJxi2hPbZF04/vNls9x0rdpDMQa5qBH/Iq6wPrLaf/H6X+3NQ/wChW1f/AL+Wn/x+tqigDF/t297+GdXH425/lNR/b9z38O6uP+Awn+UlbVFAGL/wkEvfQdXH/bJD/J6P+EiPfRdXH/bsD/I1tUUAYv8Awkid9J1cf9ubH+VI3ieBRk6ZrHUDjT5T1PsK26KAMX/hJrb/AJ8NX/8ABbN/8TR/wk9r/wA+Or/+Cyf/AOIraooAxf8AhJ7P/ny1f/wV3H/xFH/CUWX/AD6av/4Kbn/43W1RQBi/8JRYf8+ur/8Agouv/jdH/CU6f/z7av8A+Ce7/wDjdbVFAGL/AMJTp/8Az76v/wCCe7/+NUf8JTp//Pvq/wD4J7v/AONVtUUAYv8AwlOn/wDPvq//AIJ7v/41R/wlOn/8++r/APgnu/8A41W1RQBi/wDCU6f/AM++r/8Agnu//jVJ/wAJVp2SPI1YY9dIux/7TrbooAxf+Eq0vuuoD66bcj/2nR/wlekd5LofWxnH/slbVFAGL/wlmjd7mQfW2lH/ALLR/wAJbofe/A+sbj+lbVFAGL/wl2gd9UgH1JH9KP8AhL/DvfWrIfWUCtqigDF/4TDw131/TB9bpB/WkHjHwueniPSP/A6L/wCKrbooAxf+Ew8Mf9DHpH/gdF/8VR/wmHhj/oY9I/8AA6L/AOKraooAxh4u8NHp4i0k/wDb7H/8VSjxZ4bYZHiDSj24vY/8a1yqnqAfwpvkxf8APNP++RQBl/8ACVeHf+g9pf8A4GR/40v/AAlHh7/oO6Z/4Fx/41peRF/zyT/vkUfZ4f8AnjH/AN8igDO/4Sfw/wD9BzTP/AuP/Gl/4SbQP+g5pv8A4Fx/41f+zQf88I/++BSfZLb/AJ94v++BQBRXxLoLDK63ppGccXcf+NOHiHRD01jT/wDwJT/Grf2K0/59Yf8Av2KQ2FmetpB/37H+FAFca9o56atYf+BKf40o1vST01Sy/wDAhP8AGpTptgetlbf9+l/wpDpWnHrYWv8A35X/AAoAaNY0s9NSs/8Av+v+NKNV049NQtf+/wAv+NIdH0w9dNs/+/C/4U06JpJ66XZf+A6f4UASjUrA9L22/wC/q/405b+zYgLdwEnoBIKrnQdHPXSbH/wHT/CkXQNGVw66TYBlOQRbJkH8qANGiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACsTXQBqnh2QjhNRbJ+ttOv8yK26xPExEdtp85OPL1K25/35BH/wCz0AbL/cNQD/kKN/1xH/oRqd/uGq6/8hST/riv/oTUATOcRyn6/wAqitBjT7Yf9M0/pT5TiCc+x/lTbfiygH+wn9KAEk/5CkH/AFxk/wDQkqaP+P8A3jUMn/IUg/64yf8AoSVNGMBv940AL/y0H0p1VbSYyWdvNKwy0Ad2PA6Ak1aoAzNb1KXT7WOOzjSbULp/JtYXJCs+MlmxyFUAsT6DA5Ip+k6UmmQyFpWuLudt9zcuMNK/r7AdAo4A4qhoyf2jrOoa1IxdFkazsgeiRocSEe7SK2T3CJW/QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABWL4p/5BEJ9NQsSfwuoq2qw/FzrH4clkdgqxz27kk4AxMh/pQBtP9w1Av/IUl/64p/6E1Tv938R/Oq6f8hSf/rjH/wChPQA+c4tLg/7LfypYRi1hH+ytMueLG5P+w/8AI1InEMQ9h/KgCJ/+QpD7Qyf+hJVhOh+pqu3/ACFI/aFv/Qlqwn3T9T/OgDNHHhwH0sf/AGSpdWvBpuj396eltavN/wB8qT/Sof8AmW/+3H/2Sq/jFQ3g7XVIyDYS5H/AGoAvaJY/2ZoOn2PObe3jjJJySQoBJ9STV+iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACsXxXzoDL2a5tlP0M6A/zrarI8TEf2KQT1uLcD/v8lAF5r60I4uYuo/jHrTYiranOykEGCLBHcZeppwPIbgVUsP9d/26Q/zegCa84026P/TN/wCRqYDCxj/PSoL7jSrv/rlJ/I1ZPBT6/wBDQBX/AOYoPaE/+hVPnETH0zUA/wCQo3tCP/QjUshxbSn2b+tAFFxjw+49LL/2Sq3i/wD5E/XP+vCX/wBAarcwxocw9LP/ANlNVPF//In65/14S/8AoDUAblFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFY/iTnTEX+9cRD/AMeFbFYnieQJZ2Sk482+giBxnBZsUASzJGbAEGUTMdmPNY4Yde/bBNM+3Q6avnz7yv2e3QBELMzEuAAByeasPYTmVpPtKZbjHlcDOBnr14FZOuSRWUlp58qqiTWgZ24HDOc/pVQjzSSJk7K5Pe+IbI6fPFJHeQtKrIpmtJEBY5AGSuK3m+8v1/oa5HxJrOmXmmQwW9/byyNcqdiyAnqT0/Ktf/hJtJYqVuJCoY8i3kIPXvtq5U3ZNJkqa6svr/yFJPaFP/Qmp85xZTn/AGX/AK1VsL231C7muLWTzIjEgDYI5DOCMHnqKsXZxp1yfSN/61m1bRmm5DcjGjXA/wCnU/8AoJql4v8A+RP13/sHy/8AoDVfvRjTLgf9MMfoaoeL/wDkT9d/7B83/oDUgNyiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACsXxVxo0cn/PK+s5CfQC4jJ/TNbVYnjA7fBusy94bOSYY9UUsP1FAGy38P1rlvFUfn3EEQlELvNDskY4CMFmKn8CBXUt1X6/0qm9tBd31xHcQRzII4ztkQMM5fsfrVwlyyTJkrqx59PqI1e/SUMUVXyYuxkMblj/wHAH4mu38Nf8i3px9Uz/OuYuLSy0/VZZFsbYRtHJECsago+DtI/l+NZ9pZ2MXhQPLZxNexLHJE+0ZkWXlfr82V+grpfLUjaOlrfqQ4yg031udf4Z5e+b+9NIf/ACPNWrfHGlXZ/wCmUn8jWB4FTy9HRM5IQg/9/pq37/8A5BV5/wBcpP5Guer8b9S4fChL8Ysrgf8ATMCs7xgQvg3Xic4GnzdBn+Bq0tQ/49Zh7KP1rO8Xf8ijrQ9bKQfmpFZlG5RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABWR4qTzPCGtp/esJx/5DateszxE6J4b1TeRj7HMcZ5ICHNAF6N/Mhgf+8Af0qr9qhg1G6DtmQRK4jXl2C5zhep6j86fp+/+zLHzFKP5SblPUHbyKz9EFrc32oapEXkeZ9m+QfMoXKlR6DINUlpdib6HNa5d7vtMoilyJF/dtGVY/gaty+ENSL2T2+qFFt4QkUU8aMU45UkLhgBnGQeadfapa63bKq2Z+zsZ7aSSWIblkVNylSOn8VSx6/qZhsVsbGe/iiYxXF0Y8eaVIUlfm9Ax574roipxfu6epE5xlFJ9C34atIdMvb/TkkneSFULGZQN2Wc7lx25x9RWzf8A/IJu/wDrlJ/I1j2Gpw6j4mjlt7VsvZMHkk+VogsrLtI6csD+VbF9/wAgm7/65SfyNYTTT1Li7oL/AP4939zGP/HhWd4t/wCRW1Uetvj860b/AP1J95Ih/wCPis7xZ/yLV+PVUH5sKgZuUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBDeSNDZTypwyRsw+oFfPmp6ne6nLJNeXMk00qlMs3YjBAHYYzxXtk/iGO7MltoluNVnGVZkfbbxn0eXBH1VQze1Y9v8NdMNwl3fSPLOSWljhAjhJP8KqOVUfXPvXFjKFSrbkex6OAxVKhze0W5s+FL641Lwzp93dyeZO+4M2AM4ZgOnsBTLiZfDt07Q2TzW107Sy+U4Lox64U9Qck8H8K2YbeG0hhgt4kihThUQYAGDWPqb7tUVJFYRBdu/HT6e/NdtJOMUpann1mpSco6XYXV9LfW9zYW1hd7DG6PcYCKpIP3cnLHPoK53R9Qk0rSJLCK8kRYbmVI5fsLybAHIPIOGPIPtmuojtbKXBhumil74bv+NcHI89rHcaeGnIup5DN+5fMTeY3zdOdyHtnoK66KUk1bsc83Zps63wWUk07zlYyF1J8xlwWHnTHJ/Oty/8A+QVd/wDXKT+RrnPCd0LTQYG+zSmM7gHAOMB2xwfqa25r23ubKaBZVWR0YBW469Kwq/HL1NIfCixff6sf9dYf/RgrM8XMV8N3rBS2DESBjp5i56+1ad3+8hBT5h5sRyvPSQZql4nt5brwvrENum+drOTyl9X2kqPzxWZZsUVFbXEV3aw3MLbopkWRG9VIyDUtABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAGF9u8TMw2aFYBWPHmamwKjH8QERAP8AulvrTvJ8USksb7R7YH/ln9jlnx/wPzUz/wB8itnL/wB0fnRl/wC6v5//AFqAMb7L4oyf+JxpGP8AsFSf/JFL9l8T/wDQX0j/AMFcv/yRWxl/7q/n/wDWo+f0X86AMf7L4n/6C+kf+CuX/wCSKPsvif8A6C+kf+CuX/5IrY+f1X8qDuAyWUfh/wDXoAxha+KOc6xo/t/xKpf/AJIpfsvif/oL6R/4K5f/AJIrTa5iT71zCv1IH9aj/tCz739t/wB/F/xoAofZfE//AEF9I/8ABXL/APJFH2XxP/0F9I/8Fcv/AMkVf/tCz/5/4D9JFpPt9tnAuGY/7KFv5CgCgLXxRznWNH9v+JVL/wDJFL9l8T/9BfSP/BXL/wDJFX/tsP8A09H/ALd5P/iaPtkR6JdH/tjIP5igCh9l8T/9BfSP/BXL/wDJFH2XxP8A9BfSP/BXL/8AJFX/ALST920um/IfzYUnnyZ/5B9z/wB9x/8AxdAGe8XiWFGlfVdJZEG5lGmSAkDtn7QcflU63OpTBTA1uwI5YxMFH47ufwqeYzzQyRrYspZSoLuvGR7E1VWz1FSDGtpH6gM2D9Rgj8qAHo2rzQpKlxYqHUMA0LHGf+BVWRfEM6+YmraXEpJARtPdiMHHXzhn8quwxajDEkYSzIVQoOWycfhT4IL6KIRiS2UDJzsZupz6igCgLfxJznXNJPPH/Esf/wCP0vkeI/8AoNaV/wCCyT/4/Wn5d9/z82//AH4b/wCLpPIuj968A/3IgP55oAzfI8Sf9BjS/wDwVSf/AB+jyPEv/QX0v/wUy/8Ax+tL7LN/z/3H/fMf/wATR9kc/evLlvxUfyAoAzRB4n5/4nGkn0/4lMv/AMkUeR4n/wCgtpP/AIKpf/kitL7BF3kuCf8Ar4cfyNH2CDuZm9mnc/zNAGb5Hij/AKCuk/8Agqk/+SKUW/ifH/IV0j/wWSD/ANr1o/2dZ/xW0Tf767v51NFBDbqVhijiUnJCKFB/KgDIEHigE51HR254xYSjj/v8aXy/E4/5etIb/t3lH/s5rY3r/eH50b1/vA/SgDHx4nH8ekN/wGUf1NG7xOP+WekN/wBtJR/7Ka2N49/yNG8ejflQBirJ4p53WujdeMXEvT/vineZ4n/59dI/8CZf/iK2Nx/uN+lG4/3D+lAGP5nif/n10j/wJl/+N0eb4n/59NI/8Cpf/jdbGW/uj86Mv/dX8/8A61AGMp8Usg3po8bY5w0rjP5LQYPFDYxqOjx88/6BK/8A7WFbPz+i/nR8/qv5UAY/2TxKfvazpYH+xpjg/rOaaNL11mbzfEZAJ4EFlGuP++t1bWH/ALy/l/8AXow/94flQBj/ANh35+/4n1YjuBHbKP0hz+tNXwnpsn/IQa61Q5JxfztKnXP+r+5/47W1hv736UbW/v8A6UAVTcWOmta2CBITKdkEESY4AycAdAPXpWcviNo7qWK90+W2jjDEy+Yrjj1AOasWTQ3Gt6jJ5QS7t9luXJyWTbvGB2GWP1xWHFqM93d6rBJYSwpDOFMrNw4yeRx7e/XrWqjpsZuXmdZFNHcRQzQuHjkAZWU5BBFObD/J1H8VZGjCCOCa1s1fyre5dCCcAMRuIX2G6tZXA+XYR7VnJWdi07ortp1rMpLRAHJ5XjvVcaUbbP2W4dNx6NyM1oI645OOT14705/u59CDRcLGYTqlrEVSGGUDpt4/z+VQpLZAbbyAiV+Wcrz+nNbTHapPoKiCKMhwGXODkZ7UXCxiXItYniFjcP5sr4Cq3QevrXQAYAHX3qv/AGfaiZZVhVXU5BXirNDBIwvC5a0sptFlI83TH8lcDAaA8wsPbZhf95G9K3aw9atp7O9i16yR5ZYIzFdW6DJngzngd3Q5ZfXLL/FkWb3XLO18PvrMbfabQRiRGhIO8HGMH8RUtpK7KjFyaS3Zp0V5bB8Ub0ak0lxZxGzbgRIfnUeu7ufw/KvToJluLeKdMhZEDqD1wRmsqOIp1r8j2N6+Fq0Lc63JKKKK2OcKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAK32CH+/cf+BMn/xVJ9gh/v3P/gTJ/wDFUG8sF63NsPq60n27Tv8An6tf+/i0AL/Z9v3Ejf70zn+Zo/s+y728bf7wz/Ok+3ad/wA/Vr/38Wj7fp/a6tj9HU0AH2DT/wDn0tv+/a/4UCx08HItbUH18taX7fZ9pkP05o/tC2HRnP0iY/yFAEixWyfdjhX6ACpN6Doy/nVf7fD/AHbj8LeT/wCJpft8P9y4/wDAaT/4mgCfevrRvHv+Rqv9vi7R3H/gPJ/hR9tU9ILg/wDbIj+dAFjePRv++TRvHo35VX+1uelncH8FH8zR9qm/58Lj/vqP/wCKoAsbv9lqNx/uN+lQfapv+fC4/wC+o/8A4qkN1P2sJ/xaP/4qgCxuP9w/mKMt/dH51X8+6PSzI/3pBR5t6elrCP8AenP/AMTQBYy/91fz/wDrUfP6KKg8y+/59rf/AL/t/wDEUm++/wCfe3/7/t/8RQBYw/qv5UYf+8Pyqvuvj/yztl/4Gx/oKMXx/jtl/wCAMf6igCxtP98/kKNp/vt+lV9l9/z8W/8A34b/AOLo8u//AOfm2/8AAdv/AIugCxsHq35mjYPf8zVfy709bmEfSA//ABVHkXR63hH+7GP65oAsbF/uj8qXYo/hH5VW+zT97+f8Fj/+Jpfss3/P/cf98x//ABNAFmiqcljLIuDqN2B/s7B/JaiGkR/xXl831uW/pQBo1FLdW8H+unij/wB9wP51SOg6exzJE7n1aRif51JHo9lD/qklj/3J3H8jQBJ/aNkfu3MTn0Rtx/IUfb4eyXB/7d5P8KPsMA6vcf8AgTJ/8VSfYrTuXP8AvTMf5mgBftch+5ZXLD1+Vf5sKPPumI2WWP8ArrKB/LNJ9ise8UZ+pzSfYNOP/LpbH/tkp/pQA7ffHjyLdffzmP6bRRsvuvn2y+3ksf13Ck+w6f8A8+dv/wB+R/hR9hsP+fOD/vyP8KAEKy/8tNQCf9c0Vf8A0LNYGv6i9leafFJr8thYSs5nv/3GEYD5IyWQhdxJO4j+ADOWFdELW0XpbRD6Rf8A1qlRYo/uRhfomKAOYsLfR9WuCtn4uu7+dUJZbfU1JAyOSseB6c471X1U/wBg3trHaeIL97meeBZLOZxcfuWkCvJypZAAWO7IXjnNdJf6VpWreX/aOm2t55edn2i2WTbnrjcDjoPyo0/StL0kSf2dptrZ+Zjf9mtxHuxnGdoGcZP50AZV4qhvP0zWbY3TFfM86RB5qgcLuUZHXjg9aozXGqOJ1FlDGrSqZZHm3bTk5UADk+/FdeWUjkE/8BNc7cMxW4jRdzNPk47DnrVxl3REkbdrZwWMKRQJtQuznkklmySST7mrJAYYIyKYXQ7cMp59afuX1H51Dd9WXsMUlMg8rn8qcY1IIxjPpxTVdctg557c9hSANnaflU9B3+lAAu58c5A659aUMMuGGM/l0py/KxXt1FA/1h+g/rQAitjAJyOx9afTSinPbPpTfnTtvX260AY7XF2RcSC62qjlVXGS3sK5++0S9Ph+4/s1Ge1uzm5sY9uUbcCZIQSBnuyZAbqMNnd0ljAM3sz5LZbbnsMdqgsZGe03PJLHbxsU3Rjv3J9hVOCkmnsKMnCSktzzLSvBt7rF262k8L2sbbXn5G091KEBlYd1IBFepNaiwgtnluFea32hU3YyoGCAPWszVLC1uLiKTR5/supBAv221k6p2DjlZOhwGBxyRiqaTJpGP7aTzW3Z/tWzZi4P+3GcunXtvXucVOGw1PD3cepvicXVxFlPodfBqNpcKpjnT5jjBODn0xVquVjkMkDT2Wp2t3p9z80c5w25h1UuvA6dcdRVuC/1RV8wxrdIeMRkcexJwc/hW7op6xZzKXc36Ky49etHGWSeNQdsjPEQsbejGpf7Xtm/1KzzD1ihYj88Vm6cl0Kui/RVD+1P7tjesf8Arjj+dWLW7iu0Zo9wKna6OpVlPoQaTi1qO5PRRRUgFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFADQEXoFH0pcj1FVfttv/AM8p/wDwGk/+JoF7Af8Aljcf+Az/APxNAFrI9RRuHqKq/bIf+eNx/wCA7/4UfbIv+eFx/wCA7f4UAWtw9RRuX1H51V+2Rf8APC4/78N/hQL2MjP2e4/78N/hQBa3L/eH50b1/vD86rfbI/8Anhcf9+G/wo+2x/8APG4/78N/hQBY3r/eH50b0/vL+dV/t0f/ADxuP+/Df4UC/jIz5VyP+3d/8KALG9P7y/nRvT+8v51X+3xf887n/wAB5P8ACj7fD/cuP/AaT/4mgCxvT+8v50b0/vCoPt8P9y4/8BpP/iaPt8P9y4/8BpP/AImgCfevrRvHv+RqD7fD/cuP/AaT/wCJo+3w/wBy4/8AAaT/AOJoAn3j0b/vk0bx6N/3yar/AG+H+5cf+A0n/wATR9vhI+5c/wDgNJ/8TQBY3/7LflRuP9xv0qD7fD/cuP8AwGk/+JpPt8P9y4/8BpP/AImgCxuP9w/pRlv7o/Oq/wBvg9J/+/D/AOFH2+3/AOmv/fl/8KALGX/ur+f/ANaj5/8AZFQf2hbf3n/79t/hSf2ha/8APQ/98N/hQBPiT+8v/fP/ANejbJ/z0H4LUH9oWv8Az2H5GrIIIBHQ0AM2Sf8APT/x2ja3c5/4ERUlFAEePVW/PP8AWj933UD6ipKKAGhUP3Qv4U7FIVU9VB/Ck2D3/M0AOpkplCZhRHbPR3KjH1ANLt/2m/Ojaf77fpQBB5l9/wA+1v8A9/2/+Io8y+/59rf/AL/t/wDEVPtP99v0o2n++36UAQeZff8APtb/APf9v/iKPMvv+fa3/wC/7f8AxFT7T/fP5CjDf3v0oAg8y+/59rf/AL/t/wDEUeZff8+1v/3/AG/+IqfDf3v0ow394flQBAr3u4bre3C55InJ/wDZKxXA8iYgctdDP5Guhw/95fy/+vXNtPHxDnMjXG7aOw9fpTRLOjkRTglR1FGzHQ/mM0jsQvzL3HI571ICCMg8UiiMMVZtwxz1HNOYbl4+ooH+sP0H9aCo6g7TQAHlQy9RyKAQXyOhFRo5wRwBn73ajbtlALHBB9uaAJqKbsHqw/GjDjoQfrQBipPFbWF9NKwXDNtyeSccAetVYblRo8OnxDFxcDlEyWUE/MT+GetZ2oPdRXS7VUQu8iiZvuxErjt39K2tEhis9M8y2h8ze37wqcvjsff8/wDCujlUYKTM07uxkXVsFiubtidKtRJ5EEcMRLytnG7aPXtjkjnpTy9tDpLXcDG62jccyBt4HXY2OWxn5WweOlYtxLen7N/aFxPDJYqBA6S5+0H5lZi2fkcj7obHII7moILa5t7mZtPvLu4mlRrhvMTek0QH8SkfNk4AOe56EGt3Tut/8jJTaextSeGnVzqGjztZXEn7zfCoCTZ5y6Hhj7/ex0IpP+Eg+zyMviexhszjBv41LwN7t3jP+9wP7xq1pOq3mmyQadqYZpXUBQ7AiQ/7DdMn+62D6Gt829texuyfOD8rKc5U+hB6fQ1ytzg7M392WxmRXslpcoyXKXMM2BlioDehyPbFawubqVikcMKMOu6Xdj8BXL3XhObT42fRJIgmdzWE3ywsevyHrE30yp9MnNGm6xaXb+QizWd/AMTWz8SoPXHII/2hkH1q3OEldrUXK07I6ry75fmFxE5/uGPA/PNVjEtzdlllmsrwqAyqQQ4HQ4PDVFHDZXK4SedLj+FpXIYH8eDUszXDIsV3aljn5JYnHB9eehoS7f5f8OFx5ubuxZPtflzQMwTzkG0qScDcvpnHINaNZttP9rM1jdxhiEBYMMbgfUev0p39nSwHNldyRj/nnL+8T9eR+BrOUVez0Y0+xoUVRhvJo7lba+REd/8AVyR52P7c9D7VeqGmigooopAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBi/ZfE//QX0j/wVy/8AyRR9l8T/APQX0j/wVy//ACRW1RQBiG18UY41jR8/9gqX/wCSKX7L4n/6C+kf+CuX/wCSK2qKAMX7L4n/AOgvpH/grl/+SKPsvif/AKC+kf8Agrl/+SK2qKAMX7L4n/6C+kf+CuX/AOSKPsvif/oL6R/4K5f/AJIraooAxfsvif8A6C+kf+CuX/5Io+y+J/8AoL6R/wCCuX/5IraooAxDa+KO2saP/wCCqX/5Ipfsvif/AKC+kf8Agrl/+SK2qKAMX7L4n/6C+kf+CuX/AOSKPsvif/oL6R/4K5f/AJIraooAxfsvif8A6C+kf+CuX/5Io+zeJ/8AoL6R/wCCuX/5IraooAxfs3if/oLaR/4K5f8A5Io+zeJ/+gtpH/gsl/8AkitqigDF+zeJ/wDoLaR/4LJf/j9H2bxP/wBBXSP/AAWS/wDx+tqigDF+zeJ/+grpH/gtl/8Aj9H2fxP/ANBXSP8AwWy//H62qKAMX7P4n/6Cmkf+C2X/AOP0fZ/E/wD0FNI/8F0v/wAfraooAxfs/if/AKCekf8Agul/+P0fZ/E//QT0j/wXS/8Ax+tqigDENv4oyMano+M8506X/wCP0vkeJ/8AoI6R/wCAEv8A8eraooAxfJ8T/wDP/pH/AIBS/wDx2jyvE/8Az+6R/wCAcv8A8draooAxfK8T/wDP3pH/AICy/wDxyjy/E/8Az86R/wCA8v8A8XW1RQBi7PE//PfSP+/Mv/xdG3xP/wA9tI/79S//ABVbVFAGLjxP/wA9NI/74l/xprjxVsbY2jb8HbuEuM+/NblFAGLnxOP4dIP/AAKUf0o3+Jx/yw0g/wDbaUf+y1tUUAYUtx4ojhdxZ6OxVSf+PqUf+068zu/iH4gn1BbmJ0gjQ/LBHgqR/tZ6/wCcYr2hlDoyt0YYNec3fwtDagps7/ZZscsJFy6ewxwfxx+NcWMhWkl7I9HL54eDl7b5HT+F/FNr4hsIi0sEd/gmS1D/ADAAkbgp5wcdfwzxWx9gtd27yF3ZzmstPCmmJo9tp6rIDaktb3IbE0Lk5LK2ODz06EcEEcU7S9QvI9Rk0jVQhukj82C5QbVuowcE7f4WUlQw6fMCOuB10+ZRXNucNXlc24bX0Nh/uj6j+dBG07l/EetD/d/Efzp1UQNB+fI7ig/OSP4R196ZnY5A7AkfpUijaAKAEA+dh6gU1lwVxyDxinD/AFh+g/rQ3VfrQAiP/CTz2zT6ayBvY+tIrkHa/B7H1oAwnjEmiX6lghLnD4ztPrTdCF7b2WRAuzOSucA8nlT26cg1LaQedaXjynKKzbE98dTTTqlnpGlWcuoXot4Z5fJRivG47jgntwp5rVTtHlItrcj1ax0nUn828Q2l2owJDxvHocH5l9qxbTSotKuzfaYqOCCGhnkAVhnkQyYGO/B/+vXbJFCVWSIIwIyD1yPUGoTpljLv32yMWJZg3OCec+34VUa3KrK/6CcLu5zVglxquoLqlzZNDBbyZjWRdrM5xyc9Qo4HbJJrpJNkrCYboJcYEy4P4N6j2P4Yok861jKSM0lv0EuMvH/vDuPfr69zSDdES6mNoZMEOOnTvjtWdSpzSu1oaQhpZPUcJdzrDdKI5SfkdfuSfT39j+GetVdX0Gy1kRtOrQ3kRJt7uE7ZIj6qf5g8EcEEVYJMaGG4iEsDDjAzgUizNAnBa4tu/eSP692H6/Wp22A55J5bG5TTdcjjSSU7be8Qfubg+nJ+R/8AZPX+EnkDVivHjiaCVWdVO5XVuVH0PXFaVxBa6hZNBcxxXNpMuCGAZWB9fX61z0qSeHh5d9LJc6UeIr6Vi0loeyyn+JPR+o/i/vURdhvXcu/aWGordABwY+CONwGc/Q8itiC6iuB8pww6qeorEmiEE8TSoVDOPmRsdeM5FS/Y5drNb3JMkbHakmMkema2lyyS1IV0a11bR3du0MmcHkEdVPYj3FQ6fcSSxPFPj7RA2yTHf0b8RzTLG+M5EcgKvzwfUdRTInWPXrgS/I0saCLI4cDJPPqM1FnZxfQfmaVFFFZjCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArC8WxOugzalbnbeaYpvLd8Z5QEsuO4Zdykf7Xrit2o54UuLeSGQZSRSjD2IxQB5/4o+Jn9lXTWtjZpKVlKCaR8o4A5wAQR8xxk8cN6VqaR45F/p8V7dWRtUlBITcXwM4znA69elczBoGnmz8N6pPZRO95p8JeTbjMhjXJYdCTknJrY07RGeyJjiLRADYYnxkDp8vbt0FTClVjJym7p7HpYmvgZ0IU6NNqS3ber9FfXp/wDqrbWLO/ZXt5VYD7wyMj0/lWj5h/55tXL6WIRI8Wol/Pbq7KB8vYFh1OSOtar20tnF5trefu+ytyD7Cr5WtzzW1fTY0VkUyYOVOOhp79B9R/OswX80ag31oyZGCV5xVmO6imT9zOrd9rcGlYVy5SMoYYIyKaHO4K67SenPBrC1zxno+gzJBczPLOzYaKAB2Qerc8fTr7VM5xgrydjSFOdR8sFdli0kUaddcYBLfniql3p1zf6Pp09kYjdWc/2iOOYkJJkOjKfTKO4zg4JBxUmnf2FrcPm2F2two5YK/zL/vKeR+Iraii+zoEUlkHY9RVXTV0RyuLszjItQTSorq40pXthZqZL7RLjjy0Byzw+gxkjblT0wDXZW80d5aw3Me4LKgdSRg4IzWfrfh7TfENssd7CHK/ckUkMPUZHOCMgjuCR3rWGcDPX2oAaGIOG4PY9jVZ7Z7dmktQCrHLwE/K3qV9D+h79c1bIBGCMim8p6lf1FAGdNdCCymubeJpljHzQdHVvT2/yaZFc291EJLaQB8gbWGGU+hHb+VXprYSsJon8ucDAcDII9GHcf5GK5i5hltbxmuSyMzEiSMgFAT27MvQfzxnNQ7xd0b01Gp7r3NYM9kWkhJ65kt5D94k8lT6/z7+o0IJ4bqFjH8yfdeNhyvsRWRHdNEqx37CSFjiO6UYwfRvQ1PNbTW7i5t5BnH3wMgj0YdxV8ykZypuDMy7sm8PxNs3S6ARzGq7msD/eXuYvVf4O3y8LaaWS1jSYhGjYApNEdyOD0z7H1FadnfrcEoVEc6/ejzwfcViX1s/h2KSa0iebRXbdNaopZrU55eNRyU7sg6cle4OkZWdnsZtGg+wXBkRtgkCvE/bcAcjPrj86L24mWa0knhJ8hzIyr/ENpGV9xnpVEuwsnNtte2kAdGVwy7W5Uj1HTkVqLOt5aiMDE6kOsb98HoD37iras0K90aUciyxrIjBkYBlI7g06snR7j5ZLYkgxSsmxuqjqP0NaN1N5FrJL/dXj69qxkuV2KIl1G2LYZzH8xALjAODjg9KsqwYAqQQehFYq+XFYJOXSSWLb8mfujPIx6881NaXrW8UcDW5JCbyUYHrz3xzz0pAatFNjcSRq65wwBGadQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABQTgZPSiqupS/Z9KvJs48uB3z9FJoA5/RbSOX4eeHlePKx2dq2PTKKCfw3E/hVu206PQ4HRJJlj3ZWdjvC+zD0q3o1uF8K6fbHgCyjj4/wBwCr1tJ59pE7YyyjcPQ9x+daQqOKt0JcU9RskUVzHGXCyKf4h3GKoT6ZHDPC0EzxyMxCA8jOCf5A1qsMBcdiKguv8Aj4sv+ux/9FvUXHYq/ab22J+0QeaMctH6VVjFlfymZj5DD7kY+U/U9ifatsf6w/Qf1qkkEV1FK8qKzrI4DAYPDHHSi4WOf1m8vrB/KivfJsYzuuryRQ3koMcKD1Zido//AFV5f4ntbuPxBNdzWU9ut47zxLONrFSQfpkZGR2r0rWLS20TxHpl/d+U+mXB+zztcHiF1zJEw7feBGT7VQ8VafNJ8TPDGr2UUdwi2032gyygRpCrx/PyR08wnvyBxXn4qj7a6vse/gpxoQhp8Seu19dm++n3WstW3Q8AaPaXovrXUbaSDUIdk0Ey7oZkRgeUYYbGQM9jxnNdmbvVdBcnUXbUdMx/x9xxYng95UXh1/2kAx3XGSKfms3xDguJYnZJrYwWbRyAqYwvmSSEDqCxRR7jNdZXRh48kOTsefmCvVVT+ZJ/p+nyehDBPDdQJc2k0c0Mg3I8bBlceoI/nUoYH69xWDNpdzo873uhRq0TsXuNNyFSQnq0Z6I/fH3WPXBO6tLT9RtdWtftFrITtYo6spV4nHVXU8qR6GtzhLtFNDc7W4P86dQA0qQcr+I9aint4byExTJuX0PUH2qekK556HsaAOda1utId1jCT2khwYpOFb2z/Cf/AB0+3Ap1tdLDlbXzHi6SWcgPmxfQdx/nmt44dTHIoIYYII4YVlXumKNrgSFE+5JGf3sP0P8AEvt19M9BDj2N41U9J/1/X3iPFb3yeapJxysqcPGf89fWpbS8kWdba4IEpHyOPuygdx/h1HvwazZnmtiJ5ZNpbBS+txlH/wB9f61OJIdQRbadRDct8ybT8khH8SN2P6/UU4z6MU6OnMilqNgdEMt3axyPpLkvc2sYy1sTyZIwOq55ZB/vLzkNMskaQQs0qy20qCWCdGyCDzww/wAmtGzvJBL9kvcLOOEkI4lHoff279R3Ax57WTw0L27sIDPpJYyXOnA5MZPLSQ59ySU6HquDw28ZO1jna1LmnZmEskz4mlfzY3XGSoAX88DJFXp52EkVtcsgy6t5nQMo5/PIFZOn20MugWl/Z3KtkbwUOUJyeB6Y6fhV4X6z28JkhaK5UqEVuQ+eoB96qS53oGyLOsbJLRFRFeSVwqHj+dQ3IKWaRrDKkm7G5gDuLAqeR9asXFrFFNBLFbHCvlvLHt6fXFOknS5mt4kDgiTcwZCMAAnv74rAouqAqhR0AwKWiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKM84rLv4kkvNrLl3iCJz0O7r+RzRaRpb36QhArqjqSB94ZUg/l/WgDUrO18BvDmqKQCDaSgg/7hrRrP1448O6mcE/6JLwO/yGgCXTABpFmAMDyEwB/uiiw+Tz4f7khYe4Ybs/mSPwpNKO7R7FsEZt4zg/7ooT5NRQ5/1tvyPTYf/sz+VAFp/uj6j+dZt/fCO4t9kTOIpjuYkKufLbjJ781Zv7hrZImVQVL4bPYYJ/pXLXl380Eksb3Mj3G5YYuhLI2FH45yT0AranT5tWRKVjdfX7TZ5sDCXIx128+n61lW9/NIZg1ykTPK2FEhCjLHPNakthem4jmtPsMGFUvHJblz7jcCPQ849Kr2J8/UL5fs6O0cjjbK2OCx5HBz0ol7NLRAubqVorhdRuJ7C9YrbyIYVLNvLuR95TjA74+lcc/gu+0jXYbaGLT9USKynnt4roOqZ3w7soMgseMc4PoK6ldFu/khQok8bvMm5s7xuJHfj72B/u9BVHw7JPa66Gurm4u5Y7O6bEhy3+si4Xk5yVP40VKMJR509tDehjKtH3I7PX7vxOo0KAS2FnqFx5Et28G1ZYoPK2xsQwQDJwBwOvateqWkfa/7Jtjftm6ZN0nGME84/DOPwq7WLiouyJlUlUfNIKyNR0d5br+0tNmW11NVClyMxzqOiSqOo9D1XtwSDr0UEmZpmrx6g8lpcQta6hCAZrWQ5IHZlP8AEh7MPocEEDRyV+9yPX/GqWqaTBqiRl2eG5hJa3uoTiSFvVT6HuDkHoQap2Wr3NrcxabrqxxXbnbBcxgiC6PouSdj/wCwT9CwBwAbdFNwV+7yPT/ClBBGRQAEAjBpMlfvcj1/xp1FAFSW2ZGeS2Cnf/rIW+7J6/Q+/fv6jGudJE0LvpjFCrZa1kONjjkFf7rfofpXRYKdOR6Uo2k7gBk8ZpOKZcKkoPQxfPttVgKSK0d2gAkhcbW9en6iqlzLOttPBIDOGjyjjq2D0b3x3749eu5eafb3oHmqQ6/dkU4ZfoaxbppdP+XUo/Otui3ka/Mn++B/MU4z5HeRXIqnwb9v8hk1hIofUdBMciz/ADXVkW2pcccsh/gl9zw3RuzChHqkN7bgwsxZW2yQum2SIgYIZeoYA59xgjjmrwc2kyXEUqtBLwzKcq47H6g96hvdIt7/AF22u4Lg2l7HEwiu4lG5h/dYHhl5Pyn1yMHkbRtGSa1Ri07NM6yNleNWRgykZDA9adXK6Frj2YTTdbiW0uWkIimX/UTFjkBSfuseyt17FsGuqrOSs2gTugoooqRhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBRuo3bUrZoygYI+CwJHb/GkaKVdRtpZZEYncnypt7E+pqW6by7i3lKsVBYHapPUe30pkkxnmt9kUw2yZJaMqMYI7/WgC7VLVxu0W/HrbyD/x01dqnqrBNHvmPQW8h/8AHTQA3Rju0PTz620Z/wDHRTrj5TZy9lkCsfZgV/mVqPQQ6+HdMEg2uLSIMM5wdgzUl8P+JdI//PPEn/fJDf0oAg1qdooI44yokkY7Se2ATWHbBrDV9MU4EU0kjS8ZwwjOwg+hy/511M0EUjJI8as8ZyhI+7WVewOFgtJLd3iMzhGjYZwUfH0Iz+lbwmuTlM5R1uJrMmoLcWV3ZX0MFlG+67DruLpnoOD/ALXp1qkl99i19m8jzYnEoeRcFkPmcAc9Dz+Qqpem6itPJd2ELSBOQM+uD+RrU0e7FtbMro5LO+JCOvzHv+P61EW2+XR2NZRSipd2ZWqtFq0Msjs4dG8uDYxRo2BChgRzk7mNZUcUNv4utLpV3zfYJWIZy2PnA4z04B/OtDxKDb39veWaMQ43XMaDG/Z0P69aw7Oa+m8QtcyLCGltHIXYVOfNUHv7jjHetKUXrrpp+JVW3JFrrf8AA9Kkuzbva7lBglwnmDqGONv4Grlcnf6sljoF5HqZW3NnEkySlxtI3fIcn3GMVE3ivVr6OKbSNHLWhI3Xd2TDGfdQRvYe4XB/vVnOHLoZKVzsaKw10bUbzEmo69cFWH+psEFvHj6/NJn33j6UDwfoBcvPpsd1IQAXvGa4YgZ6mQsT1NZlG5UF5Z22oWklrdwpNBIMOjjINZf/AAh3hgElfDulKf7yWcan8wKRfCWkRFjbLd2hY5P2W9miGcY+6rAHp3FAEBub3wy4S8aW90bnF4x3S2o7CXu6f7fUY+bPLVvoyTRrNC6srgMrqchgeh9xWOukaxZg/YdfkmXJPl6jAswHOcBk2N+JLVkWMWv6DqyLHoqPpd1JieKzug6W7E/61FcIVBP3kAI/iHOdwB0d1e3S6hbWdrbBmf55pZMhI4wRnHqx7D8TSR2F5Fem4/tS4ljJY/Z5FTZg5wAQuRjj8qZaSzy6vdkuZLKSON7eRSCqsMhl+vANNg0y6g8Q3GoSalNJbyxhEtT9xDxz1x2PbvWui08iNyxpWo/2jauzxGGeKQxTRE52OOoz3HQg+hq4V5yvB/nWXaT3txc6hLHGiQx3HlxI6bTKFUBjn69D7VowXCXCkrkMpw6MMMp9CKiasyo7EgbPHQ+hoZQykMMg0FQ3X86TJX73I9RUjMG70J4C8umMse/l7d/9U/4fwn3H6Vlee9vcvHLFJEYxwrYypPf3H9K7QEMOMEVVu7GC7j2TJuA+6w+8n0/woh7jujSU+dWn9/X/AIJQtTb6ilzBcwwzJMBG0TruSRAOmD9TwagWy1PQkzpTyajYr1sLiXM0Y9IpWPPsrn6MoGKztWuZPDFt53yzB+LfB6NtxuI64A6/hz2p1v4qSxKpqFy1xb9Bd/Z2ikQ+joQM/Vfy71u6UprmiYOai7M6DTdastULxwuyXMYBltZlKSx/7yHnHoeh7E1oVl3Vjpuu28M0qpKF+aC6gcq6Z7o6nK/gfrVQya7oxVWjbWrLODImyO6jGOpXhJPqNp9mrAs36KoadrWn6ozpa3AM8YzJBIpjlj/3kYBl/EVfoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACsfxZI0Xg/WnjI8z7DMEz3YoQo/PFbFYvin59Khtxybi9tYiPVTMhYf8AfIagDXhjEMMcS9EUKPwFRXEZmsZ4h1dHUfjkVYpqfd/E/wA6AI45RPaRyqeHQMMe/NRXjKtxY7upnIH18t6LH/kEWv8A1wT+QqHVTtl04/8AT2o/NWH9aAMbxRH5em3LDPyTRsPxYD+tXtJkLaerYyI5XY/QswNM8TxCXTrqPpviXH13jFOsP3VqoQbd6gNx0JPJqVpUXmdD1w68m/0KupW5a/kjUlhJbJsU9gWIYD/x2sOXS7++u7DUdPvLeC4a2kUCa3MokJZGxw64IMfvnNdPq6eVdadIoxuzCT9cMP8A0GstrZ7ezSSEMGimbK+6vnj04IrWEtbehM1emmZ9vZWiaq97rjSalMlthnlgysDAnGyMZCDGeeT6sa1tCna90JdPjYFgD8/91TyB9RV21so7+wNwoUTuSdx6jtsPtjismyiV5VM26KaGVrcyIcMuOnPoARx7V0TUWnbocibW50mmSu9t5RI3RHYcjn/P+FXSuOWc4+uK56C8+zavPa3rhGKZkkDbVI7Nnt/TmiTW/C6uUW4hv5lPzLbRteyA+4QMwrmkrM0TN/dFkDzBk8Y307Z6Mw/HNc+2uaEF+bTr8L33aJcgD6/uqnsr3w/qMvladfWpmHWK2n2OD7oCD+BFSM2cOOhB+tG/H3gV+vSq2y8h5SVbhf7so2t+DDj8MfjT47yKRxE4aKU/8s5Bgn6dj+BNAFTU9DtdSjOd0Um4PvjJHzDoTgjn34PvVAaecwW+pX+oBUG0YnxHMckjLgBs84wSOg69a6Dbj7px7dqNwPysMZ7HoapTktExOKYcp6lf1FQzW4lYTRP5cyjCyAZyPQjuP8jFWKaVIOV69x61IyGC68yQwyr5dwBkpnIYeqnuP5d8VYqGWKK5TZIpyDkEHDKfUHtUP2iS0+W7bdF2uMYA/wB/0+vT6UAWioJyOD6ijLL1GR6inUUAY+p6P9tuRe2swS7SJotso3xSIeqsvbPqMH61gWE9xH/xTNxA1lNK5zK0md0GOiN3b+EY7c9c12xUHqOfWq17YQX9uYLqJZozzhuoPqD2NbQq2VpESh1Rl3umx6NBLqGmTR2IjXdLCw/cSADuo6H3Xn61q2UstxYwTvAYJJEDNCxzsJHSshdIumuYILu/M+mwv5qxyr+8Zh91Wb+JQefXIGc10FTNppa3YRWvYoX+lafqwQXtsryR8xyZKyRn1R1wyn3BFURZa9pzH7Ffw6jbgcQagCkg+kyA8f7yE+rVuEAjBGaQhgODkfqKzLMX/hJYbXjV7O60wjrLOm+H6+amVUf7xU+1bEFxDdQJPbzRzROMrJGwZWHsR1quHu4TggXK/gkn/wASf0rNOhaBd3LyRWos7xzuke1Z7WZj6sUKlvxyKAN6isT+ytYtf+PHXnkXtHqFusygegKbG/ElqRb3xHAP9J0azuACebO9O5h/uyIoH/fRoA3KKxP+EjEX/H7o+r2v/br5/wD6JL0ieMfDxQNJqtvbgjI+1EwH8nAoA3KKz7fXtHu8fZ9WsZsjI8u5Rs/kavI6SLuRlYeoOaAHUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVia6N+q+HI8nB1FmYeoFtOR/49tNbdYesLnxF4dbJwLiYYzwSYH/AMDQBuU1Oh+p/nTqanQ/U0AVbA50m2x2iUfkMVX1rASzc9Eulc/RQxP6CrNl/wAgyP2X+tM1KEXAt4ScCR2TP1icUAUPEWTb4HVmRP8Ax4H+lWLKI/2cSTyYsj8Car6lIbvRkuVwMtG5/EDI/XFXrHmyj4/5Y1K+JPsbN/urFfXf+QTFOMfuZYpB+YH9apybojdqzAneJePRh/iDWhfLHNoTRvgh4wMVgSXLzvA7ER7oxEUA++uCc59mU/nVKPvPyHF3ppev9fmP07U10m3IeOUySMT5SqSOFUDGO5qjHqwuba703TkW+1R5PPkYHbFAzc5du3GMKAWPoByGa7dSXeqWukaWwS+kg3POfu26khQx9WznaO/PYGtDw9aDTrqCwCRAW7vGzLnMh2gl2J6ksc5713u0o8y33fyOLZ2KWh+DRqEj3fiW8fU7lD5b20i7YUYc/c6N1yCcnnrXdxxpFGscaKiKMBVGAB9Kz9KzE93bOMyxyl3kH8e7kH644x7VpVx1PiNVsFUdU0uw1O3IvrOC48vLIZEBKH1U9VPuMGr1BAIwRkVAz58l1zV2uIZzqF07Q8RlpmZkHsScn8ck+texeEtQk1/wtb3N/wCXPI5ZXJUYOGIGR61n3nw40a61BbiMy28WcyQRn5W+mfu/5xitB/Dv9lAXPhxY7adFw9qxPk3QHZ+pVuwcc9M7gMVwYWhWp1G5vQ9TG4qhVpRjTVn6beRrC3nt+baUuv8AzymYkfg3Ufjn8Kcl3G7iKVWhlPAST+L6HofwqvpWsQ6mHiMb217Dj7RaTcSRE/oynnDDIOOD1q/JGk0ZjkRXQ9VYZBrvPLDaV+6fwNG8dG4PvVYW89sP9GffGP8AljKx4+jdR+OfwqSK6jmfymDRy4yYpBhvw7Ee4yKAJiufY+tJn+Fx1/I0bcfdOPbtQTxh149uRQBV8iW05tBui7wE4A/3D2+nT6VPBcR3CkoTlThlYYZT6EdqcCQMg7l/UVHNbRzsJVJSUDCypwwHp7j2PFAE9FVBdPbnbeBVXtOv3D9f7v48e/ardACEAjBGRTNjJ9w8f3TUlFADVcE4OVb0NOpGUMMMMikwy/dOR6GgBSARgjNRTW0c6hZESRQchZF3YPtUm8ZweD706gCn9meL/UzzR/7LHzF/Xn8iKUTXaH5oI5lH8UL4Y/8AAW4H/fRq3SFVPUA0AVvt8K/64SQ+plQhR/wL7v61PHLHMm+KRXU/xKcil2Y6Mw/HNQSWFvK5d4IXc/xtGC350AR3GlWF2++506zmbGN0kSsf1FUn8JeHXO5/DmkMfU2kZP8A6DV77BGOhmH0uZAPyzS/ZZV+7c3K/Rlb/wBCBoAzf+EQ8Ph966JaRnGP3S7OPwxS/wDCK6MPu2Mi/wC5cOv8mrQ+zz/8/t1/3zF/8TS+TcD/AJfJvxRD/IUAZv8AwiulB9wTUFOMfLqU6/ykpf8AhGNP/wCeusD6avdD/wBq1oCK6Gf9Lb8YRRsuv+fofjB/9egDP/4RjT/+e+s/+De7/wDjtH/CNWI6Xesj/uKXJ/m9aO27/wCflPxtz/jRi9/5+Ifxtm/+KoAzf+Ebtg5YalrQyAMfb5iP1NL/AMI9F21TWR/2+Of51o4vf+fiD/wGb/4ujF7/AM/EH/gM3/xdAGd/wj69tY1kf9vJP8xR/YJ7a3rA/wC2w/qtaOL3/n4g/wDAZv8A4ujF7/z8Qf8AgM3/AMXQBmDQZA5YeIdZ5AGPMTA/8c96d/Yc3/Qw6x/31F/8brQxe97i3/8AAZv/AIul/wBN/wCe9v8A9+G/+KoAzv7En/6GPV/zh/8AjdH9iXH/AEMmr/nB/wDGq0c3v/PW3/79t/jRvvP71v8A98tQBnf2Lc/9DNq/5W//AMao/sW6/wCho1f/AL5tv/jNaPmXn/Tt+bUebef3bb/vtv8ACgDO/sa8/wChp1b/AL4tf/jNH9j3v/Q16t/37tP/AIxWj515/wA87X/v83/xNHn3n/PG1/8AAg//ABFABp9pNaRMs2pXN8WOQ9wsQK+w8tFGPqKt0gzgZAB74paACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoorGt3nuyFW5kjfvuYc/Rcf1oA2axda41nw4fW/kX/AMlpz/SrdtbvJES11PkOy8MOzEelZeoFv7U0BWdn2atIoLHnH2Sf/GgDo6av8X1p1NXq31/oKAKtl/yDl/4EP1NJeFjeWKg4BlJzj/YenWf/AB4fRnH/AI8aS94urBv+m5H5xvQCKrxAaRfwHkwtIc+/31/LI/Kp7Eg2cRHQxUy9/dm+XtLalgPUqCCfyK0tgMWUB9YKXUv7JDfqvmSogPCbiO2awbl4oLhfPdVhtZZtxP8ACpO7P5NXQ3IzLN725/rXLeLjGYZbOQAJe3FpHIe/lyOscmP+Ak01rJ+hcXaAmj2xOkjUrtRHf34+0yqTkp8wCxj/AHVwPruPetrQEWS/1VZDuk3p8xPP3f8AEVBfyrGls0YPnBDCoCZJLckfgOat6dbLbaKbpGY3Cu7s56k5wQfbArvelO3f+v0OJayuW9IfZPe20h/fCdpAT1dTjB/p+FatZN2v2e+sWHabap/2WBBH54Na1clTe/c2iFFFFZjCiiigDO1PR4NT8uXe9veQ5MF3CQJIievsVPGVOQe4qpaa3Na3kem65GsF05Cw3SAi3uT2Ck/df/YJz6FhzW5UN1a297ayW11DHPBINrxyKGVh7g0ATVHNBFcJslQOAcjPY+oPY+9Yfl6j4e5h8/U9KH/LIkvc24/2SeZV9j847FuANbT9Rs9Vso7yxuEnt5B8rofzBHUEdweR3oATbc233SbmL+6xAkX6Ho344PuamhuIrgExtkrwykYZfqDyKlqGaCKSRJGX94nRlOGA+o5x7UASFATnofUU0hlOR+Y/wp4IIyDmloAYrq/ynr6Gq/2R7bmzYKo/5YP9z8P7v4ce1WWRX6jNNw6dDvHoetAEcV2jyCKRWim/55v1P0PQ/h+NWKikjhuk2SorgHO1hyD6+31qHyrm3/1MnnR/885T8w+jf45+ooAmljguV2SKr4OQD1B9R6H3qL7PcQ/6i4LL/wA85vm/Juv4nNCXVvNIIpAY5v8AnnINrfh6/hmptjr9x8+zUAQfbGjO25tpY/8AaUeYh/Ec/mBUsUkM67oJVZemUYEU7zGX76H6iopILW4YO6Lv6Bx8rD6Ec0AT/OPQ/pRv9VYfhmq/2WeP/U3kmOyyqHA/kx/E0b72P70MUoHeN9pP/ATx/wCPUAWN6f3h+dOqr9tAH722uY/by9//AKBmk+3WQ+/IkR/6ajyz/wCPYoAt0VWS7snHyXUTD/ZlB/rUy7G5R8/Rs0APopu0/wB9v0o2n++36UAOopu1v75/IUYb+9+lADqKbhv7w/KjD/3l/L/69ADqKbh/7y/l/wDXow/95fy/+vQA6im4f+8v5f8A16MP/eX8v/r0AOopuH/vL+X/ANejD+q/l/8AXoAdRTcP6r+VHz+q/lQA6im/P6r+VHz+q0AOopvz/wCzR8/+zQA6iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKo/wBlw+WIzLMyg5ALdKvUUAVE09Y12rPcYyT/AKz1rL1iBbe70IqWP/Ez3Esckkwyj+tb9YHiKUi80mMAf8faEH+6x+UH9T+dAG/TV+831/oKro06XaQySrIrIW+5gjBHv71YX7zfX+goAq2XNk3H/LSUf+PtSX4y9pjtMT/5Dels/wDjzf8A67S/+jGp12Mz2Q/6bH/0W9AFfVztthMOBtdGP+yyn/2YLS2vGnWp/wCmVJqq7/D90T1SEuPqoyP1FOth/wASy2/64/0pF9LDLjH2hwenk4P5Gub8RoX1XQHBAL3kCuCM8Bgf5iugvvvzY6kBR+ORWDre1/EGmIBgRXNvj3O7k/8Aj1Ulq2CehoTXEMF7pjFgUjin59TjGR+v51radADpSxv0cHI+tc6DJf6okWNzhVIOMKiZJb/D8q6eDEJxnCmPeR6HvXVWVopdf6/zOeOruZlzKZW02AndOtzg46lUPLfpW7WDpi41ZywG941lz3AO7j9a3qyraNIuIUUUViUFFFFABRRRQAVkX2hLJdNf6dObDUWxumjXKTY6CVOA49+GHZhWvRQBhweIPs1zFY65Cthdytshk3boLg+iP2b/AGGwfTcOa1Z4IpiDKnK/dkUkMv0I5FPuLeC7t5Le5hjmhkG145FDKw9CDwaxP7K1PSH3aNdCezA/5B145IX/AK5y8sv+6wYdhtFAGl/pMHP/AB8x/wB5cCQfUdG/T6GpYLuOcEo27b94YIK/VTyKo2OuWl3dCzkWWx1Agn7JdKFdsdSvJVx7oSPpV6a3imIMsfzr92RCQw+hHIoAsAgjIORRVIrdQfMp+1J7YWT/AOJb9PxqSK8jkfy84k/55sNrfkeo9xxQBYZFbqPxpoDr33D3604MD0PPpS0ARyLFMhjmRWU9VcZBqH7JJF/x7XDIP7knzr+pyPwOParWM9absx90kfSgCv8AapYji4tXA/vxfvF/IfN+n406O4tbhiscqM/dQcMPqOoqb5x6H9KjljhnXbPCrgdnTcKAHeVj7rEUfvB7/wCfwqAWcQP7ieeM/wCzKWA/BsgflS+Tdp9y7Vh/02iBP/jpWgCbew6r/OjzR3H6ioQ1+ODDbP7+ay/ptP8AOj7Rcr9+yZv+uUikfqRQBIxgf7yq31XNRNaWD/etIG+sIP8ASl+1v/HZXC/gh/kxpPtkH8UM4P8A17uf5CgA+w6f/wA+dv8A9+R/hR9h0/8A59Lb/v0P8KPtlsf+WU/42sg/9lqIarprEgTx5BwQVIx+lFgJfsNh2ghH0AFIbGyP8IH0kI/rSf2hp+0t58OB3NU5fEejxzRwiYSSSZ2hF9Pemot7CbSL32O0/vOPpM3+NH2O2/56TD6XL/8AxVZlr4hglkf7XaiziVC/mvcRsOOxAbIP4VpDUNOZQy3tsQRkETD/ABocWtwTuOFlAeklwfpcyf8AxVY2tKWuLfR9OubmO/usu0q3Dk28IPzSYJIzztXII3EHBANbA1CwXpeW/wD3+H+NcPYeIPtaXLWxKa9qUmyaWRCsdhArFV+ZwA20ZIAzudicbScIZr6JaXDa7qK/2rf3umQKsPmXM+G+0AneEKBQVAIBzn5hgYwa6L7FB/z0uP8AwJk/+KqtYvpOnWENlbXVusEShVBmBJ9yc8knknuTmp/tunf8/dv/AN/h/jQA77DB/wA9Lj/wJk/+Ko+wwZ/1lx/4Eyf/ABVMF7px6Xluf+2w/wAad9psD/y8wH/tqP8AGgBfsMP/AD0uP/AmT/4qj7DH2luP+/7/AONHnWR/5bwn/toP8aUSWh6Sxf8Aff8A9egBPsS9p7n/AL+mj7F6XNz/AN/KeDbHpIn/AH3ShYD0ZfzoAj+xt2u7n/vof4UfZJO17c/+Of8AxNSiOM9CKd5S/wCcUAPooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArmfEcg+3WYP8ABc223/eMoA/DLDNdNXOeIYCYxLICii9tnjkGCCwkQKuOvL4H40AatvK82pS71UGKMKdrZGSc+g9KuL95vr/QVT0+Mo0x8uRQSoG8YJ45P5k1cX7z/X+goArWf/HpJ/12l/8ARjUt1/x82P8A13P/AKLeks/+PST/AK7S/wDoxqddf8fFl/12P/ot6AK+qbk0a+UqNvkyDOexBoszv0y1HfysH/vmjXzjQb3HUxkD8eKfbIEsLbHeME/980iuhVuOdQiJ+7yce+T/APXrm9bLtr9kEbYftcClsZx9010N7Kkc0BPLEDCjqc7q5zxI2y5D4KSte2+1c5xnPP6CtacW3b0CTtG/r+Zq6ZEU1hFU4DWwj56/3s/rWveSCeVLW3yWOUdh0Ve/Pr7VnWwWLWnYk7YMj8BGAatz3D6fptrIiB53O1EPd3PGfzronrJPqYLRWHwhR4kmC/d+yqPoQx/x/StWqWn2L2vmSzS+bcS43sBgDHYD05NXa5ptN6GiCiiioGFFFFABRRRQAUUUUAFFFU5E+03hj3uqRLklGIO4/wCA/nQA++0+z1O2Nve20c8RIO2Rc4I6EehHYjkVlLp2s6SP+Jdff2hbgki11FzvUeizAE4H+2GJ/vCtONpo7sQGXzU2FiWXDLzgcjr3/KrdAGNb+ILN7lLW9SbTL1zhYbsBfMPojglHPspJ9QK1JYkmTZNEkqdcEZ/Si5tbe9tpLa6gingkG14pUDKw9CDwaxx4eksAP7E1KeyUdLaXNxb/AE2Mdyj2RlHtQBofZ5UP+j3BKj/lnOC/5H7w/En6Uv2mWHieCRB/eT96v6fN+YrNfWNQsABq+jyvGCB9p04G4X6lMCQfgrAetX9P1bT9UDf2ffwzlPvorgsh9GXqp9jQBaiuEmTfGyyJ/ejbcKkDqTjPPpVeW0glk8ySACTGPNQ4bH+8MGmeRMvEN3uH9ydN2PxGD+eaALlFU/NuYyRJZt/vQSBh+TY/kaPt8A4ebyv+u6GPP0zjNAFsgHqAfrSbF7ZH0NIGJAIAYHoVOaXf6qw/DNABtPZmow/94flRvXucfXilDKejA/jQAnz/AOyf0oy/91fz/wDrU6igBuW/u/ka5bQbPRLvRLV7izsJpnUsxdI2bJJPOea6uqD6JpMpJk0uycn+9bqf6VpCVk0TKN3c4q40jQmW/aMrBem5kWGKFd5ZRgAeWMnHXkAfWrfgeKZNW1ZpbMROqxow6FepGATkAjnGe1b9z4W0eSFvK0y1STqpWMLz+FRxWn2BCdDtraKdmDXFvOWBkAGAA3OMfQiuh1VODSb+ZkoOLvYtWOpTXl3eW9xZNCkUnlxs2f3o5/vAA9OxPWjRBawWclrZmV4beeSP5sfIc5Kj2GcfhVe+udWkRdumxwogWR5ZZwdp4JChRyeoycCtSys4bC1W3gTbGCWwSSckkk5PXkmsJJKPqaLVk24/3G/Sjcf7jfpTqKyLG7j/AHWo3H+61OooAbuz/AaQhT1j/Sn0UARFIz1hH/fIpDDAetuv/fAqaigCube2PW2T/v2KQ2loetpF/wB+hVmigCqbKyPWyh/78j/CkFjYggiyhBHQ+SP8Kt0UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFYnigBtNtIyM7tSsv0uI2/9lrbrF8RfN/ZMf9/Uof0y3/stAG1TV+831/pTqav3m+v9KAKtn/x5yf8AXaX/ANGNT7r/AI+LL/rsf/Rb02z/AOPST/rtL/6ManXX/HxZf9dj/wCi3oAq6+f+JQ4/vSRjHr865/TNWFXGnQj0Rf5Yqn4g5tIFH/PYEj2AP9cVPeIc2sAdlXnO04zgChK7KvZFKcb7iSQfwhFz+X+Nc5q4DXVpPIcr/asKkeo3MRXRXj/ZreVIU3OdoJY9PmJyfyrldbV/Jsp9pI/tONvlPXCk4we1dEI3lfyREn7lvM6C1Bmae4kYATTFBz1BYZ49ML+tXrkm61eyQ52xN5xX+6MEL+J5P4Vn6NCI7C2t7e1ja7dGkeWTgKN5GfU/StyCzW2kQF2kmdi8sjdWIGPwHPAq6kkpO3mZxTtqXqKKK5DUKKKKACiiigAooooAKKKKAEZgiMzHCqMk1mWjTCCa581Uy5ZlkXjoO/Xpj1q/cwm4t3iDbdwxnGazpbe7DSB0Dh2+Qx9FY4G4jrx+lAFrT2aZHunXa0p4Geijgf1P41cpqIscaoowqgAU6gAooooAKo6houm6oVa9soZpE+5KVxIn+64+ZfwIq9RQBhHRdUs2U6Xrsyxj/l31CP7Un4NlZPzc0p1HWrUYvtDW5T/npp9wr/iUk2EfQFq3KKAMKPxXofnCCa/+wznGIr5Gt2P0EgGfwzWyrb0DI6SIwyCOhH1pzokiFHVWVhgqwyDWQ/hTRN5eCxFnIxyXsZGtmJ9zGVz+NAF42FrksLREYnJeMBT+YwaT7Kq/6u5uYvq5b/0PNUBomowEm08R3wX+GO5jimQfjtDn8WpdvieDnzNIvvYpJa/rmT+VAF9Y7ocJfI//AF0iB/8AQSKUpejrJbSe3lsv/sxrMGqa2hYXPhpnwcA2l5FIG46jzNn60v8Abjp/x8eHtWg9/Kjl/wDRbtQBoD7ZgZtLXPtMf/iKCbwD/j1t/oLhv/iKzh4m03kG21hSOudJu+Px8vFL/wAJTo4+/Ldx/wDXS0nT+aigDR33Xe0H4T//AFqPNuO9nJ+Ew/xrMXxd4ebONUT5Tg53jB/Knf8ACV+H/wDoKw/99NQBo+dMOtjcfhIn/wAVUchMuN+m3LEdCXjyP/H6pf8ACV+Hv+gvb/8Afw0f8JZ4d/6DFt/39ovYC1tZuJLO9kX+68kZH/oVT+fL/wA+N1/32n/xdZ3/AAlnhz/oNWn4z/8A16P+Es8N/wDQcsv/AAIH+NNtsDR8+X/nxuv++0/+Lo8+X/nxuv8AvtP/AIus7/hLfDf/AEHrD/wJX/Gj/hLfDX/Qwad/4Fp/jSA0fPl/58br/vuP/wCLo8+X/nxuv++4/wD4us0eL/DDDI8R6Zjp/wAfkf8AjS/8Jd4Y/wChl0r/AMDov8aANHz5f+fG6/77j/8Ai6T7RNn/AI8br/vuP/4us/8A4S7wz/0Mulf+B0X+NH/CXeGf+hm0r/wOi/xoA0PPl/58rr/vqP8A+KpftEv/AD53X5p/8VWd/wAJd4Z/6GbSf/A2L/Gl/wCEu8NH/mZdK/8AA2L/ABoA0PtMn/Ppdf8Ajv8A8VR9pf8A59rr8l/xqgPFfhw9PEel/wDgZF/jTh4o8PHp4h0z/wADIv8AGgC79qb/AJ97r/vkf40faj/zwuv++KpjxLoB6a/p3/gXH/jTh4i0M9Nd0/8A8Co/8aANQHIBwRnsaWmo6yIrowZGAKspyCPUU6gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACsTXmX+1PDkRIy+onA9cW8zf0rbrA0RG1PULvWrnG9Jp7K1jByIY45SjH/AHnZMn2CjsSQDfpq/eb6/wBKdTV+831/pQBVs8/Y3z/z2l/9GNT7r/j4sv8Arsf/AEW9Ms/+PJv+ukn/AKG1Ouv+Piy/67H/ANFvQBS1rnH+zESfbLpj+RqxcFmvoiy4CRu3X6Cq+p/ML49hFEv47yT/ADFTrGGustnIg3HnuT/9aqit2D2RRuVMsFzNnAyhAHfnH9a5zUSJRo9r0zqSFj7cg/oDXQ6uoRpUT5QyjIHQnBP9K4/Ube8udQsLeECBXvo0Mu7LYZWP4cDjHrXVBJq/kZt9DsvD2bhUuB9yKEQg/wB5idzH+Q/OtiP55nk7D5B/WoLe0ito47KEFYIU6A8n6n86uKoVQqgADsK56kk22ikhaKKKzKCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACq39oWn/PdPxNTyHETn0BqG0IXT4cEcRL/ACoAnVldQykMpGQR3pay7SNpRBGZZEUWyNhGxyc1Zt1aO7mi8x3UIhG9s4zn/CgC3RRRQAUUUUAFFFFABRRRQAUUUUAFGAetFFADSiHqq/lSGGI9Yk/75FPooAiNtAesEf8A3wKQ2dqettD/AN8CpqKAEACgAAADgAUtFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFYfhPd/YTb8b/tt5ux6/aZM/rW5WF4bljg0e4MrqgGpXwyT63UpH6GgDdqjqn/ACCNQx18h/8A0CplvrZ2VVmBLHAxnrUWqDOkagCcfuH5/wCAVUfiQnsc5baBpD+EjcHTrYzfZ3beYxnPODmtu0OdP0Q+oT/0S1cZaTW03g7y0u73+0SDAIvtUgGTk7tucY2fN6cV1Ghs76Po29i2G2gn0ETAV0VotRd31MqbV9F0LN5zZak/YzLg/QIP5g1K10ovpQkbsxjVQNuPX1qKfnQZ27NI7D6GQkfpimLFNNrVyGuCojRB8igZJ9c5rKmk07mkr6WM/UZZJNskmFDyHv8AewduB7D+hrHTzWvNOlKdNURMZ5JWIj/H8617uNI7q/QEsII4o1LckH7xqhEvmx6HIScyaw0xIOM5V/8ACt2/cfy/HUm2x20SFQxbG9jk4qSiiuNu5oFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAEVycWsx/2G/lWT5cIsDCYIvP+7u2DO3Gd35frWy6LIjIwyrAgj2qodMgJJDTBiu3IkOcelAFVAy3VsgkeNWt0XK46846g+lT2LM17dEuzrhQrNjJALDsPXNPm0/zAAkzIAip0z0OQc+tPtbQ2zsTLvBVVA2gYAz/jQBaooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACua0cNHHqETNkxaxJ2xgOwf/wBnrpa5eDab/wATWpysn26CcAj+BoYVDD1BZJB9VPpQBvXzAQocjKyof/HhRfIJdPvIznDRsvHutZ9ysLW6COCJJF+aXaoyNpxj86tX8rlJ4Yzt/dl3b0GOg9zVQV5IT2OIsdEzcrIL+63RQmINFCjbRyORj0JGevNdTpYjg0fSAkm+JHbDkYJASTms+1lFlDsVSXkhMSADksWP/wBc1o3Fs1loltAeGXzAAOxMcnH610VpuUdSIxSeg+7zF4bt0PB8tFP/AHz/APWqW2Yf2rqDsQFBQEnsADS67xYIB034x/wE1jaJa2k9pPJPH5sjEcNk7mx/iainG8JNlS0sRgRy2V9d/eWS7ILrzkBT0qX7KtrY+GE24Zr5WP4xSmn3bxOlvpqzRRvPKzbAwDKu4KDj6bvyq7rahLvw8i9BqAA/CCWnWnpbv+gorY3KKKK5ywooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACsbWtGlvJEvrCUQ6hEhQbyfLmQkHy3x2yMhhyp55BKnZooAwtJez1aK4LR3MN1E/k3dvM5DRuADg44YYIIYZBB4q9LGZHv1AyxiCj8jVC6QW/jnTZo0bN1ZTxTbWwDsaNkLDPONzgf75q5c3cdo1y0u8F8BflJB49aumm3oTLbUwNLuFfUY/MDLtfbz64Yj+db2tDK2Kno12gP0IIrAgtftbQ/Kjsyb+cjn5sYPtkVPa3ktzBplrOv7xLsYbdncF3H+WK0nHmXMugbW8zW12SNLaIO4GJNxBPOApyah8NArp8vGCJDx6HAJH5k0apbyrq1tdJFvUhUyCM7gScfjn9KbotyDolzdKCMyyMAetEY/u3byBvVHI6jYi98QQTM8OYXtIlUuQ53vkkDv96ux13/kI+Hh/1ET/AOk81XotNtVWB5LaF54lGJGjBYEeh61R1z/kKeHB/wBRFv8A0mnpVqvPZdiYQ5bvubVFFFYmgUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBi3PzeNtMHZNPuyfYmS3x/I1Y1Y4gX08z/2U1XX9543l/wCmOnJ/4/I3/wAbqbV/+Pdf+uv/ALLV0/iRMtjCtZ/sM6MTu2wlgAO/PH51ejtltZdBt2IaYyvLI3uY3J/U/pWdf7YWtRjO6EqAOpOWraS2kik0mWc7p2mw3oo8mTgU4/A2+r/Q0qbxt2/Uuam5jihcDcyzKQM9etY3hmCa60IIZgkRkO5QnJ6HrWrq4JS3C9TKAKo+EeNLCjoVDfjyP6VpB2pSa7r9TKS95HQVi63/AMhbw3/2EX/9JbithHWRA6EFT0IrH1z/AJC/hr/sJP8A+klxXOWbVFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAGLZ/N4z1dx0WytI/wAQ07f+zCpdXPyRj/pp/SodH3P4g8RSHGFuYoR68QRt/wC1Km1MgzwA9N+T+lXT+IUtjmLeSS41YySHKKxiQf3cZz/6FXZXQ/0ix/67H/0W9cZZRNuQh2Be7lAHpwvP6/pXXeaZv7PdvvGYhh7iNwac9btf1oi5aKK8v1ZHrMghit5WOAkoYnGcYqj4T3LppVlKsshjIPXgmtDVD+8sl9Z1/mKq+G+dOZz1a5kP6mqT/dtGbWqNCx/5B0P+e9UNcH/E38N/9hJ//SS4q/Y/8g6H8P51Q1v/AJC/hv8A7CL/APpLcViUbVFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFBOBk0AYvh755NZuP+e2pSc/7ipH/AO06dqvNzGvv/hTPCWX8Ow3J6Xks14nH8E0ryqP++XAp2phheI4I47Grho2JnPwXEME9sksm1kupXkyCMA4AP/jprpIJY5pLd4nDxm7cqynIIMbGsSSaTzdOZlUMrSuCDkH/ADirdkp0/WINOBzC0pmiPpmNtw/X+dWknGXf/gIqb+H0/Vl/WV8yWzjyQGlAJHX7y0ujKscVxGgwq3koUegyaNW3farLYm9hJkLnGeVp+lI6wSM4CtJdTNjOcfMw/pUX90knsf8AkHQfh/OqGt/8hfw3/wBhF/8A0luKv2P/ACDrf6D+dUNa/wCQz4c/6/5P/SWeoGbVFFVEmupdzRxw7A7KNzkHg49KALdFZ7X9wjOHtBtRtpdZMgHAPp71Pa3TXDyK0YXYAQQ4YHNAFmiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArG8TzSjSGsLVyl5qLfY4GHVC4O5/+AIGf/gOK2elc/pQOtasdeYn7HGjQaenZ0JG+b/gRUBf9kZ/joA3YYY7eCOCJQscahEUdgBgCs3UtolBb7uCST7CtWsjVhvdE/vEg/TAppX0Dqc7PceeLNYoSpRZWyQBnOT/StjVSYbvSL6FfMYSbSg+8RsbOPwzWUI8TxI2Vf96cexz/AExWnPk6xtJ+W1BVB2+eOQk/+OgVpSd4t+f+SKrKzivL9WZ//CVS3VzpMp0lwbgFo0W4Q5yBjnjHJHXGa3tEvDeWjloWheO6mR0Yg4O4nqOO9cro2lyX+lWtywMT3ECRQE/8szGnyN+Lgt+VbvhKZrnTZ7h4zG8t7M7If4STyPwrWtCCT5Vsc9OUm1c17H/kHW/0FUNZ/wCQ34d/6/ZD/wCS01X7H/kHW3+6Kz9ZZRr3hxSQCbyXA9f9HlrlNjbqnFHdwIUQQMu5iCWIPJJ9PerlFAGb5eoqz7REFdix2vz+ZH9KmsLZoDMzJs3kEDdu7etXKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAxf+Et0HvqUQ/3gR/MUf8Jd4d76zZj/AHpQP51tUUAYo8X+Gi6p/b+mBmOFBukBJ9OtbCOkiB0YMjDIZTkEUrKrqVdQykYIIyDWJN4T0rzPPsITpl2CWWewxEc+rKBtf6MDQBuUVgDVNV0tzHq2nvdQKOL+wjLg/wC/Dkup/wB3ePp0q/aa7pN8m+21K0lAOCFlXKn0IzkH2NAGhRUDXtqoy1zCB6mQVQuPE+jW8vki/jnuP+fe1Bnl/wC+EBbHvigDWorDTxBdyKGj8M6yQemfIQ/k0op39t6j28Lat+Mtp/8AH6ANqisRdZ1VlBPhfUFJHINxbcflJS/2vq3bw1d/jcwf/F0AbVFYv9q6x28OT/jdQ/8AxVH9qa128Ov+N3H/AI0AbVFYv9pa528Pj8b1P8KP7R17toEX43y//E0AbVFYv2/xB20K3/HUP/sKPt3iLtodn+Oon/41QBtUVhrq+sRIPtPhq5Zsc/ZLqGQA/V2Q/pVvTNcstVLRxM8N0igy2lwvlzRf7ynt7jIPYmgDRooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoorK1fVzZFLOyhF1qk6kwW27Ax/fc/woO5/AAkgUAVdZlOragvh23LhHQS6hKufkhJwI89mk5HqFDHg4rdRFjRURQqKMKqjAA9BVLSNMGl2ZjaUz3MrmW5uCMGaQ9W9hwAB2AA7VfoAKyNSOLuP8f8A0GtesS7JuLlpeREmQG9W6Yq4K7E2ZV0Nmswg/wDPLP5rVqcD7XNu53RgvnufLmqHUtqa1AzEBRBkk9gFNWkt5LwCcDYLg+WgYcgCKTk+nLUqTtFvz/yNq+8fRfqVrXQdL/4RyynNhB5gt4XZtvJOBnP15q/4ahjgs7mOJAiLf3AVR2Acgfyqo8eu2mkraGHTWWOFIsiZwT0UH7laOhQTQWLfaPL817qeRhGSVBMjcAkDP5VvUk3B3d9TlilzKyJIpHi0m1aMKWOxfm6cnFZd7dySazozTKvy3TeUU6NmN1JOe2M/pWhIGOgQBThsJg++RVPV5DBfaNHLCiZuNkW1t2CFJ9BjgH1rmNToqKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKpXGkaZeStLc6daTyMAC8sCsTjpyRV2igDLXwzoKOWTRNNVj1ItIwT+lXraztrNGS1toYFY7isSBQT0zx9BU1FABRRRQAUUUUAFFFFABRRRQAUUUUAFUdS0ex1eNFvINzRnMUqMUkiPqjqQyn6EVeooAwjB4g0zAtZ4dWt8geXdt5MyD/roqlXx6FQfVjTl1jV8kP4YvMg4ytzAQfcZcH9K26KAMX+2NV/6Fm+/8CLf/AOOUf2xqn/Qs3/8A4EW//wAcraooAxf7Y1T/AKFm/wD/AAIt/wD45SLrOqlQT4XvwSOR9ot+P/IlbdFAGL/bGqf9Czf/APgRb/8Axyj+2NU/6Fm//wDAi3/+OVtUUAYv9sar/wBCzff+BFv/APHKP7Y1X/oWb7/wIt//AI5W1RQBi/2xqv8A0LN9/wCBFv8A/HKP7Y1X/oWb7/wIt/8A45W1RQBi/wBsar/0LN9/4EW//wAco/tjVf8AoWb3/wACLf8A+OVtUUAYv9r6r/0LV7/4EW//AMco/tfVf+havf8AwIg/+OVtUUAYv9r6r/0LV7/4EQf/ABdINV1pywTw3KmDgGa7iAPH+yWrbooAw9viS/JSRrLSYem6FjcysPYsqqh+oerml6PbaUspiaWaedt81zO++SU9sn0HQAYA7AVoUUAFFFFADJpPKhkk/uqW/IVmrHt0mMdehP48mr17/wAeFx/1yb+RqunNig+lWtI38xdTCmxN4jtYnAZQmCD3HIrqY+rj/arl2IHiC0/vMQp+gyf54rpGlENrJMe2WqLa2RrUeifkQAC9uiTkRRNjH98g9foDn8qdYj9z/wBt5v8A0Y1OsozFEqN94KM/Xkn9SaSx/wBSf+u03/oxqqT1sjJEEcbyaLbqgy21SBnrjms7WllutW0RXj8phcuyAkHcfLbPTpxk/hWxYf8AIOtP9wfyqhq3/IweH/8ArvN/6JepGbVFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFADd6/3h+dG9f7w/OnUUAN3r/eH50b1/vD86dRQA3ev94fnRvX+8Pzp1FADd6/3h+dG9f7w/OnUUAN3r/eH50b1/vD86dRQA3en95fzo3r/AHh+dOxRQA3ev94fnRvX+8Pzp1FACb1/vD86N6/3h+dLijA9KAE3r/eH50b1/vD86XA9KMD0oATev94fnRvX+8PzpcD0owPSgBN6/wB4fnRvX+8PzpcD0owPSgBN6/3h+dG9f7w/OlwPSjA9KAE3r/eH50b1/vD86XA9KTA9KADev94fnRvX+8PzowPSlwPSgBN6/wB4fnRvX+8PzpcD0owPSgBN6/3h+dG9f7w/OlwPSjA9KAE3r/eH50b1/vD86XA9KMD0oATev94fnRvX+8PzpcD0owPSgBN6/wB4fnRvX+8PzpcD0owPSgBN6/3h+dG9f7w/OlwPSjA9KAE3r/eH50m9R/EPzp2B6UmB6CgCrqEinT7gKwJMZHX2pn+r2xHhezEfWn6iv/EvmKjkLnj0HWo7zb8pXAHDcegzV7xSF1OaaTPie39Ffqf9010sh89o7ZeUj2tKf1C/ia5dWjuNYVkJyZXAbGQcEj+ldZZRLEhjBJ2HOT1bPc+9FuVu+6NKjTUbdiwgwxz1wM/rVaxOYT/12m/9GNVof6w/Qf1qtY/6o/8AXab/ANGNUEBp/wDyDrP/AHF/9Bqhq3/Iw6B/12m/9EtV/T/+QdZ/9c1/9Bqhqv8AyMWgf9dZv/RTUAbVFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFADdg9W/OjYPVvzp1FADdg9W/OjZ7t+dOooAbs92/OjZ7t+dOqKa4gtgpnmjiDttUuwXJwTgZ74B/KgB+z/ab86Nn+0350qurruVgwPcHNLQA3b/tN+dG3/ab86dRQA3b/ALTUbT/eanUUAN2n+81G0/32/SnUUAN2n++36UbT/fb9KdRQA3af77fpRtP99v0p1FADdp/vt+lG0/32/SnUUAN2n++36UbT/fb9KHkSJC8jqijksxwBVSTWNMi/1mo2if706j+tAFvaf75/IUbW/vn8hWTJ4s8OQ583xBpSY67ryMf1pv8AwmHhj/oY9I/8Dov/AIqgDYw3979KMN/e/SsY+MfC4BJ8SaOAOp+3Rf8AxVL/AMJh4Y/6GPSP/A6L/wCKoA2MN/eH5UYb+8PyrLHijw8wyuu6YQO4u4/8a0obiG4TfBLHKn95GDD9KAHYf+8Pyow/95fy/wDr06igBuH/ALy/l/8AXow/95fy/wDr06igBuH/ALy/l/8AXow/95fy/wDr06igBuH9V/Kj5/Vfyp1FADfn9Vo+f/Zp1FADfn/2aPn9F/OnUUANy/ov50Zf+6v5/wD1qdRQBFIHeNkKKQwIPzf/AFqxL+4mghitHgeSaQrCgTncMj5iewx1roKzZj5muxwyxgxm3LRvjkMG5GfoRWlN2epMjmLRbqa5s2UxiNmZgACOCTjP5muns9Qhu52KK8ckbtDNG4wVYcj8COQfQ1Sngv4NetUt7OB9NWI75CfmRucADP07etT20iXGv3aR2yI0Sx/aJQclmIbC/gpH50+W7lLvr/w45TuoxXQ1h/rD9B/Wq1j/AKo/9dpv/RjVYj6kHqAB/Oq9j/qj/wBdZv8A0YayGGn/APINsv8Armv/AKDVDVf+Rj0H/rpN/wCimq/p/wDyDbL/AK5r/wCg1Q1T/kY9B/66T/8Aoo0AbVFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFc7q0drqfizStNuUhnSG3nvXhkAYAjZGhKn1EkmPoag0rSY9aS71G/vNRed7y5iUQ380CJHHM8aKFjZR0XOSCSSea2tM0ay0gT/AGRJd9w4eWSad5ncgADLuS2AAMDOBQBVbwj4adtzeH9K3f3vscefzxTPCKLD4cit0GFt57i3A9BHM6f+y1uVyulaxb6QL6zvLfUUK39w6sunTujK8jPkOqFSPmPegDqqKxf+Et0QffvTF/11heP/ANCUUi+MfDLZ/wCKg0xcHB3XSL/M0AbdFYv/AAmHhj/oY9I/8Dov/iqevivw6/3df0tvpeRn+tAGvRWcviDRX+7q9g30uUP9aeutaU4yup2ZHTidT/WgC9RVMarpx6aha/8Af5f8ab/bOl4z/aVnj/ruv+NAFySRIo2kkYIiAszMcAAdSa5vTbfU/EFlb6reapc2MVzGJIbOy2qERuV3sylmfGM42gdMdy3xTrmnS+G9QsrS+guL68tpILaC3cSSO7KQMKuTgZyT0AGTXSRiKKJI4yqogCqAegFAGT/wjFo3Mt9q8h9f7TnT9EcCj/hE9Gb/AFttLP8A9fFzLL/6GxrY3p/eX86N6f3l/OgDIHhDw0Dn/hHtKJ9TZxkn8cVbj0bS4ceVptnHj+7Ao/pVzen95fzo3p/eX86AEjhiiGI40Qf7KgU+m70/vL+dG9P7y/nQA6im70/vL+dG9P7y/nQBHJaW0oIkt4nB6hkBzWfN4W8P3D+ZLoemvJ/fNqm788ZrU3p/eX86N6f3l/OgDGPhPShjyvt1uB/Db6jcRL+SOBS/8I4if6nVtXi/7fGk/wDQ91bG9P7y/nRvT+8v50AY/wDYd+PueJ9WA7Ax2zD9Yc/rR/ZmuJ/q/EO//rvZI3/oJWtjen95fzo3p/eX86AMb7F4kY7X1vT1T1i01g/5tMw/8do/sCeX/j81/Vp17qsiQD8DEit+tbO9P7y/nRvT+8v50AZXhSWWfwhoss8ryzNYwmSSRizM2wZJJ5JznmtesPwk6jwvYpuH7tWj6/3WK/0ra3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzqlq2qwaRpVxfygukKglUIyckAfqaTaSuxxi5NJbsv0V5bb/FO7GpM9xZwmybgRI3zqPXd3P4D8K9NguYri3jmRgFkUOMnnBGayo4iFW/I9jevhalC3OtyWq15bG7haATSwFhxJC21lIIPBqfen95fzppdPMHzL0Pf6VsnbU5zMaz1ZbdI31SNgpO6UW4DkcY74B65479q04YVhTAO5jje5A3OQMZOO/FJK6eS/zL09aeZEBGXXnpzVOTYkrCKMSye+DVex/wBWf+us3/ow1OHTzm+Zfujv9arWLp5Z+Zf9bN3/AOmhqRi6f/yDLHv+6T/0GqOqf8jJoP8Avz/+izV3T3T+zbH5l/1Sd/8AZqhqbr/wkuhfMPvT9/8ApnQBuUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzo3p/eX86AHUU3en95fzp1ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBi/8IppQ+6L5P8Ac1C4X+T0f8Itp/8Az8av/wCDi7/+O1tUUAYv/CMWY+5e6uv/AHFLhv5uaP8AhHEH3NW1df8At8Zv55raooAp6XpsWk6fHZwySyIjO2+VtzMWYsST9WNXKKKACiiigAooooAKY0MT/ejRvqoNPooArNp9k/3rO3b6xKf6VENF0oDA0yz65/1C/wCFXqKAM+TRNJ2N/wASyy6H/l3X/CvlHTNNsZNMtHezt2dokLM0YJJxX14/+rb6Gvk3Sf8AkEWX/XFP5CvWymMZTlddDCu7JEq6Tpp/5cLX/v0v+FSLo+mf9A+1/wC/K/4VYSpV617vsqf8q+45XJ9yuujaX/0DrT/vyv8AhUq6LpX/AEDbT/vyv+FWV6VMlL2UP5ULmfcqroek/wDQMs/+/C/4VKuhaR/0C7L/AL8L/hVpamWl7KH8qFzPuU10HRz/AMwqy/78L/hUq+H9G/6BNj/4Dr/hVxKlWl7KHZC5n3Ka+HtF/wCgTY/+A6f4VIvh3RP+gRYf+A6f4VeWpVpOlDshcz7lAeHND/6A9h/4DJ/hUq+GtC/6A2n/APgMn+FX1qVal04dkHM+5nr4Z0H/AKAun/8AgMn+FSL4Y0D/AKAmnf8AgMn+FaK9KkWodOHZBzPuZw8L+H/+gJp3/gKn+FSL4W8P/wDQD03/AMBU/wAK0lqVelQ6cOw+Z9zMXwr4e/6AWm/+Aqf4U9fCnh3/AKAWmf8AgIn+Fai1ItS6cOw+Z9zLHhPw5/0AdM/8BE/wqQeEvDf/AEANL/8AARP8K1BUorNwj2HzPuZI8I+G/wDoX9L/APASP/Cnjwh4a/6F/S//AAEj/wAK1hUgrNwj2HzPuZA8H+Gc/wDIvaV/4Bx/4U8eDvDP/QvaV/4Bx/4VrjrTxWbjHsUpMxx4O8Mf9C7pX/gHH/hTx4N8Mf8AQu6T/wCAcf8AhWwKeKzcV2KTZjDwZ4X/AOhc0n/wDj/wp3/CGeF/+hc0n/wDj/wrZFPFZuK7FpsxR4L8Lf8AQuaT/wCAUf8AhSjwX4W/6FvSf/AKP/CtsU4Vk0ik2Yg8F+Fv+hb0j/wCj/wpf+EK8K/9C3pH/gFH/hW4KWsmi0Yf/CFeFf8AoW9I/wDAKP8Awpf+EK8K/wDQt6R/4BR/4VuUtZMtGF/whXhX/oW9I/8AAKP/AAo/4Qrwr/0Lekf+AUf+FbtBrNmiMH/hCvCv/Qt6R/4BR/4Un/CFeFf+hb0j/wAAo/8ACt6krNs2ikYJ8F+Fv+hb0j/wCj/wpD4L8Lf9C3pP/gFH/hW8aaazbZqkjB/4Qvwt/wBC5pP/AIBR/wCFNPgzwv8A9C5pP/gHH/hW92pprNtmqiuxgnwZ4X/6FzSf/AOP/Cmnwb4Y/wChd0n/AMA4/wDCt40w1Dk+5oox7GCfB3hj/oXdK/8AAOP/AApp8HeGf+he0r/wDj/wrdNMNQ5PuaqEexhHwf4Z/wChe0r/AMA4/wDCmHwh4a/6F/S//ASP/Ct01Ganml3NFCPYwj4R8N/9ADS//ASP/CmHwl4c/wCgBpn/AICJ/hW6ajap5pdzRQj2MI+E/Dn/AEAdM/8AARP8Kjbwp4d/6AWmf+Aqf4VuN1qNqXNLuaKnDsYjeFfD3/QC03/wFT/Com8LeH/+gHpv/gKn+FbjdKibrS55dy1Th2RiN4Y0D/oCad/4Cp/hUbeGdB/6Aunf+Ayf4VtNUTdKXPLuaKnDsjFPhrQv+gNp/wD4DJ/hUTeG9DH/ADB7D/wGT/Ctk1E9HPLuWqUP5UY7eHdE/wCgRYf+A6f4VE3h7Rc/8gmx/wDAdP8ACtdqibrT55dy1Sp/yr7jHbQNGH/MKsf/AAHX/Com0HR/+gXZf9+F/wAK1nqF6alLuUqVP+VfcZLaHpPP/Ess/wDvwv8AhUL6JpQ/5htp/wB+V/wrWbvUD1SlLuWqNP8AlX3GU+jaWP8AmHWn/flf8KhfSNNA/wCQfa/9+V/wrUeq79KpSfctUaf8q+4y30rTh0sbb/v0v+FVpdMsB0srcf8AbMVqyVVlrSMn3NI0af8AKvuMqTT7MA4tIP8Av2K+pvARJ+Hnhok5P9l23/opa+YZfumvp3wD/wAk78Nf9gu2/wDRS110XueDn8Iw9nyq2/6HRUUUVsfOhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA1/9W30NfJukkf2RZ8j/Up/IV9aVzx8BeDyST4V0Qk/9OEX/wATXZg8X9Wk3a9zOpDnR8+IR6iplI9RXvn/AAgPg7/oVdE/8AIv/iaP+EB8Hf8AQq6J/wCAEX/xNd/9s/3Px/4Bl9X8zwhSPUVMhHqK9x/4QHwd/wBCron/AIARf/E0f8ID4O/6FXRP/ACL/wCJo/tj+5+P/AF9W8zxNWHqKmVh6ivZv+EB8Hf9Cron/gBF/wDE1map8OPDs+o6LJaeGtGSCC8aS7UWca74vIlUAjHzfO0Zx7Z7Uv7Y/ufj/wAAPq3meYow9RUqsPUfnXrn/CA+Dv8AoVdE/wDACL/4mj/hAfB3/Qq6J/4ARf8AxNH9r/3Px/4AvqvmeUqy+o/OpVZfUfnXqP8AwgPg7/oVdE/8AIv/AImj/hAfB3/Qq6J/4ARf/E0v7X/ufj/wA+q+Z5mrL6j86lVl/vD869H/AOEB8Hf9Cron/gBF/wDE0f8ACA+Dv+hV0T/wAi/+Jpf2t/c/H/gB9V8zzxWXH3h+dSqy+o/Ou+/4QHwd/wBCron/AIARf/E0f8ID4O/6FXRP/ACL/wCJqf7U/ufj/wAAPqvmcMrL/eH51IrLj7w/Oui1T4ceHZ9R0WS08NaMkEF40l2os413xeRKoBGPm+dozj2z2rT/AOEB8Hf9Cron/gBF/wDE0v7T/u/j/wAAPqvmcerL/eH51IrL/eH511n/AAgPg7/oVdE/8AIv/iaP+EB8Hf8AQq6J/wCAEX/xNS8y/u/j/wAAf1bzOXDL/eH51IHX+8PzrpP+EB8Hf9Cron/gBF/8TR/wgPg7/oVdE/8AACL/AOJpPMP7v4/8APq3mc+HX+8Pzp4df7w/Ot3/AIQHwd/0Kuif+AEX/wATR/wgPg7/AKFXRP8AwAi/+Jqfr3938R/V/Mxg65+8Pzp4df7w/Otb/hAfB3/Qq6J/4ARf/E1ma/8ADjw7dadFHp3hrRo5xeW0jMtnGmYlnRpBnHdAwx3zjvUfXP7o/YeYgdf7w/OpA6/3h+dQ6x4I8JxaloKx+GdHRZL9kkC2MYDr9nmODxyMhT9QK1v+EB8Hf9Cron/gBF/8TUvFeQ/Y+ZRDr/eH504Ov94fnVz/AIQHwd/0Kuif+AEX/wATSHwF4P3r/wAUronQ/wDLhF/8TUvEeQ/ZeZWDr/eH504Ov94fnTbTwJ4QbTkdvC+ilipOTYxZ/wDQadceBPCAuLQDwtooDSEECwi5Gxv9moda/Qr2Y4Ov94fnS71/vD86kHgLwfvP/FK6J0H/AC4Re/8As1Xs/AnhB4yW8L6Kf3ko5sYugkIH8PpUudxqJLvX+8Pzp29f7w/OsXVfh54ev/BNzBp3hvR01G4090glFpGjCVojtO7GQd2Dmpb3wP4Uj8Q6NCvhnRwkiz+Yoso8NhVxkY5xUN3Ksam9f7w/Ojev94fnT/8AhAfB3/Qq6J/4ARf/ABNH/CA+Dv8AoVdE/wDACL/4mpauUnYj3r/eH50m9f7w/Opf+EB8Hf8AQq6J/wCAEX/xNH/CA+Dv+hV0T/wAi/8AialwLVSxCXX+8Pzppdf7w/OrH/CA+Dv+hV0T/wAAIv8A4mj/AIQHwd/0Kuif+AEX/wATU+y8y1Wt0K29cfeH50wuv94fnVz/AIQHwd/0Kuif+AEX/wATSN4B8HlSB4V0TOOP9Ai/+JqfYeZSxHkUi6/3h+dMLr/eH50nh34c+HLPwzpVtqfhnRpdQhtIkuZGs43LSBAGJYrzznnvWl/wgPg7/oVdE/8AACL/AOJqfq/mWsXboZhdf7w/OmF1/vD861v+EB8Hf9Cron/gBF/8TR/wgPg7/oVdE/8AACL/AOJpfVvMpY3+7+Jil1/vD86YXX+8Pzrd/wCEB8Hf9Cron/gBF/8AE0f8ID4O/wChV0T/AMAIv/ian6p5lLH/AN38f+Ac8XX+8PzqNmX+8Pzrpf8AhAfB3/Qq6J/4ARf/ABNH/CA+Dv8AoVdE/wDACL/4ml9T8y1mP938f+AcszL/AHh+dRsy/wB4fnXW/wDCA+Dv+hV0T/wAi/8AiazNA+HHh2106WPUfDWjSTm8uZFZrON8RNO7RjOOyFRjtjHaj6n/AHilmf8Ad/H/AIBgMy4+8PzqJmX+8Pzrt/8AhAfB3/Qq6J/4ARf/ABNH/CA+Dv8AoVdE/wDACL/4ml9S/vfgUs1/ufj/AMA4RmX+8PzqFmXHUfnXoP8AwgPg7/oVdE/8AIv/AImj/hAfB3/Qq6J/4ARf/E0fUv734DWbf3Px/wCAecll/vD86iZl9R+del/8ID4O/wChV0T/AMAIv/iaP+EB8Hf9Cron/gBF/wDE0fUv734Ff2x/c/H/AIB5czL6j86iZlz1H516t/wgPg7/AKFXRP8AwAi/+Jo/4QHwd/0Kuif+AEX/AMTR9S/vfgP+2f7n4/8AAPInYeo/OoXYeor1DQPhx4dtdOlj1Hw1o0k5vLmRWazjfETTu0YzjshUY7Yx2rT/AOEB8Hf9Cron/gBF/wDE0/qf94r+2v7n4/8AAPFmYc8ioHYeor3D/hAfB3/Qq6J/4ARf/E0f8ID4O/6FXRP/AAAi/wDiaf1TzH/bn/Tv8f8AgHhDkeoqByMdRXv3/CA+Dv8AoVdE/wDACL/4mj/hAfB3/Qq6J/4ARf8AxNNYXzKWe/8ATv8AH/gHzxIR6iqspHqK+kf+EB8Hf9Cron/gBF/8TR/wgPg7/oVdE/8AACL/AOJqlh7dSln9v+Xf4/8AAPmKUjB5r6d8A/8AJO/DX/YLtv8A0UtH/CA+Dv8AoVdE/wDACL/4mt6CCG1t47e3iSKGJQkccahVRQMAADoAO1bQhynn5jmP1zl921r9b728l2JKKKKs80KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAKV/qlvpvl+fHdv5mcfZ7OWfGMdfLVsde/WskX1zc+JbMWN9dSQSAy3VpNbrGtvDsYKTlBIrtIFwGPI38cV0dUv7H0v+0jqX9m2f28nJuvIXzTxt+/jPTjr04oAyNQuNVsfFFtPLck6PO8dukMTpuErBuWUxliPu9HGMdMZrpKpR6PpcV3Hdx6bZpcxII45lgUOigYChsZAxxj0q7QAUUUUAFFFFABVW+v4dPhWWdLl1ZtoFvbSTNnr91FJA464xVqigDmb7U57q+05tKvb1JppUBsZbTy1aJXHmyOJEEigKSAQQN20c5qLxPqt/ZXNybS7NutlYNerGEVvtThseWdwJxwB8uDlxzW9caPpd5fR3tzptnPdxACOeWBWkQA5GGIyMEkj3NOl0vT53haWwtZGhkMsReFSY3J3Fl44JPOR3oAt0UUUAFFFFABRRRQBVvr+HT4VlnS5dWbaBb20kzZ6/dRSQOOuMVkT6lNPrOiTWlzdx2lzPJBLbTWvlbsRSOGxIgcHKjoQPrXQ1TutJ06+uoLm70+1uLiA5hllhV3jPqpIyPwoA5Px5cajp+r+HdRS4K6Zb3n+kRRlBIzFHAIDIcjbvGMjOeOcEdxXNeIdL083+hXBsbUzR6kpWQwruXcHY4OOMt8315rpaACmn76/Q06mn76/jQBWsv+QXH/ALlLcf8AH3Z/77f+gGksf+QXD/1zpbj/AI/LT/eb/wBBNAFgf6w/Qf1rPS6jsrGS4lWZkWWXIhheVuZSOFQFj+ArQH+sP0H9arWP+qP/AF1m/wDRhoA5uXVpZdH0e50+4vbYR3VpBNHLZmISq7ohH71MkYJ5XH1o8VyXH/CU+HreC+ax8yO8Y3CqjFdsanHzAjHc8dAenWtgaXp2q6Vp8eo2FreIkaMi3EKyBTtHI3A4NUNa07T7rxPo1vc2FvPHKLiR1khVlLBEAJyMZwAAfYUAbOjXkuo6Hp97PH5ctxbRzOg/hZlBI/M1do6DAooAKKKKACiiigBk0qwQSTOHKopYhELsQPRQCSfYDNc5f699tm06y0+W/smurvyZLiWwkiKKIpH+Xzo9pJMYXofvfSumqC7s7W/tmt7y2huYGxuimQOpxyMg8UAYCXGt6x4NsbjTrqKLUJfLZpcqiyKG+YrlHA3KCR8p61q6Fff2jodpdEyMzphjIVLFgSDkqAp5B5AAPpUtxpGm3cPk3On2k0W1V2SQqy4XO0YI6DJx6ZNWYoo4IUihjWOJFCoiDAUDoAB0FAD6KKKACiiigAooooA5TVtVv7fXZRDdmOG2lsY/s2xSJhPMY2YkjdwPu4I5U5yOhNqt+viSRVuyLePUo7AWexcSI1uJS+cbtwLHocYQ8Z5roZ9Nsbq5jubiytpbiIFY5ZIlZkB6gEjIzQNNsFvEvBZWwuo08tJhEu9U/uhsZA9qALVFFFABRRRQAUUUUAFcr4s1W/sJJvsd2bYWum3F+BsVvPeMrhDuB+Xnnbg/MMEd+qqvdafZXzQtd2lvcGF98RljD7G9VyOD7igDD1y41Ww1e0vluWXRwYYZYY3jDmR5dmSGjYsPmUYDqeuMmukqkdH0trqG6bTbM3EAxFKYF3xjJPynGRySePU1doAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAMXxFwdJPpqMX8mH9a5rRP+Ed+0zf8JB9i/4SX+0Jc/asfaP9afJ8rPzbNmzG3jGe+a6XxJxFpp9NRt//AELH9a2qAPOYfE+qs+5dU828dbz7Zp3lR/8AEvEauY24XcOVRfnJDb8jih9c1/T7HcdRe9mn0aO+3vbp+4cuquyqijKhXLYOT8vXmvRqafvr+NAHk2nah/pt9JbaompobrR4hcPHG+VaVgQCq7SRk/MoBH1GataPdywTaVbPq73t0viC5int7gQs9uvmXO04CBlLAAgnt93A4r0ax/5BNv8A9cl/lSzj/iYWnPQP/IUAecDxZrA0q4uotV8++/si7uby18mP/iWTxrlFwFyMNlcSbt2MjgGpJ9U1SzgvrS4vftg2WlyrTW8XyNJesjgALjaQoIzkg9+mPSx/rG+g/rVax/1Z/wCus3/ow0AcLpGrawq2N3JqbyQHWDp4tDDGEEW0gchd24HBzuxjgg9ap6Xrt3f+NfCvn6v511Ot79t0/ZGPsbBBiPAUMuCMfMSTtyOK9G0//kHWX/XFP/QRWFPpFpa+OdKu0895pIro5muZJQmdmdiuxCDnooH6UAZXivxDd6f4jv7Vde/s6OHSUuraHyo28+4LygL8yktnao2KQx7Y5qpf+MNTg8SWsS3CwEXtnaXGnzTR7j53lhmSMRFyo8z75kA3KRg9D6AthbJqUmoLHi6khSB5Nx5RSzKMdOC7c9easUAefPrepwaBe6nc6xODJq9zYwf6iGG2RLmRFZ3aJsDCYLEHqOMnNRaPr+ta2uj2v9qmAy3l7bzXNskchlSIEoylowvp8wQA9cDNejUUAcN4b1jWJrnQJL7UTcrqUFwJYjCiIjREbWXA3ZIzkEkZPAHSrHiHWtU07Xf7It5yJNXSNNNfy1PkurYnPTB2xkSANnow6V2NFAHnp8WXw8c21nFeKbaTUXspbKaWMyIBG5DiNYgyqSoIZpDkHpyMVNF8RPomhWCXF6ltavo88luJAvz3CyHhSRlmwR8vf0r02igDzKfxP4gkmtkGqadYN9itZoTe3Cwrds6AudphYuN2VwjKR+Ir02iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAP//Z", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "env.vis.figsize = (8, 8)\n", + "\n", + "# Plot simulator state with the stacked trajectories\n", + "_ = env.reset(agent_type=torch.Tensor([-0.2, 1.0, -0.2]))\n", + "img = env.vis.plot_simulator_state(\n", + " env_indices=[2], \n", + " agent_positions=trajs['agent_positions'], # Pass stacked trajectories directly\n", + " zoom_radius=100,\n", + " multiple_rollouts=True, \n", + " line_alpha=0.5, \n", + " line_width=1.0, \n", + " weights=trajs['collision_weights'], \n", + " colorbar=True, \n", + ")[0]\n", + "\n", + "Image.fromarray(img_from_fig(img))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Figure saved as effect_of_rew_cond_2.png\n" + ] + } + ], + "source": [ + "# Save the figure with high DPI\n", + "fig = img # Since img is already the figure object\n", + "filename = \"effect_of_rew_cond_2.png\"\n", + "fig.savefig(filename, dpi=300, bbox_inches='tight', pad_inches=0.1)\n", + "print(f\"Figure saved as {filename}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gpudrive", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index 13badcc73..4dd76e3c9 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -3,7 +3,7 @@ from dataclasses import dataclass from enum import Enum -from typing import Tuple, Optional +from typing import Tuple, Optional, Union import torch import madrona_gpudrive @@ -99,11 +99,14 @@ class EnvConfig: condition_mode: str = "random" # Options: "random", "fixed", "preset" + # If condition_mode is "fixed", set the agent weights here + agent_type: Optional[Union[str, torch.Tensor]] = None + # Define upper and lower bounds for reward components if using reward_conditioned collision_weight_lb: float = -1.0 collision_weight_ub: float = 0.0 goal_achieved_weight_lb: float = 1.0 - goal_achieved_weight_ub: float = 2.0 + goal_achieved_weight_ub: float = 3.0 off_road_weight_lb: float = -1.0 off_road_weight_ub: float = 0.0 diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 037c87df6..a8694584a 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -45,18 +45,8 @@ def __init__( self.render_config = render_config self.backend = backend - # Initialize reward weights tensor if using reward_conditioned + # Initialize reward weights tensor to None initially self.reward_weights_tensor = None - if ( - hasattr(self.config, "reward_type") - and self.config.reward_type == "reward_conditioned" - ): - # Use default condition_mode from config or fall back to "random" - condition_mode = getattr(self.config, "condition_mode", "random") - agent_type = getattr(self.config, "agent_type", None) - self._set_reward_weights( - condition_mode=condition_mode, agent_type=agent_type - ) # Environment parameter setup params = self._setup_environment_parameters() @@ -77,6 +67,18 @@ def __init__( self.cont_agent_mask.sum().item() ) + # Now initialize reward weights tensor if using reward_conditioned reward type + if ( + hasattr(self.config, "reward_type") + and self.config.reward_type == "reward_conditioned" + ): + # Use default condition_mode from config or fall back to "random" + condition_mode = getattr(self.config, "condition_mode", "random") + self.agent_type = getattr(self.config, "agent_type", None) + self._set_reward_weights( + condition_mode=condition_mode, agent_type=self.agent_type + ) + # Setup action and observation spaces self.observation_space = Box( low=-1.0, @@ -124,12 +126,15 @@ def _set_reward_weights( If condition_mode is "preset", can be one of: "cautious", "aggressive", "balanced" If condition_mode is "fixed", should be a tensor of shape [3] with weight values """ + # Initialize the reward weights tensor if it doesn't exist yet + # Use the shape from controlled agent mask to ensure consistency if self.reward_weights_tensor is None: self.reward_weights_tensor = torch.zeros( - self.num_worlds, - self.max_cont_agents, + self.cont_agent_mask.shape[0], # num_worlds + self.cont_agent_mask.shape[1], # max_agent_count from mask 3, # collision, goal_achieved, off_road device=self.device, + dtype=torch.float16, ) # Read bounds for the three reward components @@ -140,6 +145,7 @@ def _set_reward_weights( self.config.off_road_weight_lb, ], device=self.device, + dtype=torch.float16, # Ensure same dtype as reward_weights_tensor ) upper_bounds = torch.tensor( @@ -149,6 +155,7 @@ def _set_reward_weights( self.config.off_road_weight_ub, ], device=self.device, + dtype=torch.float16, # Ensure same dtype as reward_weights_tensor ) bounds_range = upper_bounds - lower_bounds @@ -164,6 +171,7 @@ def _set_reward_weights( * 0.9, # Strong off-road penalty ], device=self.device, + dtype=torch.float16, # Ensure same dtype as reward_weights_tensor ), "aggressive": torch.tensor( [ @@ -175,6 +183,7 @@ def _set_reward_weights( * 0.6, # Moderate off-road penalty ], device=self.device, + dtype=torch.float16, # Ensure same dtype as reward_weights_tensor ), "balanced": torch.tensor( [ @@ -195,6 +204,7 @@ def _set_reward_weights( / 2, ], device=self.device, + dtype=torch.float16, # Ensure same dtype as reward_weights_tensor ), "risk_taker": torch.tensor( [ @@ -205,6 +215,7 @@ def _set_reward_weights( * 0.4, # Low off-road penalty ], device=self.device, + dtype=torch.float16, # Ensure same dtype as reward_weights_tensor ), } @@ -215,10 +226,17 @@ def _set_reward_weights( env_indices = torch.tensor(env_idx_list, device=self.device) num_envs = len(env_indices) + # Get the max agents dimension from the controlled agent mask + max_agents = self.cont_agent_mask.shape[1] + if condition_mode == "random": # Traditional random sampling within bounds random_values = torch.rand( - num_envs, self.max_cont_agents, 3, device=self.device + num_envs, + max_agents, + 3, + device=self.device, + dtype=torch.float16, # Create directly as float16 ) scaled_values = lower_bounds + random_values * bounds_range @@ -234,8 +252,8 @@ def _set_reward_weights( scaled_values = ( preset_weights.unsqueeze(0) .unsqueeze(0) - .expand(num_envs, self.max_cont_agents, 3) - ) + .expand(num_envs, max_agents, 3) + ) # Already float16 from agent_presets elif condition_mode == "fixed": # Use custom provided weights @@ -244,7 +262,9 @@ def _set_reward_weights( "For condition_mode='fixed', agent_type must be a tensor of shape [3]" ) - custom_weights = agent_type.to(device=self.device) + custom_weights = agent_type.to( + device=self.device, dtype=torch.float16 + ) # Ensure float16 if custom_weights.shape != (3,): raise ValueError( f"agent_type tensor must have shape [3], got {custom_weights.shape}" @@ -253,8 +273,8 @@ def _set_reward_weights( scaled_values = ( custom_weights.unsqueeze(0) .unsqueeze(0) - .expand(num_envs, self.max_cont_agents, 3) - ) + .expand(num_envs, max_agents, 3) + ) # Already float16 from conversion above else: raise ValueError(f"Unknown condition_mode: {condition_mode}") @@ -299,8 +319,9 @@ def reset( if condition_mode is not None else getattr(self.config, "condition_mode", "random") ) + self.agent_type = agent_type self._set_reward_weights( - env_idx_list, condition_mode=mode, agent_type=agent_type + env_idx_list, condition_mode=mode, agent_type=self.agent_type ) return self.get_obs(mask) diff --git a/gpudrive/utils/checkpoint.py b/gpudrive/utils/checkpoint.py new file mode 100644 index 000000000..43c2215e3 --- /dev/null +++ b/gpudrive/utils/checkpoint.py @@ -0,0 +1,29 @@ +import torch + +from gpudrive.networks.late_fusion import NeuralNet + + +def load_policy(path_to_cpt, model_name, device, env_config=None): + """Load a policy from a given path.""" + + # Load a trained model + saved_cpt = torch.load( + f=f"{path_to_cpt}/{model_name}.pt", + map_location=device, + weights_only=False, + ) + + print(f"Load model from {path_to_cpt}/{model_name}.pt") + + # Create policy architecture from saved checkpoint + policy = NeuralNet( + input_dim=saved_cpt["model_arch"]["input_dim"], + action_dim=saved_cpt["action_dim"], + hidden_dim=saved_cpt["model_arch"]["hidden_dim"], + config=env_config, + ).to(device) + + # Load the model parameters + policy.load_state_dict(saved_cpt["parameters"]) + + return policy.eval() diff --git a/gpudrive/utils/env.py b/gpudrive/utils/env.py new file mode 100644 index 000000000..6616a8d04 --- /dev/null +++ b/gpudrive/utils/env.py @@ -0,0 +1,52 @@ +import dataclasses +import torch + +from gpudrive.env.env_torch import GPUDriveTorchEnv +from gpudrive.env.config import EnvConfig, RenderConfig + + +def make_env(config, train_loader): + """Make the environment with the given config.""" + + # Override any default environment settings + env_config = dataclasses.replace( + EnvConfig(), + ego_state=config.ego_state, + road_map_obs=config.road_map_obs, + partner_obs=config.partner_obs, + reward_type=config.reward_type, + norm_obs=config.norm_obs, + dynamics_model=config.dynamics_model, + collision_behavior=config.collision_behavior, + dist_to_goal_threshold=config.dist_to_goal_threshold, + polyline_reduction_threshold=config.polyline_reduction_threshold, + remove_non_vehicles=config.remove_non_vehicles, + lidar_obs=config.lidar_obs, + disable_classic_obs=True if config.lidar_obs else False, + obs_radius=config.obs_radius, + steer_actions=torch.round( + torch.linspace( + -torch.pi, torch.pi, config.action_space_steer_disc + ), + decimals=3, + ), + accel_actions=torch.round( + torch.linspace(-4.0, 4.0, config.action_space_accel_disc), + decimals=3, + ), + reward_type=config.reward_type, + condition_mode=config.condition_mode, + agent_type=config.agent_type, + ) + + render_config = RenderConfig() + + env = GPUDriveTorchEnv( + config=env_config, + data_loader=train_loader, + max_cont_agents=config.max_controlled_agents, + device=config.device, + render_config=render_config, + ) + + return env diff --git a/gpudrive/utils/multi_policy_rollout.py b/gpudrive/utils/multi_policy_rollout.py deleted file mode 100644 index 20985eaad..000000000 --- a/gpudrive/utils/multi_policy_rollout.py +++ /dev/null @@ -1,195 +0,0 @@ -import torch -import pandas as pd -from gpudrive.visualize.utils import img_from_fig -from gpudrive.datatypes.observation import GlobalEgoState - -def multi_policy_rollout( - env, - policies, - device, - deterministic: bool = False, - render_sim_state: bool = False, - render_every_n_steps: int = 1, - zoom_radius: int = 100, - return_agent_positions: bool = False, - center_on_ego: bool = False, -): - """ - Perform a rollout of multiple policies in the environment. - - Args: - env: The simulation environment. - policies (dict): Dictionary of policies {policy_name: (policy_function,mask)}. - device: The device to execute computations on (CPU/GPU). - policy_masks (dict): Dictionary of policy masks {policy_name: mask_tensor}. - deterministic (bool): Whether to use deterministic policy actions. - return_agent_positions (bool): Whether to return agent positions. - - Returns: - policy_metrics: Dictionary of metrics corresponding to policies {policy_name: metrics(dict)} - metrics: { - 'goal_achieved', 'collided', 'off_road', 'off_road_count', 'collided_count', 'goal_achieved_count', 'frac_off_road', 'frac_collided', 'frac_goal_achieved' - } - - """ - - # Initialize storage - num_worlds = env.num_worlds - max_agent_count = env.max_agent_count - episode_len = env.config.episode_len - sim_state_frames = {env_id: [] for env_id in range(num_worlds)} - agent_positions = torch.zeros((num_worlds, max_agent_count, episode_len, 2)) - - # Reset environment - next_obs = env.reset() - policy_metrics = { - policy_name: { - "goal_achieved": torch.zeros((num_worlds, max_agent_count), device=device), - "collided": torch.zeros((num_worlds, max_agent_count), device=device), - "off_road": torch.zeros((num_worlds, max_agent_count), device=device), - } - for policy_name in policies - } - episode_lengths = torch.zeros(num_worlds) - - active_worlds = list(range(num_worlds)) - control_mask = env.cont_agent_mask - live_agent_mask = control_mask.clone() - - for time_step in range(episode_len): - print(f't: {time_step}') - - policy_live_masks = {name: mask & live_agent_mask for name, (policy_fn,mask) in policies.items()} - - - actions = {} - for policy_name, (policy_fn,policy_mask) in policies.items(): - live_mask = policy_live_masks[policy_name] - if live_mask.any(): - actions[policy_name], _, _, _ = policy_fn( - next_obs[live_mask], deterministic=deterministic - ) - - - combined_mask = torch.zeros_like(live_agent_mask, dtype=torch.bool) - for live_mask in policy_live_masks.values(): - combined_mask |= live_mask - assert torch.all(live_agent_mask == combined_mask), "Live agent mask mismatch!" - - action_template = torch.zeros((num_worlds, max_agent_count), dtype=torch.int64, device=device) - - # Assign actions based on policy masks - for policy_name, action in actions.items(): - live_mask = policy_live_masks[policy_name] - if action.numel() > 0: - action_template[live_mask] = action.to(dtype=action_template.dtype, device=device) - - # Step environment - env.step_dynamics(action_template) - - if render_sim_state and len(active_worlds) > 0: - - has_live_agent = torch.where( - live_agent_mask[active_worlds, :].sum(axis=1) > 0 - )[0].tolist() - - if time_step % render_every_n_steps == 0: - if center_on_ego: - agent_indices = torch.argmax(control_mask.to(torch.uint8), dim=1).tolist() - else: - agent_indices = None - - sim_state_figures = env.vis.plot_simulator_state( - env_indices=has_live_agent, - time_steps=[time_step] * len(has_live_agent), - zoom_radius=zoom_radius, - center_agent_indices=agent_indices, - policy_masks=policies - ) - for idx, env_id in enumerate(has_live_agent): - sim_state_frames[env_id].append( - img_from_fig(sim_state_figures[idx]) - ) - - - # Update observations and agent statuses - next_obs = env.get_obs() - dones = env.get_dones().bool() - infos = env.get_infos() - - for policy_name, live_mask in policy_live_masks.items(): - policy_metrics[policy_name]["off_road"][live_mask] += infos.off_road[live_mask] - policy_metrics[policy_name]["collided"][live_mask] += infos.collided[live_mask] - policy_metrics[policy_name]["goal_achieved"][live_mask] += infos.goal_achieved[live_mask] - - live_agent_mask[dones] = False - - # Process completed worlds - num_dones_per_world = (dones & control_mask).sum(dim=1) - total_controlled_agents = control_mask.sum(dim=1) - done_worlds = (num_dones_per_world == total_controlled_agents).nonzero(as_tuple=True)[0] - - for world in done_worlds: - if world in active_worlds: - active_worlds.remove(world) - episode_lengths[world] = time_step - - if return_agent_positions: - global_agent_states = GlobalEgoState.from_tensor(env.sim.absolute_self_observation_tensor()) - agent_positions[:, :, time_step, 0] = global_agent_states.pos_x - agent_positions[:, :, time_step, 1] = global_agent_states.pos_y - - if not active_worlds: - break - - controlled_per_scene = sum(mask.sum(dim=1).float() for policy_name,(policy_fn,mask) in policies.items()) - - - - metrics =compute_metrics(policy_metrics,policy_live_masks,controlled_per_scene) - - if render_sim_state: - return metrics, sim_state_frames - - return metrics - -def compute_metrics(policy_metrics,policy_live_masks,controlled_per_scene): - - for policy_name, live_mask in policy_live_masks.items(): - - policy_metrics[policy_name]['off_road_count'] = ( policy_metrics[policy_name]["off_road"] > 0).float().sum(axis=1) - policy_metrics[policy_name]['collided_count'] = (policy_metrics[policy_name]["collided"] > 0).float().sum(axis=1) - policy_metrics[policy_name]['goal_achieved_count'] = (policy_metrics[policy_name]['goal_achieved'] > 0).float().sum(axis=1) - - policy_metrics[policy_name]['frac_off_road'] = policy_metrics[policy_name]['off_road_count'] / controlled_per_scene - policy_metrics[policy_name]['frac_collided'] = policy_metrics[policy_name]['collided_count'] / controlled_per_scene - policy_metrics[policy_name]['frac_goal_achieved'] = policy_metrics[policy_name]['goal_achieved_count'] / controlled_per_scene - - - return policy_metrics - - -def create_data_table(data): - # Extract unique policies - policies = sorted(set(policy for pair in data.keys() for policy in pair)) - - # Create empty DataFrames - collisions_table = pd.DataFrame(index=policies, columns=policies) - off_roads_table = pd.DataFrame(index=policies, columns=policies) - goal_achieved_table = pd.DataFrame(index=policies, columns=policies) - - # Populate DataFrames - for (p1, p2), metrics in data.items(): - collisions_table.loc[p1, p2] = metrics['frac_collided'].item() - off_roads_table.loc[p1, p2] = metrics['frac_off_road'].item() - goal_achieved_table.loc[p1, p2] = metrics['frac_goal_achieved'].item() - - # Print Tables - print("Average Collisions Table:") - print(collisions_table, "\n") - - print("Average Off Roads Table:") - print(off_roads_table, "\n") - - print("Average Goal Achieved Table:") - print(goal_achieved_table, "\n") diff --git a/gpudrive/utils/rollout.py b/gpudrive/utils/rollout.py new file mode 100644 index 000000000..f36c1c6e5 --- /dev/null +++ b/gpudrive/utils/rollout.py @@ -0,0 +1,432 @@ +import torch +import pandas as pd +import numpy as np + +from gpudrive.visualize.utils import img_from_fig +from gpudrive.datatypes.observation import GlobalEgoState + +import torch +import pandas as pd +import numpy as np + +from gpudrive.visualize.utils import img_from_fig +from gpudrive.datatypes.observation import GlobalEgoState + + +def rollout( + env, + policy, + device, + deterministic: bool = False, + render_sim_state: bool = False, + render_every_n_steps: int = 1, + zoom_radius: int = 100, + return_agent_positions: bool = False, + center_on_ego: bool = False, + set_agent_type: bool = False, + agent_weights: torch.Tensor = None, +): + """ + Perform a rollout of a policy in the environment. + + Args: + env: The simulation environment. + policy: The policy to be rolled out. + device: The device to execute computations on (CPU/GPU). + deterministic (bool): Whether to use deterministic policy actions. + render_sim_state (bool): Whether to render the simulation state. + render_every_n_steps (int): Render every N steps. + zoom_radius (int): Radius for zoom in visualization. + return_agent_positions (bool): Whether to return agent positions. + center_on_ego (bool): Whether to center visualization on ego vehicle. + set_agent_type (bool): Whether to set agent type during reset. + agent_weights (torch.Tensor): Agent weights tensor for condition_mode="fixed". + + Returns: + tuple: Averages for goal achieved, collisions, off-road occurrences, + controlled agents count, and simulation state frames. + """ + # Initialize storage + sim_state_frames = {env_id: [] for env_id in range(env.num_worlds)} + num_worlds = env.num_worlds + max_agent_count = env.max_agent_count + episode_len = env.config.episode_len + agent_positions = torch.zeros( + (env.num_worlds, env.max_agent_count, episode_len, 2) + ) + + # Reset episode + if set_agent_type and agent_weights is not None: + # Pass agent_weights to reset when set_agent_type is True + next_obs = env.reset(condition_mode="fixed", agent_type=agent_weights) + else: + next_obs = env.reset() + + # Storage + goal_achieved = torch.zeros((num_worlds, max_agent_count), device=device) + collided = torch.zeros((num_worlds, max_agent_count), device=device) + off_road = torch.zeros((num_worlds, max_agent_count), device=device) + active_worlds = np.arange(num_worlds).tolist() + episode_lengths = torch.zeros(num_worlds) + + control_mask = env.cont_agent_mask + live_agent_mask = control_mask.clone() + + for time_step in range(episode_len): + + # Get actions for active agents + if live_agent_mask.any(): + action, _, _, _ = policy( + next_obs[live_agent_mask], deterministic=deterministic + ) + + # Insert actions into a template + action_template = torch.zeros( + (num_worlds, max_agent_count), dtype=torch.int64, device=device + ) + action_template[live_agent_mask] = action.to(device) + + # Step the environment + env.step_dynamics(action_template) + + # Render + if render_sim_state and len(active_worlds) > 0: + + has_live_agent = torch.where( + live_agent_mask[active_worlds, :].sum(axis=1) > 0 + )[0].tolist() + + if time_step % render_every_n_steps == 0: + if center_on_ego: + agent_indices = torch.argmax( + control_mask.to(torch.uint8), dim=1 + ).tolist() + else: + agent_indices = None + + sim_state_figures = env.vis.plot_simulator_state( + env_indices=has_live_agent, + time_steps=[time_step] * len(has_live_agent), + zoom_radius=zoom_radius, + center_agent_indices=agent_indices, + ) + for idx, env_id in enumerate(has_live_agent): + sim_state_frames[env_id].append( + img_from_fig(sim_state_figures[idx]) + ) + + # Update observations, dones, and infos + next_obs = env.get_obs() + dones = env.get_dones().bool() + infos = env.get_infos() + + off_road[live_agent_mask] += infos.off_road[live_agent_mask] + collided[live_agent_mask] += infos.collided[live_agent_mask] + goal_achieved[live_agent_mask] += infos.goal_achieved[live_agent_mask] + + # Update live agent mask + live_agent_mask[dones] = False + + # Process completed worlds + num_dones_per_world = (dones & control_mask).sum(dim=1) + total_controlled_agents = control_mask.sum(dim=1) + done_worlds = (num_dones_per_world == total_controlled_agents).nonzero( + as_tuple=True + )[0] + + for world in done_worlds: + if world in active_worlds: + active_worlds.remove(world) + episode_lengths[world] = time_step + + if return_agent_positions: + global_agent_states = GlobalEgoState.from_tensor( + env.sim.absolute_self_observation_tensor() + ) + agent_positions[:, :, time_step, 0] = global_agent_states.pos_x + agent_positions[:, :, time_step, 1] = global_agent_states.pos_y + + if not active_worlds: # Exit early if all worlds are done + break + + # Aggregate metrics to obtain averages across scenes + controlled_per_scene = control_mask.sum(dim=1).float() + + # Counts + goal_achieved_count = (goal_achieved > 0).float().sum(axis=1) + collided_count = (collided > 0).float().sum(axis=1) + off_road_count = (off_road > 0).float().sum(axis=1) + not_goal_nor_crash_count = ( + torch.logical_and( + goal_achieved == 0, # Didn't reach the goal + torch.logical_and( + collided == 0, # Didn't collide + torch.logical_and( + off_road == 0, # Didn't go off-road + control_mask, # Only count controlled agents + ), + ), + ) + .float() + .sum(dim=1) + ) + + # Fractions per scene + frac_goal_achieved = goal_achieved_count / controlled_per_scene + frac_collided = collided_count / controlled_per_scene + frac_off_road = off_road_count / controlled_per_scene + frac_not_goal_nor_crash_per_scene = ( + not_goal_nor_crash_count / controlled_per_scene + ) + + return ( + goal_achieved_count, + frac_goal_achieved, + collided_count, + frac_collided, + off_road_count, + frac_off_road, + not_goal_nor_crash_count, + frac_not_goal_nor_crash_per_scene, + controlled_per_scene, + sim_state_frames, + agent_positions, + episode_lengths, + ) + + +def multi_policy_rollout( + env, + policies, + device, + deterministic: bool = False, + render_sim_state: bool = False, + render_every_n_steps: int = 1, + zoom_radius: int = 100, + return_agent_positions: bool = False, + center_on_ego: bool = False, +): + """ + Perform a rollout of multiple policies in the environment. + + Args: + env: The simulation environment. + policies (dict): Dictionary of policies {policy_name: (policy_function,mask)}. + device: The device to execute computations on (CPU/GPU). + policy_masks (dict): Dictionary of policy masks {policy_name: mask_tensor}. + deterministic (bool): Whether to use deterministic policy actions. + return_agent_positions (bool): Whether to return agent positions. + + Returns: + policy_metrics: Dictionary of metrics corresponding to policies {policy_name: metrics(dict)} + metrics: { + 'goal_achieved', 'collided', 'off_road', 'off_road_count', 'collided_count', 'goal_achieved_count', 'frac_off_road', 'frac_collided', 'frac_goal_achieved' + } + + """ + + # Initialize storage + num_worlds = env.num_worlds + max_agent_count = env.max_agent_count + episode_len = env.config.episode_len + sim_state_frames = {env_id: [] for env_id in range(num_worlds)} + agent_positions = torch.zeros( + (num_worlds, max_agent_count, episode_len, 2) + ) + + # Reset environment + next_obs = env.reset() + policy_metrics = { + policy_name: { + "goal_achieved": torch.zeros( + (num_worlds, max_agent_count), device=device + ), + "collided": torch.zeros( + (num_worlds, max_agent_count), device=device + ), + "off_road": torch.zeros( + (num_worlds, max_agent_count), device=device + ), + } + for policy_name in policies + } + episode_lengths = torch.zeros(num_worlds) + + active_worlds = list(range(num_worlds)) + control_mask = env.cont_agent_mask + live_agent_mask = control_mask.clone() + + for time_step in range(episode_len): + + policy_live_masks = { + name: mask & live_agent_mask + for name, (policy_fn, mask) in policies.items() + } + + actions = {} + for policy_name, (policy_fn, policy_mask) in policies.items(): + live_mask = policy_live_masks[policy_name] + if live_mask.any(): + actions[policy_name], _, _, _ = policy_fn( + next_obs[live_mask], deterministic=deterministic + ) + + combined_mask = torch.zeros_like(live_agent_mask, dtype=torch.bool) + for live_mask in policy_live_masks.values(): + combined_mask |= live_mask + assert torch.all( + live_agent_mask == combined_mask + ), "Live agent mask mismatch!" + + action_template = torch.zeros( + (num_worlds, max_agent_count), dtype=torch.int64, device=device + ) + + # Assign actions based on policy masks + for policy_name, action in actions.items(): + live_mask = policy_live_masks[policy_name] + if action.numel() > 0: + action_template[live_mask] = action.to( + dtype=action_template.dtype, device=device + ) + + # Step environment + env.step_dynamics(action_template) + + if render_sim_state and len(active_worlds) > 0: + + has_live_agent = torch.where( + live_agent_mask[active_worlds, :].sum(axis=1) > 0 + )[0].tolist() + + if time_step % render_every_n_steps == 0: + if center_on_ego: + agent_indices = torch.argmax( + control_mask.to(torch.uint8), dim=1 + ).tolist() + else: + agent_indices = None + + sim_state_figures = env.vis.plot_simulator_state( + env_indices=has_live_agent, + time_steps=[time_step] * len(has_live_agent), + zoom_radius=zoom_radius, + center_agent_indices=agent_indices, + policy_masks=policies, + ) + for idx, env_id in enumerate(has_live_agent): + sim_state_frames[env_id].append( + img_from_fig(sim_state_figures[idx]) + ) + + # Update observations and agent statuses + next_obs = env.get_obs() + dones = env.get_dones().bool() + infos = env.get_infos() + + for policy_name, live_mask in policy_live_masks.items(): + policy_metrics[policy_name]["off_road"][ + live_mask + ] += infos.off_road[live_mask] + policy_metrics[policy_name]["collided"][ + live_mask + ] += infos.collided[live_mask] + policy_metrics[policy_name]["goal_achieved"][ + live_mask + ] += infos.goal_achieved[live_mask] + + live_agent_mask[dones] = False + + # Process completed worlds + num_dones_per_world = (dones & control_mask).sum(dim=1) + total_controlled_agents = control_mask.sum(dim=1) + done_worlds = (num_dones_per_world == total_controlled_agents).nonzero( + as_tuple=True + )[0] + + for world in done_worlds: + if world in active_worlds: + active_worlds.remove(world) + episode_lengths[world] = time_step + + if return_agent_positions: + global_agent_states = GlobalEgoState.from_tensor( + env.sim.absolute_self_observation_tensor() + ) + agent_positions[:, :, time_step, 0] = global_agent_states.pos_x + agent_positions[:, :, time_step, 1] = global_agent_states.pos_y + + if not active_worlds: + break + + controlled_per_scene = sum( + mask.sum(dim=1).float() + for policy_name, (policy_fn, mask) in policies.items() + ) + + metrics = compute_metrics( + policy_metrics, policy_live_masks, controlled_per_scene + ) + + if render_sim_state: + return metrics, sim_state_frames + + return metrics + + +def compute_metrics(policy_metrics, policy_live_masks, controlled_per_scene): + + for policy_name, live_mask in policy_live_masks.items(): + + policy_metrics[policy_name]["off_road_count"] = ( + (policy_metrics[policy_name]["off_road"] > 0).float().sum(axis=1) + ) + policy_metrics[policy_name]["collided_count"] = ( + (policy_metrics[policy_name]["collided"] > 0).float().sum(axis=1) + ) + policy_metrics[policy_name]["goal_achieved_count"] = ( + (policy_metrics[policy_name]["goal_achieved"] > 0) + .float() + .sum(axis=1) + ) + + policy_metrics[policy_name]["frac_off_road"] = ( + policy_metrics[policy_name]["off_road_count"] + / controlled_per_scene + ) + policy_metrics[policy_name]["frac_collided"] = ( + policy_metrics[policy_name]["collided_count"] + / controlled_per_scene + ) + policy_metrics[policy_name]["frac_goal_achieved"] = ( + policy_metrics[policy_name]["goal_achieved_count"] + / controlled_per_scene + ) + + return policy_metrics + + +def create_data_table(data): + # Extract unique policies + policies = sorted(set(policy for pair in data.keys() for policy in pair)) + + # Create empty DataFrames + collisions_table = pd.DataFrame(index=policies, columns=policies) + off_roads_table = pd.DataFrame(index=policies, columns=policies) + goal_achieved_table = pd.DataFrame(index=policies, columns=policies) + + # Populate DataFrames + for (p1, p2), metrics in data.items(): + collisions_table.loc[p1, p2] = metrics["frac_collided"].item() + off_roads_table.loc[p1, p2] = metrics["frac_off_road"].item() + goal_achieved_table.loc[p1, p2] = metrics["frac_goal_achieved"].item() + + # Print Tables + print("Average Collisions Table:") + print(collisions_table, "\n") + + print("Average Off Roads Table:") + print(off_roads_table, "\n") + + print("Average Goal Achieved Table:") + print(goal_achieved_table, "\n") diff --git a/gpudrive/visualize/core.py b/gpudrive/visualize/core.py index 6fbed0245..42a8e2485 100644 --- a/gpudrive/visualize/core.py +++ b/gpudrive/visualize/core.py @@ -101,7 +101,13 @@ def plot_simulator_state( plot_log_replay_trajectory: bool = False, agent_positions: Optional[torch.Tensor] = None, backward_goals: bool = False, - policy_masks: Optional[Dict[int,Dict[str,torch.Tensor]]] = None, + policy_masks: Optional[Dict[int, Dict[str, torch.Tensor]]] = None, + colorbar: bool = False, + multiple_rollouts: bool = False, + line_color="#1f77b4", + line_alpha: float = 0.3, + line_width: float = 1.0, + weights: Optional[Dict[str, torch.Tensor]] = None, ): """ Plot simulator states for one or multiple environments. @@ -116,14 +122,14 @@ def plot_simulator_state( agent_positions: Optional tensor to plot rolled out agent positions. backward_goals: If True, plots backward goals for controlled agents. policy_mask: dict - A dictionary that maps policies to world and specifies which agents are assigned to each policy. + A dictionary that maps policies to world and specifies which agents are assigned to each policy. For now maximum number of policies is 3 as there are only 3 colors in COLOR_AGENT_BY_POLICY The structure follows the format: {Policy Name: (Policy Function,mask) }, where: - Policy (str): The policy assigned to agents within the world. - Policy Function (Neural Network): The identifier for the simulation environment. - - - Mask (torch.Tensor): A boolean or index-based mask indicating which agents follow the given policy, for all worlds. + + - Mask (torch.Tensor): A boolean or index-based mask indicating which agents follow the given policy, for all worlds. """ if not isinstance(env_indices, list): env_indices = [env_indices] # Ensure env_indices is a list @@ -142,6 +148,12 @@ def plot_simulator_state( device=self.device, ) + self.multi_rollouts = multiple_rollouts + self.line_color = line_color + self.line_alpha = line_alpha + self.line_width = line_width + self.weights = weights + if backward_goals: # Get world means for coordinate transformation @@ -236,16 +248,15 @@ def plot_simulator_state( marker_scale = max(self.figsize) / 15 line_width_scale = max(self.figsize) / 15 - if policy_masks: world_based_policy_mask = {} - - for policy_name, (fn,mask) in policy_masks.items(): + + for policy_name, (fn, mask) in policy_masks.items(): for world in range(mask.shape[0]): if world not in world_based_policy_mask: world_based_policy_mask[world] = {} - world_based_policy_mask[world][policy_name] = mask[world] + world_based_policy_mask[world][policy_name] = mask[world] else: world_based_policy_mask = None @@ -315,122 +326,21 @@ def plot_simulator_state( ) if agent_positions is not None: - # First calculate the maximum valid trajectory length across all agents for this env_idx - max_valid_length = 0 - for agent_idx in range(agent_positions.shape[1]): - if controlled_live[agent_idx]: - trajectory = agent_positions[ - env_idx, agent_idx, :time_step, : - ] - valid_mask = ( - (trajectory[:, 0] != 0) - & (trajectory[:, 1] != 0) - & (torch.abs(trajectory[:, 0]) < OUT_OF_BOUNDS) - & (torch.abs(trajectory[:, 1]) < OUT_OF_BOUNDS) - ) - max_valid_length = max( - max_valid_length, valid_mask.sum().item() - ) - - # Create color palette - palette = sns.light_palette(AGENT_COLOR_BY_STATE["ok"]) - cmap = ListedColormap(palette) - norm = plt.Normalize(vmin=0, vmax=max_valid_length) - sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm) - - for agent_idx in range(agent_positions.shape[1]): - if controlled_live[agent_idx]: - trajectory = agent_positions[ - env_idx, agent_idx, :time_step, : - ] - valid_mask = ( - (trajectory[:, 0] != 0) - & (trajectory[:, 1] != 0) - & (torch.abs(trajectory[:, 0]) < OUT_OF_BOUNDS) - & (torch.abs(trajectory[:, 1]) < OUT_OF_BOUNDS) - ) - # Get valid trajectory points - valid_trajectory = trajectory[valid_mask] - - if len(valid_trajectory) > 1: - points = valid_trajectory.cpu().numpy() - - if self.render_3d: - trajectory_height = 0.05 - segments_3d = [] - for i in range(len(points) - 1): - segment = np.array( - [ - [ - points[i][0], - points[i][1], - trajectory_height, - ], - [ - points[i + 1][0], - points[i + 1][1], - trajectory_height, - ], - ] - ) - segments_3d.append(segment) - - # Adjust color mapping to use actual position in the valid trajectory - t = np.linspace( - 0, len(segments_3d), len(segments_3d) - ) - colors = cmap(norm(t)) - colors[:, 3] = np.linspace( - 0.3, 0.9, len(segments_3d) - ) - - lc = Line3DCollection( - segments_3d, - colors=colors, - linewidth=5, - zorder=1, - ) - ax.add_collection3d(lc) - else: - segments = [] - for i in range(len(points) - 1): - segment = np.array( - [ - [points[i][0], points[i][1]], - [ - points[i + 1][0], - points[i + 1][1], - ], - ] - ) - segments.append(segment) - - # Adjust color mapping to use actual position in the valid trajectory - t = np.linspace( - 0, len(segments), len(segments) - ) - colors = cmap(norm(t)) - colors[:, 3] = np.linspace( - 0.3, 0.9, len(segments) - ) - - lc = LineCollection( - segments, - colors=colors, - linewidth=5, - zorder=1, - ) - ax.add_collection(lc) - - # Add the colorbar - try: - fig = ax.get_figure() - cbar_ax = fig.add_axes([0.92, 0.09, 0.02, 0.8]) - cbar = fig.colorbar(sm, cax=cbar_ax) - cbar.set_label("Timestep", fontsize=15 * marker_scale) - cbar.ax.tick_params(labelsize=12 * marker_scale) - except Exception as e: - print(f"Warning: Could not add colorbar: {e}") + self.plot_agent_trajectories( + ax=ax, + agent_positions=agent_positions, + env_idx=env_idx, + time_step=time_step, + controlled_live=controlled_live, + render_3d=self.render_3d, + colorbar=colorbar, + marker_scale=marker_scale, + multiple_rollouts=self.multi_rollouts, + line_color=self.line_color, + line_alpha=self.line_alpha, + line_width=self.line_width, + weights=self.weights, + ) # Determine center point for zooming if center_agent_idx is not None: @@ -467,6 +377,238 @@ def plot_simulator_state( return figs + def plot_agent_trajectories( + self, + ax, + agent_positions, + env_idx=0, + time_step=None, + controlled_live=None, + render_3d=False, + colorbar=True, + marker_scale=1, + line_color=None, + line_alpha=None, + line_width=None, + multiple_rollouts=True, + weights=None, + ): + """ + Plot agent trajectories on the given matplotlib axis. + + Parameters: + ----------- + ax : matplotlib.axes.Axes + The axis to plot on + agent_positions : torch.Tensor + Tensor of shape [env, rollouts, agent, time, 2] or + [rollouts, agent, time, 2] (legacy format) + env_idx : int, default=0 + Index of the environment to plot + time_step : int, optional + Current time step to plot trajectories up to. If None, uses all timesteps. + controlled_live : list or tensor, optional + Boolean mask indicating which agents are controlled and alive. + If None, assumes all agents are active. + render_3d : bool, default=False + Whether to render in 3D + colorbar : bool, default=True + Whether to add a colorbar + marker_scale : float, default=1 + Scale factor for markers and text + line_color : str, optional + Color for trajectory lines (only used for multiple rollouts mode without weights) + line_alpha : float, optional + Transparency of trajectory lines + line_width : float, optional + Width of trajectory lines + multiple_rollouts : bool, default=True + Whether agent_positions contains multiple rollouts + weights : list, optional + Used to color lines by the absolute magnitude of weights. + + Returns: + -------- + matplotlib.cm.ScalarMappable or None: Returns the color mapper + """ + import torch + import numpy as np + import matplotlib.pyplot as plt + import seaborn as sns + from matplotlib.colors import ListedColormap + from matplotlib.collections import LineCollection + + if render_3d: + try: + from mpl_toolkits.mplot3d.art3d import Line3DCollection + except ImportError: + print( + "Warning: 3D rendering requested but mplot3d not available. Falling back to 2D." + ) + render_3d = False + + if agent_positions is None: + return None + + # Determine shape format and extract appropriate data + if len(agent_positions.shape) == 5: # [env, rollouts, agent, time, 2] + # New format with environment dimension first + if env_idx >= agent_positions.shape[0]: + print( + f"Warning: env_idx {env_idx} out of range. Using env_idx=0" + ) + env_idx = 0 + + # Extract the specific environment data + positions_to_plot = agent_positions[ + env_idx + ] # Shape: [rollouts, agent, time, 2] + n_rollouts, n_agents, n_steps, _ = positions_to_plot.shape + + elif len(agent_positions.shape) == 4: # [rollouts, agent, time, 2] + # Legacy format without environment dimension + positions_to_plot = agent_positions + n_rollouts, n_agents, n_steps, _ = positions_to_plot.shape + print("Warning: Using legacy format without environment dimension") + else: + raise ValueError( + f"Unexpected shape for agent_positions: {agent_positions.shape}" + ) + + # Set defaults for multiple rollouts mode + line_color = line_color or "#1f77b4" # Default blue + line_alpha = 0.3 if line_alpha is None else line_alpha + line_width = 1 if line_width is None else line_width + + # If time_step is not provided, use all timesteps + if time_step is None: + time_step = n_steps + + # If controlled_live is not provided, assume all agents are active + if controlled_live is None: + controlled_live = [True] * n_agents + + # Setup for weight-based coloring + if weights is not None: + weight_values = np.array( + weights + ) # Use absolute values for coloring + + # Set up a colormap for weights + weight_cmap = plt.cm.coolwarm + weight_norm = plt.Normalize( + vmin=weight_values.min().item(), + vmax=weight_values.max().item(), + ) + weight_sm = plt.cm.ScalarMappable( + cmap=weight_cmap, norm=weight_norm + ) + + # Process each rollout and each agent + for rollout_idx in range(n_rollouts): + for agent_idx in range(n_agents): + if not controlled_live[agent_idx]: + continue + + # Get trajectory for this rollout and agent + trajectory = positions_to_plot[ + rollout_idx, agent_idx, :time_step, : + ] + + # Create valid mask + valid_mask = ( + (trajectory[:, 0] != 0) + & (trajectory[:, 1] != 0) + & (torch.abs(trajectory[:, 0]) < OUT_OF_BOUNDS) + & (torch.abs(trajectory[:, 1]) < OUT_OF_BOUNDS) + ) + + # Get valid trajectory points + valid_trajectory = trajectory[valid_mask] + + # Only proceed if we have at least 2 points + if len(valid_trajectory) > 1: + points = valid_trajectory.cpu().numpy() + + # Determine color based on weights or fixed color + if weights is not None: + # Use the weight value for this rollout + weight_value = weight_values[rollout_idx].item() + segment_color = weight_cmap(weight_norm(weight_value)) + else: + segment_color = line_color + + if render_3d: + trajectory_height = 0.05 + segments_3d = [] + for i in range(len(points) - 1): + segment = np.array( + [ + [ + points[i][0], + points[i][1], + trajectory_height, + ], + [ + points[i + 1][0], + points[i + 1][1], + trajectory_height, + ], + ] + ) + segments_3d.append(segment) + + # Create line collection for 3D + lc = Line3DCollection( + segments_3d, + colors=segment_color, + linewidths=line_width, + alpha=line_alpha, + zorder=1, + ) + ax.add_collection3d(lc) + else: + segments = [] + for i in range(len(points) - 1): + segment = np.array( + [ + [points[i][0], points[i][1]], + [points[i + 1][0], points[i + 1][1]], + ] + ) + segments.append(segment) + + # Create line collection for 2D + lc = LineCollection( + segments, + colors=segment_color, + linewidths=line_width, + alpha=line_alpha, + zorder=1, + ) + ax.add_collection(lc) + + # Add colorbar for weight-based coloring - outside the loops + if weights is not None and colorbar: + try: + fig = ax.get_figure() + # Create horizontal colorbar at the bottom + # Parameters: [left, bottom, width, height] + cbar_ax = fig.add_axes([0.15, 0.05, 0.7, 0.03]) + cbar = fig.colorbar( + weight_sm, cax=cbar_ax, orientation="horizontal" + ) + cbar.set_label( + f"Conditioning param value", fontsize=15 * marker_scale + ) + cbar.ax.tick_params(labelsize=12 * marker_scale) + except Exception as e: + print(f"Warning: Could not add colorbar: {e}") + + return weight_sm + + return None + def _plot_log_replay_trajectory( self, ax: matplotlib.axes.Axes, @@ -972,7 +1114,9 @@ def _plot_filtered_agent_bounding_boxes( line_width_scale: int = 1.0, marker_size_scale: int = 1.0, extended_goals: Optional[Dict[str, torch.Tensor]] = None, - world_based_policy_mask : Optional[Dict[int,Dict[str,torch.Tensor]]] = None, + world_based_policy_mask: Optional[ + Dict[int, Dict[str, torch.Tensor]] + ] = None, ) -> None: """Plots bounding boxes for agents filtered by environment index and mask. @@ -1074,8 +1218,7 @@ def plot_agent_group_3d( zorder=5, ) - - def plot_agent_group_2d(bboxes, color,by_policy = False): + def plot_agent_group_2d(bboxes, color, by_policy=False): """Helper function to plot a group of agents in 2D""" if not by_policy: utils.plot_numpy_bounding_boxes( @@ -1089,15 +1232,16 @@ def plot_agent_group_2d(bboxes, color,by_policy = False): ) else: num_policies = len(bboxes) - utils.plot_numpy_bounding_boxes_multiple_policy( - ax=ax, - bboxes_s=bboxes, - colors=color[:num_policies], - alpha=alpha, - line_width_scale=line_width_scale, - as_center_pts=as_center_pts, - label=label, - ) + utils.plot_numpy_bounding_boxes_multiple_policy( + ax=ax, + bboxes_s=bboxes, + colors=color[:num_policies], + alpha=alpha, + line_width_scale=line_width_scale, + as_center_pts=as_center_pts, + label=label, + ) + # Off-road agents bboxes_controlled_offroad = np.stack( ( @@ -1209,7 +1353,7 @@ def plot_agent_group_2d(bboxes, color,by_policy = False): axis=1, ) - if not world_based_policy_mask: ## controlled by the same policy + if not world_based_policy_mask: ## controlled by the same policy # Living agents bboxes_controlled_ok = np.stack( ( @@ -1233,7 +1377,7 @@ def plot_agent_group_2d(bboxes, color,by_policy = False): else: bboxes_controlled_ok = [] policy_mask = world_based_policy_mask[env_idx] - for policy_name,mask in policy_mask.items(): + for policy_name, mask in policy_mask.items(): bboxes = np.stack( ( @@ -1244,11 +1388,11 @@ def plot_agent_group_2d(bboxes, color,by_policy = False): agent_states.rotation_angle[env_idx, mask].numpy(), ), axis=1, - ) + ) bboxes_controlled_ok.append(bboxes) plot_agent_group_2d( - bboxes_controlled_ok, AGENT_COLOR_BY_POLICY,by_policy=True + bboxes_controlled_ok, AGENT_COLOR_BY_POLICY, by_policy=True ) # Plot log replay agents log_replay = ( @@ -1345,7 +1489,7 @@ def plot_agent_observation( figsize: Tuple[int, int] = (10, 10), ): """ - Plot observation from agent POV to inspect the information available + Plot observation from agent POV to inspect the information available to the agent. Args: agent_idx (int): Index of the agent whose observation is to be plotted. From e993164d736788960b128f7110f0aa8f1e9a567f Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 20 Mar 2025 17:11:19 -0400 Subject: [PATCH 03/81] Make human-replay agents slightly darker --- gpudrive/visualize/color.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/gpudrive/visualize/color.py b/gpudrive/visualize/color.py index e249dadf8..4cf250dec 100644 --- a/gpudrive/visualize/color.py +++ b/gpudrive/visualize/color.py @@ -27,7 +27,7 @@ "ok": "#4B77BE", # Controlled and doing fine "collided": "r", # Controlled and collided "off_road": "orange", # Controlled and off-road - "log_replay": "#c7c7c7", # Agents marked as expert controlled or static + "log_replay": "#787878", # Agents marked as expert controlled or static } REL_OBS_OBJ_COLORS = { @@ -35,4 +35,4 @@ "ego_goal": "#0099cc", "other_agents": "#ff884d", } -AGENT_COLOR_BY_POLICY= ['g','b','p'] \ No newline at end of file +AGENT_COLOR_BY_POLICY = ["g", "b", "p"] From 180649854232faa8c9e4d46243973ea17e59f5ca Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 20 Mar 2025 18:24:33 -0400 Subject: [PATCH 04/81] Add option for storing behavioral metrics --- gpudrive/utils/rollout.py | 89 +++++++++++++++++++++++++++++++++++---- 1 file changed, 81 insertions(+), 8 deletions(-) diff --git a/gpudrive/utils/rollout.py b/gpudrive/utils/rollout.py index f36c1c6e5..be2bc5e27 100644 --- a/gpudrive/utils/rollout.py +++ b/gpudrive/utils/rollout.py @@ -12,7 +12,6 @@ from gpudrive.visualize.utils import img_from_fig from gpudrive.datatypes.observation import GlobalEgoState - def rollout( env, policy, @@ -20,11 +19,12 @@ def rollout( deterministic: bool = False, render_sim_state: bool = False, render_every_n_steps: int = 1, - zoom_radius: int = 100, return_agent_positions: bool = False, - center_on_ego: bool = False, + return_behavior_metrics: bool = False, set_agent_type: bool = False, agent_weights: torch.Tensor = None, + center_on_ego: bool = False, + zoom_radius: int = 100, ): """ Perform a rollout of a policy in the environment. @@ -38,13 +38,14 @@ def rollout( render_every_n_steps (int): Render every N steps. zoom_radius (int): Radius for zoom in visualization. return_agent_positions (bool): Whether to return agent positions. + return_behavior_metrics (bool): Whether to collect behavioral metrics. center_on_ego (bool): Whether to center visualization on ego vehicle. set_agent_type (bool): Whether to set agent type during reset. agent_weights (torch.Tensor): Agent weights tensor for condition_mode="fixed". Returns: tuple: Averages for goal achieved, collisions, off-road occurrences, - controlled agents count, and simulation state frames. + controlled agents count, simulation state frames, and (if requested) behavioral metrics. """ # Initialize storage sim_state_frames = {env_id: [] for env_id in range(env.num_worlds)} @@ -55,6 +56,14 @@ def rollout( (env.num_worlds, env.max_agent_count, episode_len, 2) ) + # Initialize behavioral metrics storage if requested + if return_behavior_metrics: + situation_responses = {} + entropy_values = torch.zeros((num_worlds, max_agent_count, episode_len), device=device) + logprob_values = torch.zeros((num_worlds, max_agent_count, episode_len), device=device) + else: + situation_responses, entropy_values, logprob_values = None, None, None + # Reset episode if set_agent_type and agent_weights is not None: # Pass agent_weights to reset when set_agent_type is True @@ -73,10 +82,9 @@ def rollout( live_agent_mask = control_mask.clone() for time_step in range(episode_len): - # Get actions for active agents if live_agent_mask.any(): - action, _, _, _ = policy( + action, logprob, entropy, value = policy( next_obs[live_agent_mask], deterministic=deterministic ) @@ -86,12 +94,64 @@ def rollout( ) action_template[live_agent_mask] = action.to(device) + # Store policy outputs if requested + if return_behavior_metrics and live_agent_mask.any(): + # Check if entropy and logprob are scalar or vector + is_scalar_entropy = entropy.dim() == 0 + is_scalar_logprob = logprob.dim() == 0 + + # For each agent, store responses and metrics + for world_idx in range(num_worlds): + for agent_idx in range(max_agent_count): + if live_agent_mask[world_idx, agent_idx]: + # Store entropy and logprob values + # If they're scalars, we'll use them directly + # If they're vectors, we need to match them with the right agent + # We'll use a simple counter to track position in the flat action tensor + + # Calculate position in the flattened tensor if needed + mask_before = live_agent_mask[:world_idx].sum() + live_agent_mask[world_idx, :agent_idx].sum() + position = mask_before.item() + + # Store entropy (either scalar value or indexed) + if is_scalar_entropy: + entropy_values[world_idx, agent_idx, time_step] = entropy.item() + current_entropy = entropy.item() + else: + entropy_values[world_idx, agent_idx, time_step] = entropy[position].item() + current_entropy = entropy[position].item() + + # Store logprob (either scalar value or indexed) + if is_scalar_logprob: + logprob_values[world_idx, agent_idx, time_step] = logprob.item() + current_logprob = logprob.item() + else: + logprob_values[world_idx, agent_idx, time_step] = logprob[position].item() + current_logprob = logprob[position].item() + + # Create a simple hash of observation to identify similar situations + obs_flat = next_obs[world_idx, agent_idx].cpu().flatten() + # Use first N elements as a simple way to create situation identifier + situation_key = tuple(obs_flat[:20].numpy().tolist()) + + if situation_key not in situation_responses: + situation_responses[situation_key] = [] + + # Store the action as an item (not a tensor) to avoid issues + situation_responses[situation_key].append({ + 'world_idx': world_idx, + 'agent_idx': agent_idx, + 'action': action_template[world_idx, agent_idx].item(), + 'entropy': current_entropy, + 'logprob': current_logprob, + 'time_step': time_step + }) + # Step the environment env.step_dynamics(action_template) # Render if render_sim_state and len(active_worlds) > 0: - has_live_agent = torch.where( live_agent_mask[active_worlds, :].sum(axis=1) > 0 )[0].tolist() @@ -179,7 +239,8 @@ def rollout( not_goal_nor_crash_count / controlled_per_scene ) - return ( + # Prepare return values + base_metrics = ( goal_achieved_count, frac_goal_achieved, collided_count, @@ -193,6 +254,18 @@ def rollout( agent_positions, episode_lengths, ) + + # Return behavioral metrics if requested + if return_behavior_metrics: + behavior_metrics = { + 'situation_responses': situation_responses, + 'entropy_values': entropy_values, + 'logprob_values': logprob_values + } + return base_metrics + (behavior_metrics,) + + return base_metrics + def multi_policy_rollout( From 0c00526c285d764310feadc0d66f6c25286f27ad Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 20 Mar 2025 18:43:49 -0400 Subject: [PATCH 05/81] WIP --- baselines/ppo/config/ppo_base_puffer.yaml | 33 ++- .../notebooks/04_reward_cond_agents.ipynb | 279 +++++++++++++++--- gpudrive/utils/rollout.py | 85 ++++-- src/consts.hpp | 2 +- 4 files changed, 313 insertions(+), 86 deletions(-) diff --git a/baselines/ppo/config/ppo_base_puffer.yaml b/baselines/ppo/config/ppo_base_puffer.yaml index 438a0c699..08387e3bc 100644 --- a/baselines/ppo/config/ppo_base_puffer.yaml +++ b/baselines/ppo/config/ppo_base_puffer.yaml @@ -8,19 +8,31 @@ model_cpt: null environment: # Overrides default environment configs (see pygpudrive/env/config.py) name: "gpudrive" - num_worlds: 100 # Number of parallel environments - k_unique_scenes: 100 # Number of unique scenes to sample from + num_worlds: 75 # Number of parallel environments + k_unique_scenes: 75 # Number of unique scenes to sample from max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp ego_state: true road_map_obs: true partner_obs: true norm_obs: true - remove_non_vehicles: true # If false, all agents are included (vehicles, pedestrians, cyclists) + remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists) lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types - reward_type: "weighted_combination" + reward_type: "reward_conditioned" #"weighted_combination" + + # If reward_type is "weighted_combination", the following weights are used collision_weight: -0.75 off_road_weight: -0.75 goal_achieved_weight: 1.0 + + # If reward_type is "reward_conditioned", the following parameters are used + condition_mode: random + collision_weight_lb: -3.0 + collision_weight_ub: 0.5 + goal_achieved_weight_lb: 1.0 + goal_achieved_weight_ub: 3.0 + off_road_weight_lb: -3.0 + off_road_weight_ub: 0.0 + dynamics_model: "classic" collision_behavior: "ignore" # Options: "remove", "stop", "ignore" dist_to_goal_threshold: 2.0 @@ -29,10 +41,11 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. obs_radius: 50.0 # Visibility radius of the agents action_space_steer_disc: 13 action_space_accel_disc: 7 + wandb: entity: "" - project: "gpudrive" - group: "test" + project: "kshotagents" + group: "reward_conditioned" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] @@ -46,7 +59,7 @@ train: compile_mode: "reduce-overhead" # # # Data sampling # # # - resample_scenes: false + resample_scenes: true resample_dataset_size: 10_000 # Number of unique scenes to sample from resample_interval: 2_000_000 sample_with_replacement: true @@ -54,8 +67,8 @@ train: # # # PPO # # # torch_deterministic: false - total_timesteps: 1_000_000_000 - batch_size: 262_144 + total_timesteps: 2_000_000_000 + batch_size: 131_072 minibatch_size: 8192 learning_rate: 3e-4 anneal_lr: false @@ -81,7 +94,7 @@ train: num_parameters: 0 # Total trainable parameters, to be filled at runtime # # # Checkpointing # # # - checkpoint_interval: 400 # Save policy every k iterations + checkpoint_interval: 500 # Save policy every k iterations checkpoint_path: "./runs" # # # Rendering # # # diff --git a/examples/experimental/notebooks/04_reward_cond_agents.ipynb b/examples/experimental/notebooks/04_reward_cond_agents.ipynb index ffbf301fe..4bf60f78d 100644 --- a/examples/experimental/notebooks/04_reward_cond_agents.ipynb +++ b/examples/experimental/notebooks/04_reward_cond_agents.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -15,6 +15,10 @@ "import matplotlib.pyplot as plt\n", "from collections import defaultdict\n", "import random\n", + "import torch\n", + "import random\n", + "import numpy as np\n", + "import pandas as pd\n", "\n", "from gpudrive.env.config import EnvConfig\n", "from gpudrive.env.env_torch import GPUDriveTorchEnv\n", @@ -29,14 +33,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'mode': 'train', 'use_rnn': False, 'eval_model_path': None, 'baseline': False, 'data_dir': 'data/processed/training', 'continue_training': False, 'model_cpt': None, 'environment': {'name': 'gpudrive', 'num_worlds': 75, 'k_unique_scenes': 75, 'max_controlled_agents': 64, 'ego_state': True, 'road_map_obs': True, 'partner_obs': True, 'norm_obs': True, 'remove_non_vehicles': False, 'lidar_obs': False, 'reward_type': 'reward_conditioned', 'collision_weight': -0.75, 'off_road_weight': -0.75, 'goal_achieved_weight': 1.0, 'dynamics_model': 'classic', 'collision_behavior': 'ignore', 'dist_to_goal_threshold': 2.0, 'polyline_reduction_threshold': 0.1, 'sampling_seed': 42, 'obs_radius': 50.0, 'action_space_steer_disc': 13, 'action_space_accel_disc': 7}, 'wandb': {'entity': '', 'project': 'kshotagents', 'group': 'reward_conditioned', 'mode': 'online', 'tags': ['ppo', 'ff']}, 'train': {'exp_id': 'PPO', 'seed': 42, 'cpu_offload': False, 'device': 'cuda', 'bptt_horizon': 1, 'compile': False, 'compile_mode': 'reduce-overhead', 'resample_scenes': True, 'resample_dataset_size': 10000, 'resample_interval': 2000000, 'sample_with_replacement': True, 'shuffle_dataset': False, 'torch_deterministic': False, 'total_timesteps': 2000000000, 'batch_size': 131072, 'minibatch_size': 8192, 'learning_rate': '3e-4', 'anneal_lr': False, 'gamma': 0.99, 'gae_lambda': 0.95, 'update_epochs': 4, 'norm_adv': True, 'clip_coef': 0.2, 'clip_vloss': False, 'vf_clip_coef': 0.2, 'ent_coef': 0.0001, 'vf_coef': 0.3, 'max_grad_norm': 0.5, 'target_kl': None, 'log_window': 1000, 'network': {'input_dim': 64, 'hidden_dim': 128, 'dropout': 0.01, 'class_name': 'NeuralNet', 'num_parameters': 0}, 'checkpoint_interval': 400, 'checkpoint_path': './runs', 'render': False, 'render_3d': True, 'render_interval': 1, 'render_k_scenarios': 10, 'render_format': 'mp4', 'render_fps': 15, 'zoom_radius': 50}, 'vec': {'backend': 'native', 'num_workers': 1, 'env_batch_size': 1, 'zero_copy': False}}\n" + "{'mode': 'train', 'use_rnn': False, 'eval_model_path': None, 'baseline': False, 'data_dir': 'data/processed/training', 'continue_training': False, 'model_cpt': None, 'environment': {'name': 'gpudrive', 'num_worlds': 75, 'k_unique_scenes': 75, 'max_controlled_agents': 64, 'ego_state': True, 'road_map_obs': True, 'partner_obs': True, 'norm_obs': True, 'remove_non_vehicles': False, 'lidar_obs': False, 'reward_type': 'reward_conditioned', 'collision_weight': -0.75, 'off_road_weight': -0.75, 'goal_achieved_weight': 1.0, 'condition_mode': 'random', 'collision_weight_lb': -3.0, 'collision_weight_ub': 0.5, 'goal_achieved_weight_lb': 1.0, 'goal_achieved_weight_ub': 3.0, 'off_road_weight_lb': -3.0, 'off_road_weight_ub': 0.0, 'dynamics_model': 'classic', 'collision_behavior': 'ignore', 'dist_to_goal_threshold': 2.0, 'polyline_reduction_threshold': 0.1, 'sampling_seed': 42, 'obs_radius': 50.0, 'action_space_steer_disc': 13, 'action_space_accel_disc': 7}, 'wandb': {'entity': '', 'project': 'kshotagents', 'group': 'reward_conditioned', 'mode': 'online', 'tags': ['ppo', 'ff']}, 'train': {'exp_id': 'PPO', 'seed': 42, 'cpu_offload': False, 'device': 'cuda', 'bptt_horizon': 1, 'compile': False, 'compile_mode': 'reduce-overhead', 'resample_scenes': True, 'resample_dataset_size': 10000, 'resample_interval': 2000000, 'sample_with_replacement': True, 'shuffle_dataset': False, 'torch_deterministic': False, 'total_timesteps': 2000000000, 'batch_size': 131072, 'minibatch_size': 8192, 'learning_rate': '3e-4', 'anneal_lr': False, 'gamma': 0.99, 'gae_lambda': 0.95, 'update_epochs': 4, 'norm_adv': True, 'clip_coef': 0.2, 'clip_vloss': False, 'vf_clip_coef': 0.2, 'ent_coef': 0.0001, 'vf_coef': 0.3, 'max_grad_norm': 0.5, 'target_kl': None, 'log_window': 1000, 'network': {'input_dim': 64, 'hidden_dim': 128, 'dropout': 0.01, 'class_name': 'NeuralNet', 'num_parameters': 0}, 'checkpoint_interval': 500, 'checkpoint_path': './runs', 'render': False, 'render_3d': True, 'render_interval': 1, 'render_k_scenarios': 10, 'render_format': 'mp4', 'render_fps': 15, 'zoom_radius': 50}, 'vec': {'backend': 'native', 'num_workers': 1, 'env_batch_size': 1, 'zero_copy': False}}\n" ] } ], @@ -57,7 +61,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -79,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -126,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -144,9 +148,6 @@ " Returns:\n", " all_trajectories: Dictionary containing trajectories and weights\n", " \"\"\"\n", - " import torch\n", - " import random\n", - " import numpy as np\n", " \n", " # Get environment info to determine dimensions\n", " obs = env.reset(agent_type=torch.Tensor([0.0, 0.0, 0.0]))\n", @@ -230,7 +231,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -238,45 +239,45 @@ "output_type": "stream", "text": [ "Running rollout 1/20\n", - "Using weights: tensor([-0.7195, 1.0000, -3.0000])\n", + "Using weights: tensor([-1.6067, 1.0000, -3.0000])\n", "Running rollout 2/20\n", - "Using weights: tensor([-1.5693, 1.0000, -3.0000])\n", + "Using weights: tensor([-0.4170, 1.0000, -3.0000])\n", "Running rollout 3/20\n", - "Using weights: tensor([-0.4519, 1.0000, -3.0000])\n", + "Using weights: tensor([-2.7621, 1.0000, -3.0000])\n", "Running rollout 4/20\n", - "Using weights: tensor([-1.6423, 1.0000, -3.0000])\n", + "Using weights: tensor([-0.1729, 1.0000, -3.0000])\n", "Running rollout 5/20\n", - "Using weights: tensor([-0.9070, 1.0000, -3.0000])\n", + "Using weights: tensor([-1.8213, 1.0000, -3.0000])\n", "Running rollout 6/20\n", - "Using weights: tensor([ 0.8978, 1.0000, -3.0000])\n", + "Using weights: tensor([-2.4634, 1.0000, -3.0000])\n", "Running rollout 7/20\n", - "Using weights: tensor([-0.3654, 1.0000, -3.0000])\n", + "Using weights: tensor([-0.8697, 1.0000, -3.0000])\n", "Running rollout 8/20\n", - "Using weights: tensor([-2.8612, 1.0000, -3.0000])\n", + "Using weights: tensor([-1.1699, 1.0000, -3.0000])\n", "Running rollout 9/20\n", - "Using weights: tensor([-1.7468, 1.0000, -3.0000])\n", + "Using weights: tensor([-2.5592, 1.0000, -3.0000])\n", "Running rollout 10/20\n", - "Using weights: tensor([-2.3545, 1.0000, -3.0000])\n", + "Using weights: tensor([ 0.8334, 1.0000, -3.0000])\n", "Running rollout 11/20\n", - "Using weights: tensor([-2.1445, 1.0000, -3.0000])\n", + "Using weights: tensor([-0.6398, 1.0000, -3.0000])\n", "Running rollout 12/20\n", - "Using weights: tensor([ 0.9851, 1.0000, -3.0000])\n", + "Using weights: tensor([ 0.2693, 1.0000, -3.0000])\n", "Running rollout 13/20\n", - "Using weights: tensor([-0.1805, 1.0000, -3.0000])\n", + "Using weights: tensor([ 0.7411, 1.0000, -3.0000])\n", "Running rollout 14/20\n", - "Using weights: tensor([ 0.2572, 1.0000, -3.0000])\n", + "Using weights: tensor([-0.5354, 1.0000, -3.0000])\n", "Running rollout 15/20\n", - "Using weights: tensor([-2.2591, 1.0000, -3.0000])\n", + "Using weights: tensor([-2.0566, 1.0000, -3.0000])\n", "Running rollout 16/20\n", - "Using weights: tensor([-0.6897, 1.0000, -3.0000])\n", + "Using weights: tensor([-0.8910, 1.0000, -3.0000])\n", "Running rollout 17/20\n", - "Using weights: tensor([-0.5889, 1.0000, -3.0000])\n", + "Using weights: tensor([ 0.9948, 1.0000, -3.0000])\n", "Running rollout 18/20\n", - "Using weights: tensor([-0.6967, 1.0000, -3.0000])\n", + "Using weights: tensor([-2.7536, 1.0000, -3.0000])\n", "Running rollout 19/20\n", - "Using weights: tensor([-1.2825, 1.0000, -3.0000])\n", + "Using weights: tensor([-0.5967, 1.0000, -3.0000])\n", "Running rollout 20/20\n", - "Using weights: tensor([-1.3794, 1.0000, -3.0000])\n" + "Using weights: tensor([-0.0391, 1.0000, -3.0000])\n" ] } ], @@ -291,7 +292,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -300,7 +301,7 @@ "torch.Size([5, 20, 64, 91, 2])" ] }, - "execution_count": 46, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -311,18 +312,18 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([-0.7195, -1.5693, -0.4519, -1.6423, -0.9070, 0.8978, -0.3654, -2.8612,\n", - " -1.7468, -2.3545, -2.1445, 0.9851, -0.1805, 0.2572, -2.2591, -0.6897,\n", - " -0.5889, -0.6967, -1.2825, -1.3794])" + "tensor([-1.6067, -0.4170, -2.7621, -0.1729, -1.8213, -2.4634, -0.8697, -1.1699,\n", + " -2.5592, 0.8334, -0.6398, 0.2693, 0.7411, -0.5354, -2.0566, -0.8910,\n", + " 0.9948, -2.7536, -0.5967, -0.0391])" ] }, - "execution_count": 47, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -340,18 +341,26 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 9, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/emerge/gpudrive/gpudrive/visualize/core.py:376: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + " fig.tight_layout(pad=2, rect=[0.00, 0.00, 0.9, 1])\n" + ] + }, { "data": { - "image/jpeg": "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", - "image/png": "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", + "image/jpeg": "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", + "image/png": "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", "text/plain": [ "" ] }, - "execution_count": 48, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -362,10 +371,10 @@ "# Plot simulator state with the stacked trajectories\n", "_ = env.reset(agent_type=torch.Tensor([-0.2, 1.0, -0.2]))\n", "img = env.vis.plot_simulator_state(\n", - " env_indices=[2], \n", + " env_indices=[4], \n", " agent_positions=trajs['agent_positions'], # Pass stacked trajectories directly\n", " zoom_radius=100,\n", - " multiple_rollouts=True, \n", + " multiple_rollouts=True,\n", " line_alpha=0.5, \n", " line_width=1.0, \n", " weights=trajs['collision_weights'], \n", @@ -384,7 +393,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -403,6 +412,188 @@ "print(f\"Figure saved as {filename}\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Analyze diversity" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def collect_rollout_data(env, policy, agent_weights, device, num_rollouts=5):\n", + " \"\"\"\n", + " Collect behavioral data from multiple rollouts for a specific agent type.\n", + " \n", + " Args:\n", + " env: The simulation environment\n", + " policy: The policy to be rolled out\n", + " agent_weights: Agent weight tensor for this agent type\n", + " device: Device to run computations on\n", + " num_rollouts: Number of rollouts to perform\n", + " \n", + " Returns:\n", + " dict: Collected behavioral data from all rollouts\n", + " \"\"\"\n", + " # Initialize data collection\n", + " all_situation_responses = {}\n", + " \n", + " # Perform multiple rollouts\n", + " for rollout_idx in range(num_rollouts):\n", + " print(f\" Rollout {rollout_idx+1}/{num_rollouts}\")\n", + " \n", + " # Run rollout with behavior metrics collection\n", + " rollout_results = rollout(\n", + " env=env,\n", + " policy=policy,\n", + " device=device,\n", + " deterministic=False,\n", + " render_sim_state=False,\n", + " return_agent_positions=False,\n", + " return_behavior_metrics=True,\n", + " set_agent_type=True,\n", + " agent_weights=agent_weights\n", + " )\n", + " \n", + " # Extract behavior metrics (last element of returned tuple)\n", + " behavior_metrics = rollout_results[-1]\n", + " \n", + " # Merge situation responses\n", + " for sit_key, responses in behavior_metrics['situation_responses'].items():\n", + " if sit_key not in all_situation_responses:\n", + " all_situation_responses[sit_key] = []\n", + " all_situation_responses[sit_key].extend(responses)\n", + " \n", + " return {\n", + " 'situation_responses': all_situation_responses,\n", + " 'entropy_values': behavior_metrics['entropy_values'],\n", + " 'logprob_values': behavior_metrics['logprob_values']\n", + " }\n", + "\n", + "\n", + "def store_data_to_dataframe(agent_types, collected_data):\n", + " \"\"\"\n", + " Store collected agent behavioral data in a pandas DataFrame.\n", + " \n", + " Args:\n", + " agent_types: List of agent types/names\n", + " collected_data: Dictionary mapping agent types to their behavioral data\n", + " \n", + " Returns:\n", + " pd.DataFrame: DataFrame containing all the behavioral data\n", + " \"\"\"\n", + " # Create lists to store the flattened data\n", + " rows = []\n", + " \n", + " # Process each agent type's data\n", + " for agent_idx, agent_type in enumerate(agent_types):\n", + " agent_data = collected_data[agent_type]\n", + " \n", + " # Process situation responses\n", + " for sit_key, responses in agent_data['situation_responses'].items():\n", + " for response in responses:\n", + " # Create a row for this response\n", + " row = {\n", + " 'agent_type': agent_type,\n", + " 'agent_idx': agent_idx,\n", + " 'world_idx': response['world_idx'],\n", + " 'agent_id': response['agent_idx'],\n", + " 'situation_key': hash(sit_key), # Use hash as pandas doesn't handle tuples well\n", + " 'action': response['action'],\n", + " 'entropy': response['entropy'] if 'entropy' in response else None,\n", + " 'logprob': response['logprob'] if 'logprob' in response else None,\n", + " 'time_step': response['time_step']\n", + " }\n", + " rows.append(row)\n", + " \n", + " # Convert to DataFrame\n", + " df = pd.DataFrame(rows)\n", + " \n", + " # Print some basic statistics\n", + " print(f\"\\nDataFrame created with {len(df)} rows\")\n", + " print(f\"Number of unique situations: {df['situation_key'].nunique()}\")\n", + " print(f\"Number of unique agent types: {df['agent_type'].nunique()}\")\n", + " \n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting rollout data...\n", + " Rollout 1/2\n", + " Rollout 2/2\n" + ] + } + ], + "source": [ + "agent_configs = {\n", + " 'Nominal': torch.tensor([-0.5, 0.1, -0.5], device=device),\n", + "}\n", + "\n", + "print(\"Collecting rollout data...\")\n", + "collected_data = {}\n", + "\n", + "agent_weights = torch.Tensor([-0.2, 1.0, -0.2])\n", + "\n", + "\n", + "div_metrics = collect_rollout_data(\n", + " env, agent, agent_weights, device, 2\n", + ")\n", + "\n", + "#df = store_data_to_dataframe(list(agent_configs.keys()), collected_data)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['situation_responses', 'entropy_values', 'logprob_values'])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "div_metrics.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([5, 64, 91])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "div_metrics['entropy_values'].shape" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/gpudrive/utils/rollout.py b/gpudrive/utils/rollout.py index be2bc5e27..0e4e446fc 100644 --- a/gpudrive/utils/rollout.py +++ b/gpudrive/utils/rollout.py @@ -12,6 +12,7 @@ from gpudrive.visualize.utils import img_from_fig from gpudrive.datatypes.observation import GlobalEgoState + def rollout( env, policy, @@ -59,8 +60,12 @@ def rollout( # Initialize behavioral metrics storage if requested if return_behavior_metrics: situation_responses = {} - entropy_values = torch.zeros((num_worlds, max_agent_count, episode_len), device=device) - logprob_values = torch.zeros((num_worlds, max_agent_count, episode_len), device=device) + entropy_values = torch.zeros( + (num_worlds, max_agent_count, episode_len), device=device + ) + logprob_values = torch.zeros( + (num_worlds, max_agent_count, episode_len), device=device + ) else: situation_responses, entropy_values, logprob_values = None, None, None @@ -99,7 +104,7 @@ def rollout( # Check if entropy and logprob are scalar or vector is_scalar_entropy = entropy.dim() == 0 is_scalar_logprob = logprob.dim() == 0 - + # For each agent, store responses and metrics for world_idx in range(num_worlds): for agent_idx in range(max_agent_count): @@ -108,44 +113,63 @@ def rollout( # If they're scalars, we'll use them directly # If they're vectors, we need to match them with the right agent # We'll use a simple counter to track position in the flat action tensor - + # Calculate position in the flattened tensor if needed - mask_before = live_agent_mask[:world_idx].sum() + live_agent_mask[world_idx, :agent_idx].sum() + mask_before = ( + live_agent_mask[:world_idx].sum() + + live_agent_mask[world_idx, :agent_idx].sum() + ) position = mask_before.item() - + # Store entropy (either scalar value or indexed) if is_scalar_entropy: - entropy_values[world_idx, agent_idx, time_step] = entropy.item() + entropy_values[ + world_idx, agent_idx, time_step + ] = entropy.item() current_entropy = entropy.item() else: - entropy_values[world_idx, agent_idx, time_step] = entropy[position].item() + entropy_values[ + world_idx, agent_idx, time_step + ] = entropy[position].item() current_entropy = entropy[position].item() - + # Store logprob (either scalar value or indexed) if is_scalar_logprob: - logprob_values[world_idx, agent_idx, time_step] = logprob.item() + logprob_values[ + world_idx, agent_idx, time_step + ] = logprob.item() current_logprob = logprob.item() else: - logprob_values[world_idx, agent_idx, time_step] = logprob[position].item() + logprob_values[ + world_idx, agent_idx, time_step + ] = logprob[position].item() current_logprob = logprob[position].item() - + # Create a simple hash of observation to identify similar situations - obs_flat = next_obs[world_idx, agent_idx].cpu().flatten() - # Use first N elements as a simple way to create situation identifier - situation_key = tuple(obs_flat[:20].numpy().tolist()) - + obs_flat = ( + next_obs[world_idx, agent_idx].cpu().flatten() + ) + # Use first N elements as a simple way to create situation identifier + situation_key = tuple( + obs_flat[:20].numpy().tolist() + ) + if situation_key not in situation_responses: situation_responses[situation_key] = [] - + # Store the action as an item (not a tensor) to avoid issues - situation_responses[situation_key].append({ - 'world_idx': world_idx, - 'agent_idx': agent_idx, - 'action': action_template[world_idx, agent_idx].item(), - 'entropy': current_entropy, - 'logprob': current_logprob, - 'time_step': time_step - }) + situation_responses[situation_key].append( + { + "world_idx": world_idx, + "agent_idx": agent_idx, + "action": action_template[ + world_idx, agent_idx + ].item(), + "entropy": current_entropy, + "logprob": current_logprob, + "time_step": time_step, + } + ) # Step the environment env.step_dynamics(action_template) @@ -254,18 +278,17 @@ def rollout( agent_positions, episode_lengths, ) - + # Return behavioral metrics if requested if return_behavior_metrics: behavior_metrics = { - 'situation_responses': situation_responses, - 'entropy_values': entropy_values, - 'logprob_values': logprob_values + "situation_responses": situation_responses, + "entropy_values": entropy_values, + "logprob_values": logprob_values, } return base_metrics + (behavior_metrics,) - - return base_metrics + return base_metrics def multi_policy_rollout( diff --git a/src/consts.hpp b/src/consts.hpp index 93539eed9..8b41ac77d 100644 --- a/src/consts.hpp +++ b/src/consts.hpp @@ -22,7 +22,7 @@ inline constexpr float worldLength = 40.f; // This factor rescales the length of the vehicles by a tiny amount // To account for the fact that noise occasionally puts vehicles into initial // collisions. This is a dataset artifact that we are handling here like this. -inline constexpr float vehicleLengthScale = 0.7f; +inline constexpr float vehicleLengthScale = 0.8f; // Each unit of distance forward (+ y axis) rewards the agents by this amount inline constexpr float rewardPerDist = 0.05f; From 2a08793c11bf46d70f91d7437aeee786d6265097 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 21 Mar 2025 17:09:49 -0400 Subject: [PATCH 06/81] Analyze agent diversity --- examples/experimental/diversity.py | 362 +++++++++++++++++++++++++++++ gpudrive/utils/rollout.py | 96 ++------ 2 files changed, 381 insertions(+), 77 deletions(-) create mode 100644 examples/experimental/diversity.py diff --git a/examples/experimental/diversity.py b/examples/experimental/diversity.py new file mode 100644 index 000000000..02001c195 --- /dev/null +++ b/examples/experimental/diversity.py @@ -0,0 +1,362 @@ +import torch +import dataclasses +import mediapy +from huggingface_hub import PyTorchModelHubMixin +from huggingface_hub import ModelCard +from gpudrive.networks.late_fusion import NeuralNet +import matplotlib.pyplot as plt +from collections import defaultdict +import random +import torch +import random +import numpy as np +import pandas as pd +from tqdm import tqdm + + +from gpudrive.env.config import EnvConfig +from gpudrive.env.env_torch import GPUDriveTorchEnv +from gpudrive.visualize.utils import img_from_fig +from gpudrive.env.dataset import SceneDataLoader +from gpudrive.utils.config import load_config +from gpudrive.utils.checkpoint import load_policy +from gpudrive.utils.rollout import rollout + +from PIL import Image + + +def collect_rollout_for_agent_type(env, agent, agent_type_name, agent_weights, device, num_rollouts=5): + """ + Collect rollout data for a specific agent type. + + Args: + env: The simulation environment + agent: The policy to be rolled out + agent_type_name: Name identifier for this agent type + agent_weights: Tensor of agent weights + device: The device to run on + num_rollouts: Number of rollouts to perform for this agent type + + Returns: + list: List of dictionaries containing rollout data for this agent type + """ + all_data = [] + + # Run multiple rollouts for this agent type + for i in tqdm(range(num_rollouts), desc=f"Agent: {agent_type_name}", unit="rollout"): + # Run the rollout with the specified agent weights + rollout_results = rollout( + env=env, + policy=agent, + device=device, + deterministic=False, + render_sim_state=False, + return_agent_positions=False, + return_behavior_metrics=True, + set_agent_type=True, + agent_weights=agent_weights + ) + + # Extract behavioral metrics from rollout (last element of returned tuple) + behavior_metrics = rollout_results[-1] + + # Store data for this rollout + all_data.append({ + 'agent_type': agent_type_name, + 'rollout_idx': i, + 'weights': agent_weights.cpu().tolist(), + 'entropy': behavior_metrics['entropy'], + 'logprob': behavior_metrics['logprob'], + 'actions': behavior_metrics['actions'] + }) + + return all_data + + +def collect_data_for_agent_types(env, agent, agent_configs, device, num_rollouts_per_agent=5): + """ + Collect rollout data for all agent types in agent_configs. + + Args: + env: The simulation environment + agent: The policy to be rolled out + agent_configs: Dictionary mapping agent type names to their weight tensors + device: The device to run on + num_rollouts_per_agent: Number of rollouts to perform for each agent type + + Returns: + list: Combined list of dictionaries containing rollout data for all agent types + """ + all_agent_data = [] + + # Display overall progress information + print(f"Collecting data for {len(agent_configs)} agent types, {num_rollouts_per_agent} rollouts each") + + # Process each agent type + for agent_type_name, agent_weights in agent_configs.items(): + print(f"\nAgent type: {agent_type_name}, weights: {agent_weights.cpu().tolist()}") + + # Collect data for this agent type + agent_data = collect_rollout_for_agent_type( + env=env, + agent=agent, + agent_type_name=agent_type_name, + agent_weights=agent_weights, + device=device, + num_rollouts=num_rollouts_per_agent + ) + + # Add to combined data + all_agent_data.extend(agent_data) + + print(f"Completed rollouts for all {len(agent_configs)} agent types") + return all_agent_data + + +def create_dataframe_from_rollouts(rollout_data): + """ + Convert rollout data to a pandas DataFrame with the specified columns. + + Args: + rollout_data: List of dictionaries containing rollout results + + Returns: + pd.DataFrame: DataFrame with agent behavior data + """ + rows = [] + + # Process each rollout + for data in rollout_data: + agent_type = data['agent_type'] + rollout_idx = data['rollout_idx'] + weights = data['weights'] + + # Get tensor data + entropy = data['entropy'] # Shape: [num_envs, max_agents, episode_len] + logprob = data['logprob'] # Shape: [num_envs, max_agents, episode_len] + actions = data['actions'] # Shape: [num_envs, max_agents, episode_len, action_dim] + + # Get dimensions + num_envs = actions.shape[0] + max_agents = actions.shape[1] + episode_len = actions.shape[2] + + # Create rows for all non-zero entries + for env_idx in range(num_envs): + for agent_idx in range(max_agents): + for time_step in range(episode_len): + # Skip if no action was taken (all zeros) + action_vec = actions[env_idx, agent_idx, time_step] + if torch.all(action_vec == 0) and entropy[env_idx, agent_idx, time_step] == 0: + continue + + # Add row with specified columns + row = { + 'agent_type': agent_type, + 'scenario': env_idx, + 'agent_idx': agent_idx, # Keep this in case you need it later + 'timestep': time_step, + 'entropy': entropy[env_idx, agent_idx, time_step].item(), + 'acceleration': action_vec[0].item(), + 'steering': action_vec[1].item(), + 'logprob': logprob[env_idx, agent_idx, time_step].item(), + 'rollout_idx': rollout_idx, + 'collision_weight': weights[0], + 'goal_weight': weights[1], + 'off_road_weight': weights[2] + } + rows.append(row) + + # Create DataFrame + df = pd.DataFrame(rows) + + # Print summary + print(f"Created DataFrame with {len(df)} rows") + print(f"Number of unique agent types: {df['agent_type'].nunique()}") + print(f"Number of unique scenarios: {df['scenario'].nunique()}") + print(f"Maximum timestep: {df['timestep'].max()}") + + # Print more detailed statistics + print("\nRows per agent type:") + print(df.groupby('agent_type').size()) + + print("\nSample of DataFrame:") + print(df.head()) + + return df + +def compare_agent_types(df): + """ + Compare different agent types based on their behavior using the updated DataFrame structure. + + Args: + df: DataFrame containing agent behavior data with the columns: + agent_type, scenario, agent_idx, timestep, entropy, acceleration, steering, etc. + + Returns: + dict: Dictionary of analysis results + """ + results = {} + + # 1. Compare acceleration and steering distributions by agent type + accel_dist_by_agent = df.groupby('agent_type')['acceleration'].value_counts(normalize=True).unstack().fillna(0) + results['acceleration_distribution'] = accel_dist_by_agent + + steer_dist_by_agent = df.groupby('agent_type')['steering'].value_counts(normalize=True).unstack().fillna(0) + results['steering_distribution'] = steer_dist_by_agent + + # 2. Compare entropy (uncertainty) by agent type + entropy_by_agent = df.groupby('agent_type')['entropy'].agg(['mean', 'std', 'min', 'max']) + results['entropy_stats'] = entropy_by_agent + + # 3. Create a measure of behavior diversity for each agent type + # Higher entropy and more diverse action choices indicate more diverse behavior + + # Calculate action diversity based on unique combinations of acceleration and steering + df['action_combo'] = df['acceleration'].astype(str) + "_" + df['steering'].astype(str) + df_grouped = df.groupby(['agent_type', 'scenario', 'timestep'])['action_combo'].nunique().reset_index() + action_diversity = df_grouped.groupby('agent_type')['action_combo'].mean() + + # Calculate entropy diversity + entropy_diversity = entropy_by_agent['mean'] + + # Combine measures into overall behavior diversity + behavior_diversity = pd.DataFrame({ + 'mean_entropy': entropy_by_agent['mean'], + 'action_diversity': action_diversity + }) + + # Normalize and combine (handle case where min = max) + entropy_range = behavior_diversity['mean_entropy'].max() - behavior_diversity['mean_entropy'].min() + action_range = behavior_diversity['action_diversity'].max() - behavior_diversity['action_diversity'].min() + + if entropy_range > 1e-10: + behavior_diversity['norm_entropy'] = (behavior_diversity['mean_entropy'] - behavior_diversity['mean_entropy'].min()) / entropy_range + else: + behavior_diversity['norm_entropy'] = 0.5 # Constant value if all equal + + if action_range > 1e-10: + behavior_diversity['norm_action_div'] = (behavior_diversity['action_diversity'] - behavior_diversity['action_diversity'].min()) / action_range + else: + behavior_diversity['norm_action_div'] = 0.5 # Constant value if all equal + + behavior_diversity['overall_diversity'] = (behavior_diversity['norm_entropy'] + behavior_diversity['norm_action_div']) / 2 + + results['behavior_diversity'] = behavior_diversity + + # 4. Calculate additional metrics + # Average logprob by agent type (measure of confidence) + logprob_by_agent = df.groupby('agent_type')['logprob'].mean() + results['avg_logprob'] = logprob_by_agent + + # Distribution of steering and acceleration over time + time_series = df.groupby(['agent_type', 'timestep'])[['steering', 'acceleration']].mean() + results['time_series'] = time_series + + # Print summary of comparison + print("\n=== Agent Type Comparison ===") + print("\nBehavioral Diversity (higher = more diverse):") + print(behavior_diversity[['mean_entropy', 'action_diversity', 'overall_diversity']].sort_values('overall_diversity', ascending=False)) + + print("\nAverage Log Probability (higher = more confident):") + print(logprob_by_agent) + + # Acceleration and steering tendencies + print("\nAverage Acceleration by Agent Type:") + print(df.groupby('agent_type')['acceleration'].mean().sort_values(ascending=False)) + + print("\nAverage Steering by Agent Type (absolute value - measures turning intensity):") + print(df.groupby('agent_type').apply(lambda x: abs(x['steering']).mean()).sort_values(ascending=False)) + + # Analyze variation across scenarios + scenario_variation = df.groupby(['agent_type', 'scenario'])[['acceleration', 'steering']].mean().groupby('agent_type').std() + print("\nVariation Across Scenarios (higher = less consistent behavior):") + print(scenario_variation) + + return results + + +if __name__ == "__main__": + + config = load_config("/home/emerge/gpudrive/baselines/ppo/config/ppo_base_puffer") + + num_envs = 20 + device = "cpu" + max_agents = 2 + + config.environment.reward_type = "reward_conditioned" + config.environment.condition_mode = "fixed" + config.environment.agent_type = torch.Tensor([-0.2, 1.0, -0.2]) + + agent = load_policy( + model_name="model_PPO____R_10000__03_20_17_01_59_614_007000", + path_to_cpt="/home/emerge/gpudrive/examples/experimental/models", + env_config=config.environment, + device=device + ); + + # Create data loader + train_loader = SceneDataLoader( + root='/home/emerge/gpudrive/data/processed/training/', + batch_size=num_envs, + dataset_size=100, + sample_with_replacement=False, + ) + + # Set params + config = config.environment + env_config = dataclasses.replace( + EnvConfig(), + norm_obs=config.norm_obs, + dynamics_model=config.dynamics_model, + collision_behavior=config.collision_behavior, + dist_to_goal_threshold=config.dist_to_goal_threshold, + polyline_reduction_threshold=config.polyline_reduction_threshold, + remove_non_vehicles=config.remove_non_vehicles, + lidar_obs=config.lidar_obs, + disable_classic_obs=config.lidar_obs, + obs_radius=config.obs_radius, + steer_actions = torch.round( + torch.linspace(-torch.pi, torch.pi, config.action_space_steer_disc), decimals=3 + ), + accel_actions = torch.round( + torch.linspace(-4.0, 4.0, config.action_space_accel_disc), decimals=3 + ), + reward_type=config.reward_type, + condition_mode=config.condition_mode, + agent_type=config.agent_type, + ) + + # Make env + env = GPUDriveTorchEnv( + config=env_config, + data_loader=train_loader, + max_cont_agents=max_agents, + device=device, + ) + + # Define different agent types to compare + agent_configs = { # Collision, Goal, Off-road + 'Nominal': torch.tensor([-0.75, 1.0, -0.75], device=device), + 'Aggressive': torch.tensor([0.0, 2.0, 0.0], device=device), + 'Risk-averse': torch.tensor([-2.0, 0.5, -2.0], device=device), + } + + print("Collecting rollout data for all agent types...") + + # Collect data for all agent types + all_rollout_data = collect_data_for_agent_types( + env=env, + agent=agent, + agent_configs=agent_configs, + device=device, + num_rollouts_per_agent=10 # Number of times we rollout in the same scenes + ) + + # Convert to DataFrame for analysis + df = create_dataframe_from_rollouts(all_rollout_data) + + + comparison_results = compare_agent_types(df) + + df.to_csv("agent_type_comparison_data.csv", index=False) \ No newline at end of file diff --git a/gpudrive/utils/rollout.py b/gpudrive/utils/rollout.py index 0e4e446fc..8ceba3da3 100644 --- a/gpudrive/utils/rollout.py +++ b/gpudrive/utils/rollout.py @@ -57,17 +57,19 @@ def rollout( (env.num_worlds, env.max_agent_count, episode_len, 2) ) - # Initialize behavioral metrics storage if requested if return_behavior_metrics: - situation_responses = {} entropy_values = torch.zeros( (num_worlds, max_agent_count, episode_len), device=device ) logprob_values = torch.zeros( (num_worlds, max_agent_count, episode_len), device=device ) + # Assumes the action space is 3-dimensional (dynamics_model = "classic") + action_history = torch.zeros( + (num_worlds, max_agent_count, episode_len, 3), device=device + ) else: - situation_responses, entropy_values, logprob_values = None, None, None + entropy_values, logprob_values, action_history = None, None, None # Reset episode if set_agent_type and agent_weights is not None: @@ -87,6 +89,10 @@ def rollout( live_agent_mask = control_mask.clone() for time_step in range(episode_len): + + time_mask = torch.zeros(episode_len, dtype=torch.bool, device=device) + time_mask[time_step] = True + # Get actions for active agents if live_agent_mask.any(): action, logprob, entropy, value = policy( @@ -99,77 +105,13 @@ def rollout( ) action_template[live_agent_mask] = action.to(device) - # Store policy outputs if requested - if return_behavior_metrics and live_agent_mask.any(): - # Check if entropy and logprob are scalar or vector - is_scalar_entropy = entropy.dim() == 0 - is_scalar_logprob = logprob.dim() == 0 - - # For each agent, store responses and metrics - for world_idx in range(num_worlds): - for agent_idx in range(max_agent_count): - if live_agent_mask[world_idx, agent_idx]: - # Store entropy and logprob values - # If they're scalars, we'll use them directly - # If they're vectors, we need to match them with the right agent - # We'll use a simple counter to track position in the flat action tensor - - # Calculate position in the flattened tensor if needed - mask_before = ( - live_agent_mask[:world_idx].sum() - + live_agent_mask[world_idx, :agent_idx].sum() - ) - position = mask_before.item() - - # Store entropy (either scalar value or indexed) - if is_scalar_entropy: - entropy_values[ - world_idx, agent_idx, time_step - ] = entropy.item() - current_entropy = entropy.item() - else: - entropy_values[ - world_idx, agent_idx, time_step - ] = entropy[position].item() - current_entropy = entropy[position].item() - - # Store logprob (either scalar value or indexed) - if is_scalar_logprob: - logprob_values[ - world_idx, agent_idx, time_step - ] = logprob.item() - current_logprob = logprob.item() - else: - logprob_values[ - world_idx, agent_idx, time_step - ] = logprob[position].item() - current_logprob = logprob[position].item() - - # Create a simple hash of observation to identify similar situations - obs_flat = ( - next_obs[world_idx, agent_idx].cpu().flatten() - ) - # Use first N elements as a simple way to create situation identifier - situation_key = tuple( - obs_flat[:20].numpy().tolist() - ) - - if situation_key not in situation_responses: - situation_responses[situation_key] = [] - - # Store the action as an item (not a tensor) to avoid issues - situation_responses[situation_key].append( - { - "world_idx": world_idx, - "agent_idx": agent_idx, - "action": action_template[ - world_idx, agent_idx - ].item(), - "entropy": current_entropy, - "logprob": current_logprob, - "time_step": time_step, - } - ) + if return_behavior_metrics: + mask = live_agent_mask.unsqueeze(2) & time_mask.unsqueeze(0).unsqueeze(0) + entropy_values[mask] = entropy + logprob_values[mask] = logprob + + action_values = env.action_keys_tensor[action] + action_history[mask] = action_values # Step the environment env.step_dynamics(action_template) @@ -282,9 +224,9 @@ def rollout( # Return behavioral metrics if requested if return_behavior_metrics: behavior_metrics = { - "situation_responses": situation_responses, - "entropy_values": entropy_values, - "logprob_values": logprob_values, + "entropy": entropy_values, + "logprob": logprob_values, + "actions": action_history } return base_metrics + (behavior_metrics,) From a3d05431dd3916c9290088a71c3508591ea71aff Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 21 Mar 2025 17:10:58 -0400 Subject: [PATCH 07/81] Analyze agent diversity v2 --- examples/experimental/diversity.py | 359 ++++++++++++++++++----------- gpudrive/utils/rollout.py | 12 +- 2 files changed, 229 insertions(+), 142 deletions(-) diff --git a/examples/experimental/diversity.py b/examples/experimental/diversity.py index 02001c195..8307a076d 100644 --- a/examples/experimental/diversity.py +++ b/examples/experimental/diversity.py @@ -25,10 +25,12 @@ from PIL import Image -def collect_rollout_for_agent_type(env, agent, agent_type_name, agent_weights, device, num_rollouts=5): +def collect_rollout_for_agent_type( + env, agent, agent_type_name, agent_weights, device, num_rollouts=5 +): """ Collect rollout data for a specific agent type. - + Args: env: The simulation environment agent: The policy to be rolled out @@ -36,14 +38,16 @@ def collect_rollout_for_agent_type(env, agent, agent_type_name, agent_weights, d agent_weights: Tensor of agent weights device: The device to run on num_rollouts: Number of rollouts to perform for this agent type - + Returns: list: List of dictionaries containing rollout data for this agent type """ all_data = [] - + # Run multiple rollouts for this agent type - for i in tqdm(range(num_rollouts), desc=f"Agent: {agent_type_name}", unit="rollout"): + for i in tqdm( + range(num_rollouts), desc=f"Agent: {agent_type_name}", unit="rollout" + ): # Run the rollout with the specified agent weights rollout_results = rollout( env=env, @@ -54,48 +58,56 @@ def collect_rollout_for_agent_type(env, agent, agent_type_name, agent_weights, d return_agent_positions=False, return_behavior_metrics=True, set_agent_type=True, - agent_weights=agent_weights + agent_weights=agent_weights, ) - + # Extract behavioral metrics from rollout (last element of returned tuple) behavior_metrics = rollout_results[-1] - + # Store data for this rollout - all_data.append({ - 'agent_type': agent_type_name, - 'rollout_idx': i, - 'weights': agent_weights.cpu().tolist(), - 'entropy': behavior_metrics['entropy'], - 'logprob': behavior_metrics['logprob'], - 'actions': behavior_metrics['actions'] - }) - + all_data.append( + { + "agent_type": agent_type_name, + "rollout_idx": i, + "weights": agent_weights.cpu().tolist(), + "entropy": behavior_metrics["entropy"], + "logprob": behavior_metrics["logprob"], + "actions": behavior_metrics["actions"], + } + ) + return all_data -def collect_data_for_agent_types(env, agent, agent_configs, device, num_rollouts_per_agent=5): +def collect_data_for_agent_types( + env, agent, agent_configs, device, num_rollouts_per_agent=5 +): """ Collect rollout data for all agent types in agent_configs. - + Args: env: The simulation environment agent: The policy to be rolled out agent_configs: Dictionary mapping agent type names to their weight tensors device: The device to run on num_rollouts_per_agent: Number of rollouts to perform for each agent type - + Returns: list: Combined list of dictionaries containing rollout data for all agent types """ all_agent_data = [] - + # Display overall progress information - print(f"Collecting data for {len(agent_configs)} agent types, {num_rollouts_per_agent} rollouts each") - + print( + f"Collecting data for {len(agent_configs)} agent types, {num_rollouts_per_agent} rollouts each" + ) + # Process each agent type for agent_type_name, agent_weights in agent_configs.items(): - print(f"\nAgent type: {agent_type_name}, weights: {agent_weights.cpu().tolist()}") - + print( + f"\nAgent type: {agent_type_name}, weights: {agent_weights.cpu().tolist()}" + ) + # Collect data for this agent type agent_data = collect_rollout_for_agent_type( env=env, @@ -103,12 +115,12 @@ def collect_data_for_agent_types(env, agent, agent_configs, device, num_rollouts agent_type_name=agent_type_name, agent_weights=agent_weights, device=device, - num_rollouts=num_rollouts_per_agent + num_rollouts=num_rollouts_per_agent, ) - + # Add to combined data all_agent_data.extend(agent_data) - + print(f"Completed rollouts for all {len(agent_configs)} agent types") return all_agent_data @@ -116,170 +128,240 @@ def collect_data_for_agent_types(env, agent, agent_configs, device, num_rollouts def create_dataframe_from_rollouts(rollout_data): """ Convert rollout data to a pandas DataFrame with the specified columns. - + Args: rollout_data: List of dictionaries containing rollout results - + Returns: pd.DataFrame: DataFrame with agent behavior data """ rows = [] - + # Process each rollout for data in rollout_data: - agent_type = data['agent_type'] - rollout_idx = data['rollout_idx'] - weights = data['weights'] - + agent_type = data["agent_type"] + rollout_idx = data["rollout_idx"] + weights = data["weights"] + # Get tensor data - entropy = data['entropy'] # Shape: [num_envs, max_agents, episode_len] - logprob = data['logprob'] # Shape: [num_envs, max_agents, episode_len] - actions = data['actions'] # Shape: [num_envs, max_agents, episode_len, action_dim] - + entropy = data["entropy"] # Shape: [num_envs, max_agents, episode_len] + logprob = data["logprob"] # Shape: [num_envs, max_agents, episode_len] + actions = data[ + "actions" + ] # Shape: [num_envs, max_agents, episode_len, action_dim] + # Get dimensions num_envs = actions.shape[0] max_agents = actions.shape[1] episode_len = actions.shape[2] - + # Create rows for all non-zero entries for env_idx in range(num_envs): for agent_idx in range(max_agents): for time_step in range(episode_len): # Skip if no action was taken (all zeros) action_vec = actions[env_idx, agent_idx, time_step] - if torch.all(action_vec == 0) and entropy[env_idx, agent_idx, time_step] == 0: + if ( + torch.all(action_vec == 0) + and entropy[env_idx, agent_idx, time_step] == 0 + ): continue - + # Add row with specified columns row = { - 'agent_type': agent_type, - 'scenario': env_idx, - 'agent_idx': agent_idx, # Keep this in case you need it later - 'timestep': time_step, - 'entropy': entropy[env_idx, agent_idx, time_step].item(), - 'acceleration': action_vec[0].item(), - 'steering': action_vec[1].item(), - 'logprob': logprob[env_idx, agent_idx, time_step].item(), - 'rollout_idx': rollout_idx, - 'collision_weight': weights[0], - 'goal_weight': weights[1], - 'off_road_weight': weights[2] + "agent_type": agent_type, + "scenario": env_idx, + "agent_idx": agent_idx, # Keep this in case you need it later + "timestep": time_step, + "entropy": entropy[ + env_idx, agent_idx, time_step + ].item(), + "acceleration": action_vec[0].item(), + "steering": action_vec[1].item(), + "logprob": logprob[ + env_idx, agent_idx, time_step + ].item(), + "rollout_idx": rollout_idx, + "collision_weight": weights[0], + "goal_weight": weights[1], + "off_road_weight": weights[2], } rows.append(row) - + # Create DataFrame df = pd.DataFrame(rows) - + # Print summary print(f"Created DataFrame with {len(df)} rows") print(f"Number of unique agent types: {df['agent_type'].nunique()}") print(f"Number of unique scenarios: {df['scenario'].nunique()}") print(f"Maximum timestep: {df['timestep'].max()}") - + # Print more detailed statistics print("\nRows per agent type:") - print(df.groupby('agent_type').size()) - + print(df.groupby("agent_type").size()) + print("\nSample of DataFrame:") print(df.head()) - + return df + def compare_agent_types(df): """ Compare different agent types based on their behavior using the updated DataFrame structure. - + Args: df: DataFrame containing agent behavior data with the columns: agent_type, scenario, agent_idx, timestep, entropy, acceleration, steering, etc. - + Returns: dict: Dictionary of analysis results """ results = {} - + # 1. Compare acceleration and steering distributions by agent type - accel_dist_by_agent = df.groupby('agent_type')['acceleration'].value_counts(normalize=True).unstack().fillna(0) - results['acceleration_distribution'] = accel_dist_by_agent - - steer_dist_by_agent = df.groupby('agent_type')['steering'].value_counts(normalize=True).unstack().fillna(0) - results['steering_distribution'] = steer_dist_by_agent - + accel_dist_by_agent = ( + df.groupby("agent_type")["acceleration"] + .value_counts(normalize=True) + .unstack() + .fillna(0) + ) + results["acceleration_distribution"] = accel_dist_by_agent + + steer_dist_by_agent = ( + df.groupby("agent_type")["steering"] + .value_counts(normalize=True) + .unstack() + .fillna(0) + ) + results["steering_distribution"] = steer_dist_by_agent + # 2. Compare entropy (uncertainty) by agent type - entropy_by_agent = df.groupby('agent_type')['entropy'].agg(['mean', 'std', 'min', 'max']) - results['entropy_stats'] = entropy_by_agent - + entropy_by_agent = df.groupby("agent_type")["entropy"].agg( + ["mean", "std", "min", "max"] + ) + results["entropy_stats"] = entropy_by_agent + # 3. Create a measure of behavior diversity for each agent type # Higher entropy and more diverse action choices indicate more diverse behavior - + # Calculate action diversity based on unique combinations of acceleration and steering - df['action_combo'] = df['acceleration'].astype(str) + "_" + df['steering'].astype(str) - df_grouped = df.groupby(['agent_type', 'scenario', 'timestep'])['action_combo'].nunique().reset_index() - action_diversity = df_grouped.groupby('agent_type')['action_combo'].mean() - + df["action_combo"] = ( + df["acceleration"].astype(str) + "_" + df["steering"].astype(str) + ) + df_grouped = ( + df.groupby(["agent_type", "scenario", "timestep"])["action_combo"] + .nunique() + .reset_index() + ) + action_diversity = df_grouped.groupby("agent_type")["action_combo"].mean() + # Calculate entropy diversity - entropy_diversity = entropy_by_agent['mean'] - + entropy_diversity = entropy_by_agent["mean"] + # Combine measures into overall behavior diversity - behavior_diversity = pd.DataFrame({ - 'mean_entropy': entropy_by_agent['mean'], - 'action_diversity': action_diversity - }) - + behavior_diversity = pd.DataFrame( + { + "mean_entropy": entropy_by_agent["mean"], + "action_diversity": action_diversity, + } + ) + # Normalize and combine (handle case where min = max) - entropy_range = behavior_diversity['mean_entropy'].max() - behavior_diversity['mean_entropy'].min() - action_range = behavior_diversity['action_diversity'].max() - behavior_diversity['action_diversity'].min() - + entropy_range = ( + behavior_diversity["mean_entropy"].max() + - behavior_diversity["mean_entropy"].min() + ) + action_range = ( + behavior_diversity["action_diversity"].max() + - behavior_diversity["action_diversity"].min() + ) + if entropy_range > 1e-10: - behavior_diversity['norm_entropy'] = (behavior_diversity['mean_entropy'] - behavior_diversity['mean_entropy'].min()) / entropy_range + behavior_diversity["norm_entropy"] = ( + behavior_diversity["mean_entropy"] + - behavior_diversity["mean_entropy"].min() + ) / entropy_range else: - behavior_diversity['norm_entropy'] = 0.5 # Constant value if all equal - + behavior_diversity["norm_entropy"] = 0.5 # Constant value if all equal + if action_range > 1e-10: - behavior_diversity['norm_action_div'] = (behavior_diversity['action_diversity'] - behavior_diversity['action_diversity'].min()) / action_range + behavior_diversity["norm_action_div"] = ( + behavior_diversity["action_diversity"] + - behavior_diversity["action_diversity"].min() + ) / action_range else: - behavior_diversity['norm_action_div'] = 0.5 # Constant value if all equal - - behavior_diversity['overall_diversity'] = (behavior_diversity['norm_entropy'] + behavior_diversity['norm_action_div']) / 2 - - results['behavior_diversity'] = behavior_diversity - + behavior_diversity[ + "norm_action_div" + ] = 0.5 # Constant value if all equal + + behavior_diversity["overall_diversity"] = ( + behavior_diversity["norm_entropy"] + + behavior_diversity["norm_action_div"] + ) / 2 + + results["behavior_diversity"] = behavior_diversity + # 4. Calculate additional metrics # Average logprob by agent type (measure of confidence) - logprob_by_agent = df.groupby('agent_type')['logprob'].mean() - results['avg_logprob'] = logprob_by_agent - + logprob_by_agent = df.groupby("agent_type")["logprob"].mean() + results["avg_logprob"] = logprob_by_agent + # Distribution of steering and acceleration over time - time_series = df.groupby(['agent_type', 'timestep'])[['steering', 'acceleration']].mean() - results['time_series'] = time_series - + time_series = df.groupby(["agent_type", "timestep"])[ + ["steering", "acceleration"] + ].mean() + results["time_series"] = time_series + # Print summary of comparison print("\n=== Agent Type Comparison ===") print("\nBehavioral Diversity (higher = more diverse):") - print(behavior_diversity[['mean_entropy', 'action_diversity', 'overall_diversity']].sort_values('overall_diversity', ascending=False)) - + print( + behavior_diversity[ + ["mean_entropy", "action_diversity", "overall_diversity"] + ].sort_values("overall_diversity", ascending=False) + ) + print("\nAverage Log Probability (higher = more confident):") print(logprob_by_agent) - + # Acceleration and steering tendencies print("\nAverage Acceleration by Agent Type:") - print(df.groupby('agent_type')['acceleration'].mean().sort_values(ascending=False)) - - print("\nAverage Steering by Agent Type (absolute value - measures turning intensity):") - print(df.groupby('agent_type').apply(lambda x: abs(x['steering']).mean()).sort_values(ascending=False)) - + print( + df.groupby("agent_type")["acceleration"] + .mean() + .sort_values(ascending=False) + ) + + print( + "\nAverage Steering by Agent Type (absolute value - measures turning intensity):" + ) + print( + df.groupby("agent_type") + .apply(lambda x: abs(x["steering"]).mean()) + .sort_values(ascending=False) + ) + # Analyze variation across scenarios - scenario_variation = df.groupby(['agent_type', 'scenario'])[['acceleration', 'steering']].mean().groupby('agent_type').std() + scenario_variation = ( + df.groupby(["agent_type", "scenario"])[["acceleration", "steering"]] + .mean() + .groupby("agent_type") + .std() + ) print("\nVariation Across Scenarios (higher = less consistent behavior):") print(scenario_variation) - + return results if __name__ == "__main__": - - config = load_config("/home/emerge/gpudrive/baselines/ppo/config/ppo_base_puffer") - + + config = load_config( + "/home/emerge/gpudrive/baselines/ppo/config/ppo_base_puffer" + ) + num_envs = 20 device = "cpu" max_agents = 2 @@ -287,17 +369,17 @@ def compare_agent_types(df): config.environment.reward_type = "reward_conditioned" config.environment.condition_mode = "fixed" config.environment.agent_type = torch.Tensor([-0.2, 1.0, -0.2]) - + agent = load_policy( model_name="model_PPO____R_10000__03_20_17_01_59_614_007000", path_to_cpt="/home/emerge/gpudrive/examples/experimental/models", env_config=config.environment, - device=device - ); - + device=device, + ) + # Create data loader train_loader = SceneDataLoader( - root='/home/emerge/gpudrive/data/processed/training/', + root="/home/emerge/gpudrive/data/processed/training/", batch_size=num_envs, dataset_size=100, sample_with_replacement=False, @@ -316,11 +398,15 @@ def compare_agent_types(df): lidar_obs=config.lidar_obs, disable_classic_obs=config.lidar_obs, obs_radius=config.obs_radius, - steer_actions = torch.round( - torch.linspace(-torch.pi, torch.pi, config.action_space_steer_disc), decimals=3 + steer_actions=torch.round( + torch.linspace( + -torch.pi, torch.pi, config.action_space_steer_disc + ), + decimals=3, ), - accel_actions = torch.round( - torch.linspace(-4.0, 4.0, config.action_space_accel_disc), decimals=3 + accel_actions=torch.round( + torch.linspace(-4.0, 4.0, config.action_space_accel_disc), + decimals=3, ), reward_type=config.reward_type, condition_mode=config.condition_mode, @@ -334,29 +420,28 @@ def compare_agent_types(df): max_cont_agents=max_agents, device=device, ) - + # Define different agent types to compare - agent_configs = { # Collision, Goal, Off-road - 'Nominal': torch.tensor([-0.75, 1.0, -0.75], device=device), - 'Aggressive': torch.tensor([0.0, 2.0, 0.0], device=device), - 'Risk-averse': torch.tensor([-2.0, 0.5, -2.0], device=device), + agent_configs = { # Collision, Goal, Off-road + "Nominal": torch.tensor([-0.75, 1.0, -0.75], device=device), + "Aggressive": torch.tensor([0.0, 2.0, 0.0], device=device), + "Risk-averse": torch.tensor([-2.0, 0.5, -2.0], device=device), } print("Collecting rollout data for all agent types...") - + # Collect data for all agent types all_rollout_data = collect_data_for_agent_types( env=env, agent=agent, agent_configs=agent_configs, device=device, - num_rollouts_per_agent=10 # Number of times we rollout in the same scenes + num_rollouts_per_agent=10, # Number of times we rollout in the same scenes ) - + # Convert to DataFrame for analysis df = create_dataframe_from_rollouts(all_rollout_data) - - + comparison_results = compare_agent_types(df) - - df.to_csv("agent_type_comparison_data.csv", index=False) \ No newline at end of file + + df.to_csv("agent_type_comparison_data.csv", index=False) diff --git a/gpudrive/utils/rollout.py b/gpudrive/utils/rollout.py index 8ceba3da3..03b562660 100644 --- a/gpudrive/utils/rollout.py +++ b/gpudrive/utils/rollout.py @@ -89,10 +89,10 @@ def rollout( live_agent_mask = control_mask.clone() for time_step in range(episode_len): - + time_mask = torch.zeros(episode_len, dtype=torch.bool, device=device) time_mask[time_step] = True - + # Get actions for active agents if live_agent_mask.any(): action, logprob, entropy, value = policy( @@ -106,10 +106,12 @@ def rollout( action_template[live_agent_mask] = action.to(device) if return_behavior_metrics: - mask = live_agent_mask.unsqueeze(2) & time_mask.unsqueeze(0).unsqueeze(0) + mask = live_agent_mask.unsqueeze(2) & time_mask.unsqueeze( + 0 + ).unsqueeze(0) entropy_values[mask] = entropy logprob_values[mask] = logprob - + action_values = env.action_keys_tensor[action] action_history[mask] = action_values @@ -226,7 +228,7 @@ def rollout( behavior_metrics = { "entropy": entropy_values, "logprob": logprob_values, - "actions": action_history + "actions": action_history, } return base_metrics + (behavior_metrics,) From d1fab12fa0f7ef7f62625a8237ab6710c6274ada Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 21 Mar 2025 18:27:55 -0400 Subject: [PATCH 08/81] Full diversity analysis --- .../notebooks/04_reward_cond_agents.ipynb | 341 +- .../05_getting_to_know_the_pop.ipynb | 3285 +++++++++++++++++ .../utils}/diversity.py | 153 +- 3 files changed, 3471 insertions(+), 308 deletions(-) create mode 100644 examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb rename {examples/experimental => gpudrive/utils}/diversity.py (76%) diff --git a/examples/experimental/notebooks/04_reward_cond_agents.ipynb b/examples/experimental/notebooks/04_reward_cond_agents.ipynb index 4bf60f78d..625591ac9 100644 --- a/examples/experimental/notebooks/04_reward_cond_agents.ipynb +++ b/examples/experimental/notebooks/04_reward_cond_agents.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ @@ -19,6 +19,8 @@ "import random\n", "import numpy as np\n", "import pandas as pd\n", + "from tqdm import tqdm\n", + "\n", "\n", "from gpudrive.env.config import EnvConfig\n", "from gpudrive.env.env_torch import GPUDriveTorchEnv\n", @@ -33,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 41, "metadata": {}, "outputs": [ { @@ -50,7 +52,7 @@ "\n", "print(config)\n", "\n", - "num_envs = 5\n", + "num_envs = 4\n", "device = \"cpu\"\n", "max_agents = 64\n", "\n", @@ -61,20 +63,28 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 42, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Load model from /home/emerge/gpudrive/examples/experimental/models/model_PPO____R_10000__03_19_19_05_33_518_006000.pt\n" + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: '/home/emerge/gpudrive/examples/experimental/models/rew_conditioned_0321.pt.pt'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[42], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m agent \u001b[38;5;241m=\u001b[39m \u001b[43mload_policy\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrew_conditioned_0321.pt\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mpath_to_cpt\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m/home/emerge/gpudrive/examples/experimental/models\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43menv_config\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43menvironment\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdevice\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m)\u001b[49m;\n", + "File \u001b[0;32m~/gpudrive/gpudrive/utils/checkpoint.py:10\u001b[0m, in \u001b[0;36mload_policy\u001b[0;34m(path_to_cpt, model_name, device, env_config)\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Load a policy from a given path.\"\"\"\u001b[39;00m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;66;03m# Load a trained model\u001b[39;00m\n\u001b[0;32m---> 10\u001b[0m saved_cpt \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43mf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mpath_to_cpt\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m/\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mmodel_name\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m.pt\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 12\u001b[0m \u001b[43m \u001b[49m\u001b[43mmap_location\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdevice\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 13\u001b[0m \u001b[43m \u001b[49m\u001b[43mweights_only\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 14\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 16\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mLoad model from \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mpath_to_cpt\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodel_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.pt\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 18\u001b[0m \u001b[38;5;66;03m# Create policy architecture from saved checkpoint\u001b[39;00m\n", + "File \u001b[0;32m~/.pyenv/versions/gpudrive/lib/python3.11/site-packages/torch/serialization.py:1425\u001b[0m, in \u001b[0;36mload\u001b[0;34m(f, map_location, pickle_module, weights_only, mmap, **pickle_load_args)\u001b[0m\n\u001b[1;32m 1422\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mencoding\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m pickle_load_args\u001b[38;5;241m.\u001b[39mkeys():\n\u001b[1;32m 1423\u001b[0m pickle_load_args[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mencoding\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mutf-8\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m-> 1425\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[43m_open_file_like\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrb\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m opened_file:\n\u001b[1;32m 1426\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m _is_zipfile(opened_file):\n\u001b[1;32m 1427\u001b[0m \u001b[38;5;66;03m# The zipfile reader is going to advance the current file position.\u001b[39;00m\n\u001b[1;32m 1428\u001b[0m \u001b[38;5;66;03m# If we want to actually tail call to torch.jit.load, we need to\u001b[39;00m\n\u001b[1;32m 1429\u001b[0m \u001b[38;5;66;03m# reset back to the original position.\u001b[39;00m\n\u001b[1;32m 1430\u001b[0m orig_position \u001b[38;5;241m=\u001b[39m opened_file\u001b[38;5;241m.\u001b[39mtell()\n", + "File \u001b[0;32m~/.pyenv/versions/gpudrive/lib/python3.11/site-packages/torch/serialization.py:751\u001b[0m, in \u001b[0;36m_open_file_like\u001b[0;34m(name_or_buffer, mode)\u001b[0m\n\u001b[1;32m 749\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21m_open_file_like\u001b[39m(name_or_buffer, mode):\n\u001b[1;32m 750\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m _is_path(name_or_buffer):\n\u001b[0;32m--> 751\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_open_file\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 752\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 753\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mw\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m mode:\n", + "File \u001b[0;32m~/.pyenv/versions/gpudrive/lib/python3.11/site-packages/torch/serialization.py:732\u001b[0m, in \u001b[0;36m_open_file.__init__\u001b[0;34m(self, name, mode)\u001b[0m\n\u001b[1;32m 731\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, name, mode):\n\u001b[0;32m--> 732\u001b[0m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m)\u001b[49m)\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/home/emerge/gpudrive/examples/experimental/models/rew_conditioned_0321.pt.pt'" ] } ], "source": [ "agent = load_policy(\n", - " model_name=\"model_PPO____R_10000__03_19_19_05_33_518_006000\",\n", + " model_name=\"rew_conditioned_0321.pt\",\n", " path_to_cpt=\"/home/emerge/gpudrive/examples/experimental/models\",\n", " env_config=config.environment,\n", " device=device\n", @@ -83,13 +93,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ "# Create data loader\n", "train_loader = SceneDataLoader(\n", - " root='/home/emerge/gpudrive/data/processed/training/',\n", + " root='/home/emerge/gpudrive/data/processed/examples/',\n", " batch_size=num_envs,\n", " dataset_size=100,\n", " sample_with_replacement=False,\n", @@ -130,11 +140,20 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 53, "metadata": {}, "outputs": [], "source": [ - "def run_multiple_rollouts(env, agent, num_rollouts=2, device='cpu'):\n", + "def run_multiple_rollouts(\n", + " env, \n", + " agent, \n", + " num_rollouts=2, \n", + " device='cpu',\n", + " sample_collision_weights=True,\n", + " sample_goal_weights=False,\n", + " sample_offroad_weights=False,\n", + " agent_type=None,\n", + "):\n", " \"\"\"\n", " Run multiple rollouts with different collision weights and store trajectories.\n", " Stores agent positions as a tensor of shape [num_envs, num_rollouts, agents, steps, 2].\n", @@ -149,11 +168,6 @@ " all_trajectories: Dictionary containing trajectories and weights\n", " \"\"\"\n", " \n", - " # Get environment info to determine dimensions\n", - " obs = env.reset(agent_type=torch.Tensor([0.0, 0.0, 0.0]))\n", - " num_envs = obs.shape[0] if hasattr(obs, 'shape') else 1\n", - " \n", - " # Lists to collect data across rollouts\n", " all_agent_positions = []\n", " collision_weights = []\n", " goal_weights = []\n", @@ -163,16 +177,31 @@ " all_off_road = []\n", " all_episode_lengths = []\n", " \n", - " for i in range(num_rollouts):\n", - " print(f\"Running rollout {i+1}/{num_rollouts}\")\n", - " \n", - " # Sample separate weights\n", - " collision_weight = random.uniform(-3.0, 1.0)\n", - " goal_weight = 1.0\n", - " off_road_weight = -3.0\n", + " print(f\"Running {num_rollouts} rollouts, sampling weights: collision={sample_collision_weights}, goal={sample_goal_weights}, offroad={sample_offroad_weights}\\n\")\n", + " \n", + " for i in tqdm(range(num_rollouts), desc=\"Processing rollouts\", unit=\"rollout\"):\n", " \n", - " agent_weights = torch.Tensor([collision_weight, goal_weight, off_road_weight])\n", - " print(f\"Using weights: {agent_weights}\")\n", + " # Sample weights\n", + " if agent_type is not None:\n", + " agent_weights = agent_type\n", + " collision_weight = agent_weights[0].item()\n", + " goal_weight = agent_weights[1].item()\n", + " off_road_weight = agent_weights[2].item()\n", + " else:\n", + " if sample_collision_weights:\n", + " collision_weight = random.uniform(-3.0, 1.0)\n", + " else:\n", + " collision_weight = -3.0\n", + " if sample_goal_weights:\n", + " goal_weight = random.uniform(1.0, 3.0)\n", + " else:\n", + " goal_weight = 1.0\n", + " if sample_offroad_weights:\n", + " off_road_weight = random.uniform(-3.0, 0.5)\n", + " else:\n", + " off_road_weight = -3.0\n", + "\n", + " agent_weights = torch.Tensor([collision_weight, goal_weight, off_road_weight])\n", " \n", " # Run rollout with these weights\n", " (\n", @@ -231,53 +260,36 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "# Define different agent types to compare\n", + "agent_configs = { # Collision, Goal, Off-road\n", + " 'Nominal': torch.tensor([-0.75, 1.0, -0.75], device=device),\n", + " 'Aggressive': torch.tensor([0.0, 2.0, 0.0], device=device),\n", + " 'Risk-averse': torch.tensor([-2.0, 0.5, -2.0], device=device),\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 59, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Running rollout 1/20\n", - "Using weights: tensor([-1.6067, 1.0000, -3.0000])\n", - "Running rollout 2/20\n", - "Using weights: tensor([-0.4170, 1.0000, -3.0000])\n", - "Running rollout 3/20\n", - "Using weights: tensor([-2.7621, 1.0000, -3.0000])\n", - "Running rollout 4/20\n", - "Using weights: tensor([-0.1729, 1.0000, -3.0000])\n", - "Running rollout 5/20\n", - "Using weights: tensor([-1.8213, 1.0000, -3.0000])\n", - "Running rollout 6/20\n", - "Using weights: tensor([-2.4634, 1.0000, -3.0000])\n", - "Running rollout 7/20\n", - "Using weights: tensor([-0.8697, 1.0000, -3.0000])\n", - "Running rollout 8/20\n", - "Using weights: tensor([-1.1699, 1.0000, -3.0000])\n", - "Running rollout 9/20\n", - "Using weights: tensor([-2.5592, 1.0000, -3.0000])\n", - "Running rollout 10/20\n", - "Using weights: tensor([ 0.8334, 1.0000, -3.0000])\n", - "Running rollout 11/20\n", - "Using weights: tensor([-0.6398, 1.0000, -3.0000])\n", - "Running rollout 12/20\n", - "Using weights: tensor([ 0.2693, 1.0000, -3.0000])\n", - "Running rollout 13/20\n", - "Using weights: tensor([ 0.7411, 1.0000, -3.0000])\n", - "Running rollout 14/20\n", - "Using weights: tensor([-0.5354, 1.0000, -3.0000])\n", - "Running rollout 15/20\n", - "Using weights: tensor([-2.0566, 1.0000, -3.0000])\n", - "Running rollout 16/20\n", - "Using weights: tensor([-0.8910, 1.0000, -3.0000])\n", - "Running rollout 17/20\n", - "Using weights: tensor([ 0.9948, 1.0000, -3.0000])\n", - "Running rollout 18/20\n", - "Using weights: tensor([-2.7536, 1.0000, -3.0000])\n", - "Running rollout 19/20\n", - "Using weights: tensor([-0.5967, 1.0000, -3.0000])\n", - "Running rollout 20/20\n", - "Using weights: tensor([-0.0391, 1.0000, -3.0000])\n" + "Running 20 rollouts, sampling weights: collision=True, goal=False, offroad=False\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing rollouts: 100%|██████████| 20/20 [00:18<00:00, 1.09rollout/s]\n" ] } ], @@ -286,81 +298,28 @@ " env=env,\n", " agent=agent,\n", " num_rollouts=20,\n", - " device='cpu'\n", + " device='cpu',\n", + " sample_collision_weights=True,\n", + " sample_goal_weights=False,\n", + " sample_offroad_weights=False,\n", + " #agent_type=agent_configs['Risk-averse'],\n", ");" ] }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "torch.Size([5, 20, 64, 91, 2])" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "trajs['agent_positions'].shape" - ] - }, - { - "cell_type": "code", - "execution_count": 8, + "execution_count": 61, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "tensor([-1.6067, -0.4170, -2.7621, -0.1729, -1.8213, -2.4634, -0.8697, -1.1699,\n", - " -2.5592, 0.8334, -0.6398, 0.2693, 0.7411, -0.5354, -2.0566, -0.8910,\n", - " 0.9948, -2.7536, -0.5967, -0.0391])" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "trajs['collision_weights']" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/emerge/gpudrive/gpudrive/visualize/core.py:376: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", - " fig.tight_layout(pad=2, rect=[0.00, 0.00, 0.9, 1])\n" - ] - }, - { - "data": { - "image/jpeg": "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", - "image/png": "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", + "image/jpeg": "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", + "image/png": "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", "text/plain": [ "" ] }, - "execution_count": 9, + "execution_count": 61, "metadata": {}, "output_type": "execute_result" } @@ -371,9 +330,9 @@ "# Plot simulator state with the stacked trajectories\n", "_ = env.reset(agent_type=torch.Tensor([-0.2, 1.0, -0.2]))\n", "img = env.vis.plot_simulator_state(\n", - " env_indices=[4], \n", + " env_indices=[1], \n", " agent_positions=trajs['agent_positions'], # Pass stacked trajectories directly\n", - " zoom_radius=100,\n", + " zoom_radius=70,\n", " multiple_rollouts=True,\n", " line_alpha=0.5, \n", " line_width=1.0, \n", @@ -386,28 +345,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 10, + "execution_count": 49, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Figure saved as effect_of_rew_cond_2.png\n" + "Figure saved as effect_of_rew_cond.png\n" ] } ], "source": [ - "# Save the figure with high DPI\n", - "fig = img # Since img is already the figure object\n", - "filename = \"effect_of_rew_cond_2.png\"\n", + "fig = img \n", + "filename = \"effect_of_rew_cond.png\"\n", "fig.savefig(filename, dpi=300, bbox_inches='tight', pad_inches=0.1)\n", "print(f\"Figure saved as {filename}\")" ] @@ -419,108 +370,6 @@ "### Analyze diversity" ] }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "def collect_rollout_data(env, policy, agent_weights, device, num_rollouts=5):\n", - " \"\"\"\n", - " Collect behavioral data from multiple rollouts for a specific agent type.\n", - " \n", - " Args:\n", - " env: The simulation environment\n", - " policy: The policy to be rolled out\n", - " agent_weights: Agent weight tensor for this agent type\n", - " device: Device to run computations on\n", - " num_rollouts: Number of rollouts to perform\n", - " \n", - " Returns:\n", - " dict: Collected behavioral data from all rollouts\n", - " \"\"\"\n", - " # Initialize data collection\n", - " all_situation_responses = {}\n", - " \n", - " # Perform multiple rollouts\n", - " for rollout_idx in range(num_rollouts):\n", - " print(f\" Rollout {rollout_idx+1}/{num_rollouts}\")\n", - " \n", - " # Run rollout with behavior metrics collection\n", - " rollout_results = rollout(\n", - " env=env,\n", - " policy=policy,\n", - " device=device,\n", - " deterministic=False,\n", - " render_sim_state=False,\n", - " return_agent_positions=False,\n", - " return_behavior_metrics=True,\n", - " set_agent_type=True,\n", - " agent_weights=agent_weights\n", - " )\n", - " \n", - " # Extract behavior metrics (last element of returned tuple)\n", - " behavior_metrics = rollout_results[-1]\n", - " \n", - " # Merge situation responses\n", - " for sit_key, responses in behavior_metrics['situation_responses'].items():\n", - " if sit_key not in all_situation_responses:\n", - " all_situation_responses[sit_key] = []\n", - " all_situation_responses[sit_key].extend(responses)\n", - " \n", - " return {\n", - " 'situation_responses': all_situation_responses,\n", - " 'entropy_values': behavior_metrics['entropy_values'],\n", - " 'logprob_values': behavior_metrics['logprob_values']\n", - " }\n", - "\n", - "\n", - "def store_data_to_dataframe(agent_types, collected_data):\n", - " \"\"\"\n", - " Store collected agent behavioral data in a pandas DataFrame.\n", - " \n", - " Args:\n", - " agent_types: List of agent types/names\n", - " collected_data: Dictionary mapping agent types to their behavioral data\n", - " \n", - " Returns:\n", - " pd.DataFrame: DataFrame containing all the behavioral data\n", - " \"\"\"\n", - " # Create lists to store the flattened data\n", - " rows = []\n", - " \n", - " # Process each agent type's data\n", - " for agent_idx, agent_type in enumerate(agent_types):\n", - " agent_data = collected_data[agent_type]\n", - " \n", - " # Process situation responses\n", - " for sit_key, responses in agent_data['situation_responses'].items():\n", - " for response in responses:\n", - " # Create a row for this response\n", - " row = {\n", - " 'agent_type': agent_type,\n", - " 'agent_idx': agent_idx,\n", - " 'world_idx': response['world_idx'],\n", - " 'agent_id': response['agent_idx'],\n", - " 'situation_key': hash(sit_key), # Use hash as pandas doesn't handle tuples well\n", - " 'action': response['action'],\n", - " 'entropy': response['entropy'] if 'entropy' in response else None,\n", - " 'logprob': response['logprob'] if 'logprob' in response else None,\n", - " 'time_step': response['time_step']\n", - " }\n", - " rows.append(row)\n", - " \n", - " # Convert to DataFrame\n", - " df = pd.DataFrame(rows)\n", - " \n", - " # Print some basic statistics\n", - " print(f\"\\nDataFrame created with {len(df)} rows\")\n", - " print(f\"Number of unique situations: {df['situation_key'].nunique()}\")\n", - " print(f\"Number of unique agent types: {df['agent_type'].nunique()}\")\n", - " \n", - " return df" - ] - }, { "cell_type": "code", "execution_count": 14, diff --git a/examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb b/examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb new file mode 100644 index 000000000..0c25c02d6 --- /dev/null +++ b/examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb @@ -0,0 +1,3285 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "import datetime\n", + "\n", + "# Set up the styling\n", + "sns.set(\"notebook\", font_scale=1.05, rc={\"figure.figsize\": (10, 5)})\n", + "sns.set_style(\"ticks\", rc={\"figure.facecolor\": \"none\", \"axes.facecolor\": \"none\"})\n", + "%config InlineBackend.figure_format = 'svg'\n", + "warnings.filterwarnings(\"ignore\")\n", + "plt.set_loglevel(\"WARNING\")\n", + "mpl.rcParams[\"lines.markersize\"] = 8" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== Agent Type Comparison ===\n", + "\n", + "Policy Entropy by Agent Type (higher = more uncertain):\n", + "agent_type\n", + "Risk-averse 1.054958\n", + "Nominal 0.526441\n", + "Aggressive 0.227942\n", + "Name: mean, dtype: float64\n", + "\n", + "Average Log Probability (higher = more confident):\n", + "agent_type\n", + "Aggressive -0.225350\n", + "Nominal -0.527219\n", + "Risk-averse -1.052286\n", + "Name: logprob, dtype: float64\n", + "\n", + "Average Acceleration by Agent Type:\n", + "agent_type\n", + "Aggressive 3.744939\n", + "Nominal 3.171320\n", + "Risk-averse 1.797634\n", + "Name: acceleration, dtype: float64\n", + "\n", + "Average Steering by Agent Type (absolute value - measures turning intensity):\n", + "agent_type\n", + "Aggressive 2.922955\n", + "Nominal 2.645336\n", + "Risk-averse 2.292953\n", + "dtype: float64\n", + "\n", + "Average Goal Achievement Rate by Agent Type:\n", + "agent_type\n", + "Aggressive 0.998889\n", + "Nominal 0.996037\n", + "Risk-averse 0.982047\n", + "Name: frac_goal_achieved, dtype: float64\n", + "\n", + "Average Collision Rate by Agent Type:\n", + "agent_type\n", + "Aggressive 0.041110\n", + "Risk-averse 0.036129\n", + "Nominal 0.021887\n", + "Name: frac_collided, dtype: float64\n", + "\n", + "Variation Across Scenarios (higher = less consistent behavior):\n", + " acceleration steering\n", + "agent_type \n", + "Aggressive 0.215828 1.972205\n", + "Nominal 0.483494 1.774786\n", + "Risk-averse 0.790747 1.362483\n" + ] + } + ], + "source": [ + "from gpudrive.utils.diversity import compare_agent_types\n", + "\n", + "# Load the saved DataFrame\n", + "df = pd.read_csv(\"/home/emerge/gpudrive/agent_type_comparison_data.csv\")\n", + "\n", + "results = compare_agent_types(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['acceleration_distribution', 'steering_distribution', 'entropy_stats', 'action_diversity', 'avg_logprob', 'time_series', 'goal_rate', 'collision_rate'])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
meanstdminmax
agent_type
Aggressive0.2279420.3724990.0005822.857634
Nominal0.5264410.5212520.0001482.965228
Risk-averse1.0549580.6417210.0005623.296287
\n", + "
" + ], + "text/plain": [ + " mean std min max\n", + "agent_type \n", + "Aggressive 0.227942 0.372499 0.000582 2.857634\n", + "Nominal 0.526441 0.521252 0.000148 2.965228\n", + "Risk-averse 1.054958 0.641721 0.000562 3.296287" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results['entropy_stats']" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2025-03-21T18:10:51.767008\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.9.0, https://matplotlib.org/\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n" + ], + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Create a consistent color map for agent types\n", + "agent_colors = {\n", + " 'Aggressive': 'r',\n", + " 'Nominal': 'g',\n", + " 'Risk-averse': 'b'\n", + "}\n", + "\n", + "# Define the consistent order of agent types (Nominal in the middle)\n", + "agent_order = ['Aggressive', 'Nominal', 'Risk-averse']\n", + "\n", + "# Create figure with subplots - 3x2 to include acceleration and steering\n", + "fig, axes = plt.subplots(3, 2, figsize=(10, 8))\n", + "fig.suptitle('Agent Population Analysis | 50 scenes; measure at every time step; all agents controlled', fontsize=14, y=0.98)\n", + "\n", + "# 1. Policy Entropy by Agent Type (top left)\n", + "entropy_df = pd.DataFrame({\n", + " 'agent_type': results['entropy_stats'].index, \n", + " 'entropy': results['entropy_stats']['mean'].values\n", + "})\n", + "# Reorder according to our defined order instead of sorting\n", + "entropy_df = entropy_df.set_index('agent_type').reindex(agent_order).reset_index()\n", + "\n", + "colors = [agent_colors[agent] for agent in entropy_df['agent_type']]\n", + "sns.barplot(x='agent_type', y='entropy', data=entropy_df, \n", + " palette=colors, alpha=0.8, ax=axes[0, 0])\n", + "axes[0, 0].set_title('Policy Entropy', fontsize=12)\n", + "axes[0, 0].set_ylabel('Average Entropy', fontsize=10)\n", + "axes[0, 0].set_xlabel('Agent Type', fontsize=10)\n", + "axes[0, 0].grid(axis='y', alpha=0.3)\n", + "\n", + "# Add values on top of bars\n", + "for i, row in enumerate(entropy_df.itertuples()):\n", + " axes[0, 0].text(i, row.entropy + 0.01, f'{row.entropy:.3f}', \n", + " ha='center', fontsize=9)\n", + "\n", + "# 2. Agent Confidence via Log Probability (top right)\n", + "logprob_df = pd.DataFrame({'agent_type': results['avg_logprob'].index, \n", + " 'logprob': results['avg_logprob'].values})\n", + "# Reorder according to our defined order\n", + "logprob_df = logprob_df.set_index('agent_type').reindex(agent_order).reset_index()\n", + "\n", + "colors = [agent_colors[agent] for agent in logprob_df['agent_type']]\n", + "sns.barplot(x='agent_type', y='logprob', data=logprob_df, \n", + " palette=colors, alpha=0.8, ax=axes[0, 1])\n", + "axes[0, 1].set_title(f'Agent Confidence | $\\log(p(a_t)$', fontsize=12)\n", + "axes[0, 1].set_ylabel('Log Probability', fontsize=10)\n", + "axes[0, 1].set_xlabel('Agent Type', fontsize=10)\n", + "axes[0, 1].grid(axis='y', alpha=0.3)\n", + "\n", + "# Add values on top of bars\n", + "for i, row in enumerate(logprob_df.itertuples()):\n", + " y_offset = 0.05 if row.logprob < 0 else -0.05\n", + " axes[0, 1].text(i, row.logprob + y_offset, f'{row.logprob:.3f}', \n", + " ha='center', fontsize=9)\n", + "\n", + "# 3. Average Acceleration by Agent Type (middle left)\n", + "accel_df = df.groupby('agent_type')['acceleration'].mean().reset_index()\n", + "# Reorder according to our defined order\n", + "accel_df = accel_df.set_index('agent_type').reindex(agent_order).reset_index()\n", + "\n", + "colors = [agent_colors[agent] for agent in accel_df['agent_type']]\n", + "sns.barplot(x='agent_type', y='acceleration', data=accel_df, \n", + " palette=colors, alpha=0.8, ax=axes[1, 0])\n", + "axes[1, 0].set_title('Average Acceleration', fontsize=12)\n", + "axes[1, 0].set_ylabel('Acceleration', fontsize=10)\n", + "axes[1, 0].set_xlabel('Agent Type', fontsize=10)\n", + "axes[1, 0].grid(axis='y', alpha=0.3)\n", + "\n", + "# Add values on top of bars\n", + "for i, row in enumerate(accel_df.itertuples()):\n", + " axes[1, 0].text(i, row.acceleration + 0.1, f'{row.acceleration:.2f}', \n", + " ha='center', fontsize=9)\n", + "\n", + "# 4. Average Steering by Agent Type (middle right)\n", + "# Calculate average absolute steering angle\n", + "steering_df = df.groupby('agent_type').apply(lambda x: abs(x['steering']).mean()).reset_index()\n", + "steering_df.columns = ['agent_type', 'steering']\n", + "# Reorder according to our defined order\n", + "steering_df = steering_df.set_index('agent_type').reindex(agent_order).reset_index()\n", + "\n", + "colors = [agent_colors[agent] for agent in steering_df['agent_type']]\n", + "sns.barplot(x='agent_type', y='steering', data=steering_df, \n", + " palette=colors, alpha=0.8, ax=axes[1, 1])\n", + "axes[1, 1].set_title('Absolute Steering Angle', fontsize=12)\n", + "axes[1, 1].set_ylabel('Avg Absolute Steering', fontsize=10)\n", + "axes[1, 1].set_xlabel('Agent Type', fontsize=10)\n", + "axes[1, 1].grid(axis='y', alpha=0.3)\n", + "\n", + "# Add values on top of bars\n", + "for i, row in enumerate(steering_df.itertuples()):\n", + " axes[1, 1].text(i, row.steering + 0.1, f'{row.steering:.2f}', \n", + " ha='center', fontsize=9)\n", + "\n", + "# 5. Goal Achievement Rate (bottom left)\n", + "goal_df = pd.DataFrame({\n", + " 'agent_type': results['goal_rate'].index,\n", + " 'goal_rate': results['goal_rate'].values\n", + "})\n", + "# Reorder according to our defined order\n", + "goal_df = goal_df.set_index('agent_type').reindex(agent_order).reset_index()\n", + "\n", + "colors = [agent_colors[agent] for agent in goal_df['agent_type']]\n", + "sns.barplot(x='agent_type', y='goal_rate', data=goal_df, \n", + " palette=colors, alpha=0.8, ax=axes[2, 0])\n", + "axes[2, 0].set_title('Goal Achievement Rate', fontsize=12)\n", + "axes[2, 0].set_ylabel('Goal Rate', fontsize=10)\n", + "axes[2, 0].set_xlabel('Agent Type', fontsize=10)\n", + "axes[2, 0].grid(axis='y', alpha=0.3)\n", + "\n", + "# Add values on top of bars\n", + "for i, row in enumerate(goal_df.itertuples()):\n", + " axes[2, 0].text(i, row.goal_rate + 0.03, f'{row.goal_rate:.3f}', \n", + " ha='center', fontsize=9)\n", + "\n", + "\n", + "# 6. Collision Rate (bottom right)\n", + "\n", + "collision_df = pd.DataFrame({\n", + " 'agent_type': results['collision_rate'].index,\n", + " 'collision_rate': results['collision_rate'].values\n", + "})\n", + "# Reorder according to our defined order\n", + "collision_df = collision_df.set_index('agent_type').reindex(agent_order).reset_index()\n", + "\n", + "colors = [agent_colors[agent] for agent in collision_df['agent_type']]\n", + "sns.barplot(x='agent_type', y='collision_rate', data=collision_df, \n", + " palette=colors, alpha=0.8, ax=axes[2, 1])\n", + "axes[2, 1].set_title('Collision Rate', fontsize=12)\n", + "axes[2, 1].set_ylabel('Collision Rate', fontsize=10)\n", + "axes[2, 1].set_xlabel('Agent Type', fontsize=10)\n", + "axes[2, 1].grid(axis='y', alpha=0.3)\n", + "\n", + "# Adjust layout\n", + "plt.tight_layout()\n", + "#plt.subplots_adjust(top=0.95)\n", + "sns.despine()\n", + "plt.savefig('agent_population_analysis.pdf', dpi=300, bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gpudrive", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/experimental/diversity.py b/gpudrive/utils/diversity.py similarity index 76% rename from examples/experimental/diversity.py rename to gpudrive/utils/diversity.py index 8307a076d..c47a8a19c 100644 --- a/examples/experimental/diversity.py +++ b/gpudrive/utils/diversity.py @@ -64,6 +64,12 @@ def collect_rollout_for_agent_type( # Extract behavioral metrics from rollout (last element of returned tuple) behavior_metrics = rollout_results[-1] + # Extract goal and collision rates (these are earlier in the returned tuple) + goal_achieved_count = rollout_results[0] + frac_goal_achieved = rollout_results[1] + collided_count = rollout_results[2] + frac_collided = rollout_results[3] + # Store data for this rollout all_data.append( { @@ -73,6 +79,10 @@ def collect_rollout_for_agent_type( "entropy": behavior_metrics["entropy"], "logprob": behavior_metrics["logprob"], "actions": behavior_metrics["actions"], + "goal_achieved_count": goal_achieved_count, + "frac_goal_achieved": frac_goal_achieved, + "collided_count": collided_count, + "frac_collided": frac_collided, } ) @@ -137,6 +147,9 @@ def create_dataframe_from_rollouts(rollout_data): """ rows = [] + # Create a separate dataframe to store aggregated metrics per rollout + rollout_metrics = [] + # Process each rollout for data in rollout_data: agent_type = data["agent_type"] @@ -150,11 +163,34 @@ def create_dataframe_from_rollouts(rollout_data): "actions" ] # Shape: [num_envs, max_agents, episode_len, action_dim] + # Get goal and collision metrics + goal_achieved_count = data["goal_achieved_count"] + frac_goal_achieved = data["frac_goal_achieved"] + collided_count = data["collided_count"] + frac_collided = data["frac_collided"] + # Get dimensions num_envs = actions.shape[0] max_agents = actions.shape[1] episode_len = actions.shape[2] + # Store aggregated metrics for this rollout + for env_idx in range(num_envs): + rollout_metrics.append( + { + "agent_type": agent_type, + "rollout_idx": rollout_idx, + "scenario": env_idx, + "goal_achieved_count": goal_achieved_count[env_idx].item(), + "frac_goal_achieved": frac_goal_achieved[env_idx].item(), + "collided_count": collided_count[env_idx].item(), + "frac_collided": frac_collided[env_idx].item(), + "collision_weight": weights[0], + "goal_weight": weights[1], + "off_road_weight": weights[2], + } + ) + # Create rows for all non-zero entries for env_idx in range(num_envs): for agent_idx in range(max_agents): @@ -188,8 +224,9 @@ def create_dataframe_from_rollouts(rollout_data): } rows.append(row) - # Create DataFrame + # Create main DataFrame and metrics DataFrame df = pd.DataFrame(rows) + metrics_df = pd.DataFrame(rollout_metrics) # Print summary print(f"Created DataFrame with {len(df)} rows") @@ -201,9 +238,19 @@ def create_dataframe_from_rollouts(rollout_data): print("\nRows per agent type:") print(df.groupby("agent_type").size()) + # Print goal and collision statistics + print("\nGoal Achievement Rate by Agent Type:") + print(metrics_df.groupby("agent_type")["frac_goal_achieved"].mean()) + + print("\nCollision Rate by Agent Type:") + print(metrics_df.groupby("agent_type")["frac_collided"].mean()) + print("\nSample of DataFrame:") print(df.head()) + # Add the metrics to the main dataframe as a separate attribute + df.metrics = metrics_df + return df @@ -243,10 +290,7 @@ def compare_agent_types(df): ) results["entropy_stats"] = entropy_by_agent - # 3. Create a measure of behavior diversity for each agent type - # Higher entropy and more diverse action choices indicate more diverse behavior - - # Calculate action diversity based on unique combinations of acceleration and steering + # 3. Calculate action diversity based on unique combinations of acceleration and steering df["action_combo"] = ( df["acceleration"].astype(str) + "_" + df["steering"].astype(str) ) @@ -256,52 +300,7 @@ def compare_agent_types(df): .reset_index() ) action_diversity = df_grouped.groupby("agent_type")["action_combo"].mean() - - # Calculate entropy diversity - entropy_diversity = entropy_by_agent["mean"] - - # Combine measures into overall behavior diversity - behavior_diversity = pd.DataFrame( - { - "mean_entropy": entropy_by_agent["mean"], - "action_diversity": action_diversity, - } - ) - - # Normalize and combine (handle case where min = max) - entropy_range = ( - behavior_diversity["mean_entropy"].max() - - behavior_diversity["mean_entropy"].min() - ) - action_range = ( - behavior_diversity["action_diversity"].max() - - behavior_diversity["action_diversity"].min() - ) - - if entropy_range > 1e-10: - behavior_diversity["norm_entropy"] = ( - behavior_diversity["mean_entropy"] - - behavior_diversity["mean_entropy"].min() - ) / entropy_range - else: - behavior_diversity["norm_entropy"] = 0.5 # Constant value if all equal - - if action_range > 1e-10: - behavior_diversity["norm_action_div"] = ( - behavior_diversity["action_diversity"] - - behavior_diversity["action_diversity"].min() - ) / action_range - else: - behavior_diversity[ - "norm_action_div" - ] = 0.5 # Constant value if all equal - - behavior_diversity["overall_diversity"] = ( - behavior_diversity["norm_entropy"] - + behavior_diversity["norm_action_div"] - ) / 2 - - results["behavior_diversity"] = behavior_diversity + results["action_diversity"] = action_diversity # 4. Calculate additional metrics # Average logprob by agent type (measure of confidence) @@ -314,14 +313,29 @@ def compare_agent_types(df): ].mean() results["time_series"] = time_series + # 5. Goal and collision rate analysis + try: + # Try to load separate metrics file + metrics_df = pd.read_csv( + "/home/emerge/gpudrive/agent_type_metrics.csv" + ) + goal_rate = metrics_df.groupby("agent_type")[ + "frac_goal_achieved" + ].mean() + collision_rate = metrics_df.groupby("agent_type")[ + "frac_collided" + ].mean() + + results["goal_rate"] = goal_rate + results["collision_rate"] = collision_rate + except Exception as e: + print(f"Error loading metrics data: {e}") + print("Goal and collision rates won't be included in the results.") + # Print summary of comparison print("\n=== Agent Type Comparison ===") - print("\nBehavioral Diversity (higher = more diverse):") - print( - behavior_diversity[ - ["mean_entropy", "action_diversity", "overall_diversity"] - ].sort_values("overall_diversity", ascending=False) - ) + print("\nPolicy Entropy by Agent Type (higher = more uncertain):") + print(entropy_by_agent["mean"].sort_values(ascending=False)) print("\nAverage Log Probability (higher = more confident):") print(logprob_by_agent) @@ -343,6 +357,14 @@ def compare_agent_types(df): .sort_values(ascending=False) ) + # Goal and collision rates + if "goal_rate" in results: + print("\nAverage Goal Achievement Rate by Agent Type:") + print(results["goal_rate"].sort_values(ascending=False)) + + print("\nAverage Collision Rate by Agent Type:") + print(results["collision_rate"].sort_values(ascending=False)) + # Analyze variation across scenarios scenario_variation = ( df.groupby(["agent_type", "scenario"])[["acceleration", "steering"]] @@ -362,16 +384,16 @@ def compare_agent_types(df): "/home/emerge/gpudrive/baselines/ppo/config/ppo_base_puffer" ) - num_envs = 20 + num_envs = 50 device = "cpu" - max_agents = 2 + max_agents = 64 config.environment.reward_type = "reward_conditioned" config.environment.condition_mode = "fixed" config.environment.agent_type = torch.Tensor([-0.2, 1.0, -0.2]) agent = load_policy( - model_name="model_PPO____R_10000__03_20_17_01_59_614_007000", + model_name="rew_conditioned_0321", path_to_cpt="/home/emerge/gpudrive/examples/experimental/models", env_config=config.environment, device=device, @@ -428,7 +450,9 @@ def compare_agent_types(df): "Risk-averse": torch.tensor([-2.0, 0.5, -2.0], device=device), } - print("Collecting rollout data for all agent types...") + print( + f"Collecting rollout data for all agent types... N = {env.max_cont_agents}" + ) # Collect data for all agent types all_rollout_data = collect_data_for_agent_types( @@ -436,12 +460,17 @@ def compare_agent_types(df): agent=agent, agent_configs=agent_configs, device=device, - num_rollouts_per_agent=10, # Number of times we rollout in the same scenes + num_rollouts_per_agent=3, # Number of times we rollout in the same scenes ) # Convert to DataFrame for analysis df = create_dataframe_from_rollouts(all_rollout_data) + # Analyze agent types comparison_results = compare_agent_types(df) + # Save the data df.to_csv("agent_type_comparison_data.csv", index=False) + df.metrics.to_csv("agent_type_metrics.csv", index=False) + + print("\n Analysis done! Data saved to csv file.") From 6dcd6902d30494d881f9619f91d05ee7796df03b Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Mon, 31 Mar 2025 11:08:05 -0400 Subject: [PATCH 09/81] Merge in main --- gpudrive/visualize/core.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/gpudrive/visualize/core.py b/gpudrive/visualize/core.py index b26303f38..be9af1614 100644 --- a/gpudrive/visualize/core.py +++ b/gpudrive/visualize/core.py @@ -1703,13 +1703,13 @@ def plot_agent_observation( ax.plot( trajectory[:, 0], # x coordinates trajectory[:, 1], # y coordinates - color='blue', # trajectory color - linestyle='-', # solid line - linewidth=1.0, # line width - marker='o', # circular markers at each point - markersize=1, # size of markers - alpha=0.7, # slight transparency - label='Trajectory' # label for legend + color="blue", # trajectory color + linestyle="-", # solid line + linewidth=1.0, # line width + marker="o", # circular markers at each point + markersize=1, # size of markers + alpha=0.7, # slight transparency + label="Trajectory", # label for legend ) ax.set_xlim((-self.env_config.obs_radius, self.env_config.obs_radius)) From d211756eef73e622f6ef72f06764400c3cbded07 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Tue, 1 Apr 2025 11:45:03 -0400 Subject: [PATCH 10/81] wip --- baselines/ppo/config/ppo_base_puffer.yaml | 10 +-- examples/experimental/config/eval_config.yaml | 11 +++- .../experimental/config/model_config.yaml | 2 +- .../experimental/get_model_performance.py | 13 ++-- .../notebooks/04_reward_cond_agents.ipynb | 61 ++++++++++--------- gpudrive/env/config.py | 2 +- gpudrive/networks/late_fusion.py | 1 + gpudrive/utils/env.py | 2 +- src/consts.hpp | 2 +- 9 files changed, 56 insertions(+), 48 deletions(-) diff --git a/baselines/ppo/config/ppo_base_puffer.yaml b/baselines/ppo/config/ppo_base_puffer.yaml index e55462135..7bd99ba38 100644 --- a/baselines/ppo/config/ppo_base_puffer.yaml +++ b/baselines/ppo/config/ppo_base_puffer.yaml @@ -8,8 +8,8 @@ model_cpt: null environment: # Overrides default environment configs (see pygpudrive/env/config.py) name: "gpudrive" - num_worlds: 75 # Number of parallel environments - k_unique_scenes: 75 # Number of unique scenes to sample from + num_worlds: 50 # Number of parallel environments + k_unique_scenes: 50 # Number of unique scenes to sample from max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp ego_state: true road_map_obs: true @@ -17,7 +17,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. norm_obs: true remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists) lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types - reward_type: "weighted_combination" + reward_type: "reward_conditioned" # Options: "weighted_combination", "reward_conditioned" collision_weight: -0.75 off_road_weight: -0.75 goal_achieved_weight: 1.0 @@ -25,7 +25,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. # If reward_type is "reward_conditioned", the following parameters are used condition_mode: random collision_weight_lb: -3.0 - collision_weight_ub: 0.5 + collision_weight_ub: 0.01 goal_achieved_weight_lb: 1.0 goal_achieved_weight_ub: 3.0 off_road_weight_lb: -3.0 @@ -71,7 +71,7 @@ train: # # # PPO # # # torch_deterministic: false - total_timesteps: 1_000_000_000 + total_timesteps: 2_000_000_000 batch_size: 262_144 minibatch_size: 8192 learning_rate: 3e-4 diff --git a/examples/experimental/config/eval_config.yaml b/examples/experimental/config/eval_config.yaml index 48202ab2b..41085195e 100644 --- a/examples/experimental/config/eval_config.yaml +++ b/examples/experimental/config/eval_config.yaml @@ -1,17 +1,17 @@ res_path: examples/experimental/dataframes # Store dataframes here -test_dataset_size: 10_000 # Number of test scenarios to evaluate on +test_dataset_size: 10000 # Number of test scenarios to evaluate on # Environment settings train_dir: data/processed/training test_dir: data/processed/validation -num_worlds: 50 # Number of parallel environments for evaluation +num_worlds: 100 # Number of parallel environments for evaluation max_controlled_agents: 64 # Maximum number of agents controlled by the model. ego_state: true road_map_obs: true partner_obs: true norm_obs: true -remove_non_vehicles: true # If false, all agents are included (vehicles, pedestrians, cyclists) +remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists) lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types reward_type: "weighted_combination" collision_weight: -0.75 @@ -24,8 +24,13 @@ polyline_reduction_threshold: 0.1 # Rate at which to sample points from the poly sampling_seed: 42 # If given, the set of scenes to sample from will be deterministic, if None, the set of scenes will be random obs_radius: 50.0 # Visibility radius of the agents init_roadgraph: False +init_mode: all_valid #all_non_trivial render_3d: True +# Reward conditioning +condition_mode: None +agent_type: None + # Number of discretizations in the action space # Note: Make sure that this equals the discretizations that the policy # has been trained with diff --git a/examples/experimental/config/model_config.yaml b/examples/experimental/config/model_config.yaml index 0f23a2432..e8241b570 100644 --- a/examples/experimental/config/model_config.yaml +++ b/examples/experimental/config/model_config.yaml @@ -2,6 +2,6 @@ models_path: examples/experimental/models models: - name: model_PPO____R_10000__02_27_09_19_10_626_003200 - train_dataset_size: 10_000 + train_dataset_size: 10000 wandb: null trained_on: null \ No newline at end of file diff --git a/examples/experimental/get_model_performance.py b/examples/experimental/get_model_performance.py index 70443d852..c6b84b715 100644 --- a/examples/experimental/get_model_performance.py +++ b/examples/experimental/get_model_performance.py @@ -4,13 +4,13 @@ import numpy as np import os import logging + +from eval_utils import evaluate_policy + +from gpudrive.utils.env import make_env +from gpudrive.utils.config import load_config +from gpudrive.utils.checkpoint import load_policy from gpudrive.env.dataset import SceneDataLoader -from eval_utils import ( - load_config, - make_env, - load_policy, - evaluate_policy, -) import random import torch @@ -52,7 +52,6 @@ def set_seed(seed: int): path_to_cpt=model_config.models_path, model_name=model.name, device=eval_config.device, - env=env, ) # Create dataloaders for train and test sets diff --git a/examples/experimental/notebooks/04_reward_cond_agents.ipynb b/examples/experimental/notebooks/04_reward_cond_agents.ipynb index 625591ac9..925de5ab0 100644 --- a/examples/experimental/notebooks/04_reward_cond_agents.ipynb +++ b/examples/experimental/notebooks/04_reward_cond_agents.ipynb @@ -2,9 +2,20 @@ "cells": [ { "cell_type": "code", - "execution_count": 40, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-04-01 10:24:24.086400: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:477] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "E0000 00:00:1743517464.093552 1825338 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1743517464.095681 1825338 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n" + ] + } + ], "source": [ "import torch\n", "import dataclasses\n", @@ -35,14 +46,14 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'mode': 'train', 'use_rnn': False, 'eval_model_path': None, 'baseline': False, 'data_dir': 'data/processed/training', 'continue_training': False, 'model_cpt': None, 'environment': {'name': 'gpudrive', 'num_worlds': 75, 'k_unique_scenes': 75, 'max_controlled_agents': 64, 'ego_state': True, 'road_map_obs': True, 'partner_obs': True, 'norm_obs': True, 'remove_non_vehicles': False, 'lidar_obs': False, 'reward_type': 'reward_conditioned', 'collision_weight': -0.75, 'off_road_weight': -0.75, 'goal_achieved_weight': 1.0, 'condition_mode': 'random', 'collision_weight_lb': -3.0, 'collision_weight_ub': 0.5, 'goal_achieved_weight_lb': 1.0, 'goal_achieved_weight_ub': 3.0, 'off_road_weight_lb': -3.0, 'off_road_weight_ub': 0.0, 'dynamics_model': 'classic', 'collision_behavior': 'ignore', 'dist_to_goal_threshold': 2.0, 'polyline_reduction_threshold': 0.1, 'sampling_seed': 42, 'obs_radius': 50.0, 'action_space_steer_disc': 13, 'action_space_accel_disc': 7}, 'wandb': {'entity': '', 'project': 'kshotagents', 'group': 'reward_conditioned', 'mode': 'online', 'tags': ['ppo', 'ff']}, 'train': {'exp_id': 'PPO', 'seed': 42, 'cpu_offload': False, 'device': 'cuda', 'bptt_horizon': 1, 'compile': False, 'compile_mode': 'reduce-overhead', 'resample_scenes': True, 'resample_dataset_size': 10000, 'resample_interval': 2000000, 'sample_with_replacement': True, 'shuffle_dataset': False, 'torch_deterministic': False, 'total_timesteps': 2000000000, 'batch_size': 131072, 'minibatch_size': 8192, 'learning_rate': '3e-4', 'anneal_lr': False, 'gamma': 0.99, 'gae_lambda': 0.95, 'update_epochs': 4, 'norm_adv': True, 'clip_coef': 0.2, 'clip_vloss': False, 'vf_clip_coef': 0.2, 'ent_coef': 0.0001, 'vf_coef': 0.3, 'max_grad_norm': 0.5, 'target_kl': None, 'log_window': 1000, 'network': {'input_dim': 64, 'hidden_dim': 128, 'dropout': 0.01, 'class_name': 'NeuralNet', 'num_parameters': 0}, 'checkpoint_interval': 500, 'checkpoint_path': './runs', 'render': False, 'render_3d': True, 'render_interval': 1, 'render_k_scenarios': 10, 'render_format': 'mp4', 'render_fps': 15, 'zoom_radius': 50}, 'vec': {'backend': 'native', 'num_workers': 1, 'env_batch_size': 1, 'zero_copy': False}}\n" + "{'mode': 'train', 'use_rnn': False, 'eval_model_path': None, 'baseline': False, 'data_dir': 'data/processed/training', 'continue_training': False, 'model_cpt': None, 'environment': {'name': 'gpudrive', 'num_worlds': 75, 'k_unique_scenes': 75, 'max_controlled_agents': 64, 'ego_state': True, 'road_map_obs': True, 'partner_obs': True, 'norm_obs': True, 'remove_non_vehicles': False, 'lidar_obs': False, 'reward_type': 'reward_conditioned', 'collision_weight': -0.75, 'off_road_weight': -0.75, 'goal_achieved_weight': 1.0, 'condition_mode': 'random', 'collision_weight_lb': -3.0, 'collision_weight_ub': 0.01, 'goal_achieved_weight_lb': 1.0, 'goal_achieved_weight_ub': 3.0, 'off_road_weight_lb': -3.0, 'off_road_weight_ub': 0.0, 'dynamics_model': 'classic', 'collision_behavior': 'ignore', 'dist_to_goal_threshold': 2.0, 'polyline_reduction_threshold': 0.1, 'sampling_seed': 42, 'obs_radius': 50.0, 'action_space_steer_disc': 13, 'action_space_accel_disc': 7, 'use_vbd': False, 'vbd_model_path': 'gpudrive/integrations/vbd/weights/epoch=18.ckpt', 'init_steps': 11, 'vbd_trajectory_weight': 0.1, 'vbd_in_obs': False}, 'wandb': {'entity': '', 'project': 'kshotagents', 'group': 'reward_conditioned', 'mode': 'online', 'tags': ['ppo', 'ff']}, 'train': {'exp_id': 'PPO', 'seed': 42, 'cpu_offload': False, 'device': 'cuda', 'bptt_horizon': 1, 'compile': False, 'compile_mode': 'reduce-overhead', 'resample_scenes': True, 'resample_dataset_size': 10000, 'resample_interval': 2000000, 'sample_with_replacement': True, 'shuffle_dataset': False, 'torch_deterministic': False, 'total_timesteps': 2000000000, 'batch_size': 262144, 'minibatch_size': 8192, 'learning_rate': '3e-4', 'anneal_lr': False, 'gamma': 0.99, 'gae_lambda': 0.95, 'update_epochs': 4, 'norm_adv': True, 'clip_coef': 0.2, 'clip_vloss': False, 'vf_clip_coef': 0.2, 'ent_coef': 0.0001, 'vf_coef': 0.3, 'max_grad_norm': 0.5, 'target_kl': None, 'log_window': 1000, 'network': {'input_dim': 64, 'hidden_dim': 128, 'dropout': 0.01, 'class_name': 'NeuralNet', 'num_parameters': 0}, 'checkpoint_interval': 500, 'checkpoint_path': './runs', 'render': False, 'render_3d': True, 'render_interval': 1, 'render_k_scenarios': 10, 'render_format': 'mp4', 'render_fps': 15, 'zoom_radius': 50}, 'vec': {'backend': 'native', 'num_workers': 1, 'env_batch_size': 1, 'zero_copy': False}}\n" ] } ], @@ -63,28 +74,20 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 5, "metadata": {}, "outputs": [ { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: '/home/emerge/gpudrive/examples/experimental/models/rew_conditioned_0321.pt.pt'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[42], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m agent \u001b[38;5;241m=\u001b[39m \u001b[43mload_policy\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrew_conditioned_0321.pt\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mpath_to_cpt\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m/home/emerge/gpudrive/examples/experimental/models\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43menv_config\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43menvironment\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdevice\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m)\u001b[49m;\n", - "File \u001b[0;32m~/gpudrive/gpudrive/utils/checkpoint.py:10\u001b[0m, in \u001b[0;36mload_policy\u001b[0;34m(path_to_cpt, model_name, device, env_config)\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Load a policy from a given path.\"\"\"\u001b[39;00m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;66;03m# Load a trained model\u001b[39;00m\n\u001b[0;32m---> 10\u001b[0m saved_cpt \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43mf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mpath_to_cpt\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m/\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mmodel_name\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m.pt\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 12\u001b[0m \u001b[43m \u001b[49m\u001b[43mmap_location\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdevice\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 13\u001b[0m \u001b[43m \u001b[49m\u001b[43mweights_only\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 14\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 16\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mLoad model from \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mpath_to_cpt\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodel_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.pt\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 18\u001b[0m \u001b[38;5;66;03m# Create policy architecture from saved checkpoint\u001b[39;00m\n", - "File \u001b[0;32m~/.pyenv/versions/gpudrive/lib/python3.11/site-packages/torch/serialization.py:1425\u001b[0m, in \u001b[0;36mload\u001b[0;34m(f, map_location, pickle_module, weights_only, mmap, **pickle_load_args)\u001b[0m\n\u001b[1;32m 1422\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mencoding\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m pickle_load_args\u001b[38;5;241m.\u001b[39mkeys():\n\u001b[1;32m 1423\u001b[0m pickle_load_args[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mencoding\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mutf-8\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m-> 1425\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[43m_open_file_like\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrb\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m opened_file:\n\u001b[1;32m 1426\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m _is_zipfile(opened_file):\n\u001b[1;32m 1427\u001b[0m \u001b[38;5;66;03m# The zipfile reader is going to advance the current file position.\u001b[39;00m\n\u001b[1;32m 1428\u001b[0m \u001b[38;5;66;03m# If we want to actually tail call to torch.jit.load, we need to\u001b[39;00m\n\u001b[1;32m 1429\u001b[0m \u001b[38;5;66;03m# reset back to the original position.\u001b[39;00m\n\u001b[1;32m 1430\u001b[0m orig_position \u001b[38;5;241m=\u001b[39m opened_file\u001b[38;5;241m.\u001b[39mtell()\n", - "File \u001b[0;32m~/.pyenv/versions/gpudrive/lib/python3.11/site-packages/torch/serialization.py:751\u001b[0m, in \u001b[0;36m_open_file_like\u001b[0;34m(name_or_buffer, mode)\u001b[0m\n\u001b[1;32m 749\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21m_open_file_like\u001b[39m(name_or_buffer, mode):\n\u001b[1;32m 750\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m _is_path(name_or_buffer):\n\u001b[0;32m--> 751\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_open_file\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 752\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 753\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mw\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m mode:\n", - "File \u001b[0;32m~/.pyenv/versions/gpudrive/lib/python3.11/site-packages/torch/serialization.py:732\u001b[0m, in \u001b[0;36m_open_file.__init__\u001b[0;34m(self, name, mode)\u001b[0m\n\u001b[1;32m 731\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, name, mode):\n\u001b[0;32m--> 732\u001b[0m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m)\u001b[49m)\n", - "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/home/emerge/gpudrive/examples/experimental/models/rew_conditioned_0321.pt.pt'" + "name": "stdout", + "output_type": "stream", + "text": [ + "Load model from /home/emerge/gpudrive/examples/experimental/models/model_PPO____R_10000__03_19_19_05_33_518_006000.pt\n" ] } ], "source": [ "agent = load_policy(\n", - " model_name=\"rew_conditioned_0321.pt\",\n", + " model_name=\"model_PPO____R_10000__03_19_19_05_33_518_006000\",\n", " path_to_cpt=\"/home/emerge/gpudrive/examples/experimental/models\",\n", " env_config=config.environment,\n", " device=device\n", @@ -93,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -140,7 +143,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -260,7 +263,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -274,14 +277,14 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Running 20 rollouts, sampling weights: collision=True, goal=False, offroad=False\n", + "Running 50 rollouts, sampling weights: collision=True, goal=False, offroad=False\n", "\n" ] }, @@ -289,7 +292,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Processing rollouts: 100%|██████████| 20/20 [00:18<00:00, 1.09rollout/s]\n" + "Processing rollouts: 100%|██████████| 50/50 [01:07<00:00, 1.35s/rollout]\n" ] } ], @@ -297,7 +300,7 @@ "trajs = run_multiple_rollouts(\n", " env=env,\n", " agent=agent,\n", - " num_rollouts=20,\n", + " num_rollouts=50,\n", " device='cpu',\n", " sample_collision_weights=True,\n", " sample_goal_weights=False,\n", @@ -308,18 +311,18 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/jpeg": "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", - "image/png": "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", + "image/jpeg": "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", + "image/png": "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", "text/plain": [ "" ] }, - "execution_count": 61, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index 43d25792a..80b4f603b 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -135,7 +135,7 @@ class EnvConfig: # Initialization mode init_mode: str = ( - "all_non_trivial" # Options: all_non_trivial, all_objects, all_valid + "all_non_trivial" # Options: all_non_trivial, all_objects, all_valid, womd_tracks_to_predict ) # VBD model settings diff --git a/gpudrive/networks/late_fusion.py b/gpudrive/networks/late_fusion.py index aa14b3e36..2b6000236 100644 --- a/gpudrive/networks/late_fusion.py +++ b/gpudrive/networks/late_fusion.py @@ -94,6 +94,7 @@ def __init__( self.num_modes = 3 # Ego, partner, road graph self.dropout = dropout self.act_func = nn.Tanh() if act_func == "tanh" else nn.GELU() + self.vbd_in_obs = False # Indices for unpacking the observation self.ego_state_idx = constants.EGO_FEAT_DIM diff --git a/gpudrive/utils/env.py b/gpudrive/utils/env.py index 6616a8d04..53aa7e8f9 100644 --- a/gpudrive/utils/env.py +++ b/gpudrive/utils/env.py @@ -34,9 +34,9 @@ def make_env(config, train_loader): torch.linspace(-4.0, 4.0, config.action_space_accel_disc), decimals=3, ), - reward_type=config.reward_type, condition_mode=config.condition_mode, agent_type=config.agent_type, + init_mode=config.init_mode, ) render_config = RenderConfig() diff --git a/src/consts.hpp b/src/consts.hpp index 16adadb3c..41d7a5282 100644 --- a/src/consts.hpp +++ b/src/consts.hpp @@ -22,7 +22,7 @@ inline constexpr float worldLength = 40.f; // This factor rescales the length of the vehicles by a tiny amount // To account for the fact that noise occasionally puts vehicles into initial // collisions. This is a dataset artifact that we are handling here like this. -inline constexpr float vehicleLengthScale = 0.8f; +inline constexpr float vehicleLengthScale = 0.7f; // Each unit of distance forward (+ y axis) rewards the agents by this amount inline constexpr float rewardPerDist = 0.05f; From feacdf700a3d88c042de8e74125feef20e8d08e4 Mon Sep 17 00:00:00 2001 From: daphnecor Date: Tue, 1 Apr 2025 15:26:35 -0400 Subject: [PATCH 11/81] Sync --- .env.template | 13 --- baselines/ppo/config/ppo_population.yaml | 117 +++++++++++++++++++++++ baselines/ppo/ppo_pufferlib.py | 4 +- gpudrive/env/env_torch.py | 6 +- gpudrive/utils/generate_sbatch.py | 35 +------ pyproject.toml | 1 + 6 files changed, 128 insertions(+), 48 deletions(-) delete mode 100644 .env.template create mode 100644 baselines/ppo/config/ppo_population.yaml diff --git a/.env.template b/.env.template deleted file mode 100644 index 431883d8b..000000000 --- a/.env.template +++ /dev/null @@ -1,13 +0,0 @@ -# .env template - -# Path for logs -LOG_FOLDER= - -# Your HPC account code -NYU_HPC_ACCOUNT= - -# NYU ID -USERNAME= - -SINGULARITY_IMAGE= -OVERLAY_FILE= \ No newline at end of file diff --git a/baselines/ppo/config/ppo_population.yaml b/baselines/ppo/config/ppo_population.yaml new file mode 100644 index 000000000..c40cb6008 --- /dev/null +++ b/baselines/ppo/config/ppo_population.yaml @@ -0,0 +1,117 @@ +mode: "train" +use_rnn: false +eval_model_path: null +baseline: false +data_dir: /scratch/kj2676/gpudrive/data/processed/training +continue_training: false +model_cpt: null + +environment: # Overrides default environment configs (see pygpudrive/env/config.py) + name: "gpudrive" + num_worlds: 75 # Number of parallel environments + k_unique_scenes: 75 # Number of unique scenes to sample from + max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp + ego_state: true + road_map_obs: true + partner_obs: true + norm_obs: true + remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists) + lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types + reward_type: "reward_conditioned" + collision_weight: -0.75 + off_road_weight: -0.75 + goal_achieved_weight: 1.0 + + # If reward_type is "reward_conditioned", the following parameters are used + condition_mode: random + collision_weight_lb: -3.0 + collision_weight_ub: 0.01 + goal_achieved_weight_lb: 1.0 + goal_achieved_weight_ub: 3.0 + off_road_weight_lb: -3.0 + off_road_weight_ub: 0.01 + + dynamics_model: "classic" + collision_behavior: "ignore" # Options: "remove", "stop", "ignore" + dist_to_goal_threshold: 2.0 + polyline_reduction_threshold: 0.1 # Rate at which to sample points from the polyline (0 is use all closest points, 1 maximum sparsity), needs to be balanced with kMaxAgentMapObservationsCount + sampling_seed: 42 # If given, the set of scenes to sample from will be deterministic, if None, the set of scenes will be random + obs_radius: 50.0 # Visibility radius of the agents + action_space_steer_disc: 13 + action_space_accel_disc: 7 + # Versatile Behavior Diffusion (VBD): This will slow down training + use_vbd: false + vbd_model_path: "gpudrive/integrations/vbd/weights/epoch=18.ckpt" + init_steps: 11 + vbd_trajectory_weight: 0.1 # Importance of distance to the vbd trajectories in the reward function + vbd_in_obs: false + +wandb: + entity: "" + project: "kshotagents" + group: "reward_conditioned" + mode: "online" # Options: online, offline, disabled + tags: ["ppo", "ff"] + +train: + exp_id: # Set dynamically in the script if needed + seed: 42 + cpu_offload: false + device: "cuda" # Dynamically set to cuda if available, else cpu + bptt_horizon: 1 + compile: false + compile_mode: "reduce-overhead" + + # # # Data sampling # # # + resample_scenes: true + resample_dataset_size: 10_000 # Number of unique scenes to sample from + resample_interval: 2_000_000 + sample_with_replacement: true + shuffle_dataset: false + + # # # PPO # # # + torch_deterministic: false + total_timesteps: 1_000_000_000 + batch_size: 262_144 + minibatch_size: 8192 + learning_rate: 3e-4 + anneal_lr: false + gamma: 0.99 + gae_lambda: 0.95 + update_epochs: 4 + norm_adv: true + clip_coef: 0.2 + clip_vloss: false + vf_clip_coef: 0.2 + ent_coef: 0.0001 + vf_coef: 0.3 + max_grad_norm: 0.5 + target_kl: null + log_window: 1000 + + # # # Network # # # + network: + input_dim: 64 # Embedding of the input features + hidden_dim: 128 # Latent dimension + dropout: 0.01 + class_name: "NeuralNet" + num_parameters: 0 # Total trainable parameters, to be filled at runtime + + # # # Checkpointing # # # + checkpoint_interval: 500 # Save policy every k iterations + checkpoint_path: "./runs" + + # # # Rendering # # # + render: false # Determines whether to render the environment (note: will slow down training) + render_3d: true # Render simulator state in 3d or 2d + render_interval: 1 # Render every k iterations + render_k_scenarios: 10 # Number of scenarios to render + render_format: "mp4" # Options: gif, mp4 + render_fps: 15 # Frames per second + zoom_radius: 50 + +vec: + backend: "native" # Only native is currently supported + num_workers: 1 + env_batch_size: 1 + zero_copy: false diff --git a/baselines/ppo/ppo_pufferlib.py b/baselines/ppo/ppo_pufferlib.py index 587fb96c9..560aa03b9 100644 --- a/baselines/ppo/ppo_pufferlib.py +++ b/baselines/ppo/ppo_pufferlib.py @@ -156,11 +156,12 @@ def sweep(args, project="PPO", sweep_name="my_sweep"): def run( config_path: Annotated[ str, typer.Argument(help="The path to the default configuration file") - ] = "baselines/ppo/config/ppo_base_puffer.yaml", + ] = "baselines/ppo/config/ppo_population.yaml", *, # fmt: off # Environment options num_worlds: Annotated[Optional[int], typer.Option(help="Number of parallel envs")] = None, + max_controlled_agents: Annotated[Optional[int], typer.Option(help="Number of controlled agents")] = None, k_unique_scenes: Annotated[Optional[int], typer.Option(help="The number of unique scenes to sample")] = None, collision_weight: Annotated[Optional[float], typer.Option(help="The weight for collision penalty")] = None, off_road_weight: Annotated[Optional[float], typer.Option(help="The weight for off-road penalty")] = None, @@ -204,6 +205,7 @@ def run( # Override configs with command-line arguments env_config = { "num_worlds": num_worlds, + "max_controlled_agents": max_controlled_agents, "k_unique_scenes": k_unique_scenes, "collision_weight": collision_weight, "off_road_weight": off_road_weight, diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 7cdc241ce..de00920d1 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -33,9 +33,6 @@ from gpudrive.env.dataset import SceneDataLoader from gpudrive.utils.geometry import normalize_min_max -# Versatile Behavior Diffusion model -from gpudrive.integrations.vbd.sim_agent.sim_actor import VBDTest - class GPUDriveTorchEnv(GPUDriveGymEnv): """Torch Gym Environment that interfaces with the GPU Drive simulator.""" @@ -141,6 +138,9 @@ def _initialize_vbd(self): """ # Set VBD configuration parameters self.use_vbd = self.config.use_vbd + if self.use_vbd: + # Versatile Behavior Diffusion model + from gpudrive.integrations.vbd.sim_agent.sim_actor import VBDTest self.vbd_trajectory_weight = self.config.vbd_trajectory_weight # Set initialization steps - ensure minimum steps for VBD diff --git a/gpudrive/utils/generate_sbatch.py b/gpudrive/utils/generate_sbatch.py index 95850cca3..bcac4761f 100644 --- a/gpudrive/utils/generate_sbatch.py +++ b/gpudrive/utils/generate_sbatch.py @@ -62,7 +62,7 @@ #SBATCH --account={account} SINGULARITY_IMAGE={singularity_image} -OVERLAY_FILE=/scratch/{username}/{overlay_file} +OVERLAY_FILE={overlay_file} singularity exec --nv --overlay "${{OVERLAY_FILE}}:ro" \ "${{SINGULARITY_IMAGE}}" \ @@ -243,7 +243,7 @@ def save_script(filename, file_path, fields, params, param_order=None): if __name__ == "__main__": - group = "02_24_S10_000" + group = "04_01" fields = { "time_h": 47, # Max time per job (job will finish if run is done before) @@ -258,15 +258,15 @@ def save_script(filename, file_path, fields, params, param_order=None): "num_worlds": [800], "resample_scenes": [1], # Yes "k_unique_scenes": [800], + "max_controlled_agents": [64, 1], "resample_interval": [5_000_000], "total_timesteps": [4_000_000_000], "resample_dataset_size": [10_000], "batch_size": [524288], "minibatch_size": [16384], "update_epochs": [4], - "ent_coef": [0.001, 0.003, 0.0001], + "ent_coef": [0.001, 0.0001], "render": [0], - #"seed": [42, 3], } save_script( @@ -275,30 +275,3 @@ def save_script(filename, file_path, fields, params, param_order=None): fields=fields, params=hyperparams, ) - - # hyperparams = { - # "group": [group], # Group name - # "num_worlds": [800], - # "resample_scenes": [1], # Yes - # "k_unique_scenes": [1000], # Sample in batches of 500 - # "resample_interval": [2_000_000], - # "total_timesteps": [3_000_000_000], - # "resample_dataset_size": [1000], - # "batch_size": [262_144, 524_288], - # "minibatch_size": [16_384], - # "update_epochs": [2, 4, 5], - # "ent_coef": [0.0001, 0.001, 0.003], - # "learning_rate": [1e-4, 3e-4], - # "gamma": [0.99], - # "render": [0], - # } - - # save_script( - # file_path="examples/experimental/sbatch_scripts/", - # filename=f"sbatch_{group}.sh", - # fields=fields, - # params=hyperparams, - # ) - - - diff --git a/pyproject.toml b/pyproject.toml index d476b0b31..42ce8c817 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -36,6 +36,7 @@ dependencies = [ "seaborn", "safetensors", "python-box", + "lightning", ] [project.optional-dependencies] From 122e0f8376764320fa2b46bf17624ed913fdd83c Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Tue, 1 Apr 2025 18:28:00 -0400 Subject: [PATCH 12/81] Implement waypoint following agent --- baselines/ppo/config/ppo_population.yaml | 37 +++--- gpudrive/env/base_env.py | 25 ++-- gpudrive/env/config.py | 6 +- gpudrive/env/env_puffer.py | 3 + gpudrive/env/env_torch.py | 52 ++++++-- gpudrive/utils/compatible.py | 154 +++++++++++++++++++++++ gpudrive/visualize/core.py | 18 +-- 7 files changed, 246 insertions(+), 49 deletions(-) create mode 100644 gpudrive/utils/compatible.py diff --git a/baselines/ppo/config/ppo_population.yaml b/baselines/ppo/config/ppo_population.yaml index c40cb6008..00463efff 100644 --- a/baselines/ppo/config/ppo_population.yaml +++ b/baselines/ppo/config/ppo_population.yaml @@ -2,14 +2,14 @@ mode: "train" use_rnn: false eval_model_path: null baseline: false -data_dir: /scratch/kj2676/gpudrive/data/processed/training +data_dir: data/processed/examples continue_training: false model_cpt: null environment: # Overrides default environment configs (see pygpudrive/env/config.py) name: "gpudrive" - num_worlds: 75 # Number of parallel environments - k_unique_scenes: 75 # Number of unique scenes to sample from + num_worlds: 50 # Number of parallel environments + k_unique_scenes: 50 # Number of unique scenes to sample from max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp ego_state: true road_map_obs: true @@ -17,7 +17,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. norm_obs: true remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists) lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types - reward_type: "reward_conditioned" + reward_type: "follow_waypoints" #"reward_conditioned" collision_weight: -0.75 off_road_weight: -0.75 goal_achieved_weight: 1.0 @@ -39,22 +39,22 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. obs_radius: 50.0 # Visibility radius of the agents action_space_steer_disc: 13 action_space_accel_disc: 7 + init_steps: 0 # Warmup steps # Versatile Behavior Diffusion (VBD): This will slow down training - use_vbd: false + use_vbd: true vbd_model_path: "gpudrive/integrations/vbd/weights/epoch=18.ckpt" - init_steps: 11 vbd_trajectory_weight: 0.1 # Importance of distance to the vbd trajectories in the reward function - vbd_in_obs: false + vbd_in_obs: true wandb: entity: "" project: "kshotagents" - group: "reward_conditioned" + group: "04_01" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] train: - exp_id: # Set dynamically in the script if needed + exp_id: human # Set dynamically in the script if needed seed: 42 cpu_offload: false device: "cuda" # Dynamically set to cuda if available, else cpu @@ -63,7 +63,7 @@ train: compile_mode: "reduce-overhead" # # # Data sampling # # # - resample_scenes: true + resample_scenes: false resample_dataset_size: 10_000 # Number of unique scenes to sample from resample_interval: 2_000_000 sample_with_replacement: true @@ -71,8 +71,8 @@ train: # # # PPO # # # torch_deterministic: false - total_timesteps: 1_000_000_000 - batch_size: 262_144 + total_timesteps: 2_000_000_000 + batch_size: 131072 minibatch_size: 8192 learning_rate: 3e-4 anneal_lr: false @@ -102,13 +102,14 @@ train: checkpoint_path: "./runs" # # # Rendering # # # - render: false # Determines whether to render the environment (note: will slow down training) - render_3d: true # Render simulator state in 3d or 2d - render_interval: 1 # Render every k iterations - render_k_scenarios: 10 # Number of scenarios to render + render: true # Determines whether to render the environment (note: will slow down training) + render_3d: false # Render simulator state in 3d or 2d + render_interval: 50 # Render every k iterations + render_k_scenarios: 2 # Number of scenarios to render render_format: "mp4" # Options: gif, mp4 - render_fps: 15 # Frames per second - zoom_radius: 50 + render_fps: 20 # Frames per second + zoom_radius: 100 + plot_waypoints: true vec: backend: "native" # Only native is currently supported diff --git a/gpudrive/env/base_env.py b/gpudrive/env/base_env.py index f67703abd..fc9fc0e9c 100755 --- a/gpudrive/env/base_env.py +++ b/gpudrive/env/base_env.py @@ -3,6 +3,7 @@ import madrona_gpudrive import abc + class GPUDriveGymEnv(gym.Env, metaclass=abc.ABCMeta): def __init__(self, backend="torch"): super().__init__() @@ -61,10 +62,12 @@ def _set_reward_params(self): if ( self.config.reward_type == "sparse_on_goal_achieved" or self.config.reward_type == "weighted_combination" - or self.config.reward_type == "distance_to_logs" + or self.config.reward_type == "follow_waypoints" or self.config.reward_type == "reward_conditioned" ): - reward_params.rewardType = madrona_gpudrive.RewardType.OnGoalAchieved + reward_params.rewardType = ( + madrona_gpudrive.RewardType.OnGoalAchieved + ) else: raise ValueError(f"Invalid reward type: {self.config.reward_type}") @@ -108,22 +111,22 @@ def _setup_environment_parameters(self): ) params = madrona_gpudrive.Parameters() - + params.polylineReductionThreshold = ( self.config.polyline_reduction_threshold ) params.rewardParams = self._set_reward_params() params.maxNumControlledAgents = self.max_cont_agents if self.config.init_mode == "womd_tracks_to_predict": - # Bypasses all gpudrive initialization rules and directly reads from the tracks_to_predict + # Bypasses all gpudrive initialization rules and directly reads from the tracks_to_predict # flag in the WOMD dataset metadata params.readFromTracksToPredict = True elif self.config.init_mode == "all_objects": params.isStaticAgentControlled = True params.initOnlyValidAgentsAtFirstStep = False params.IgnoreNonVehicles = False - elif self.config.init_mode == "all_valid": - params.isStaticAgentControlled = True + elif self.config.init_mode == "all_valid": + params.isStaticAgentControlled = True params.initOnlyValidAgentsAtFirstStep = True params.IgnoreNonVehicles = self.config.remove_non_vehicles elif self.config.init_mode == "all_non_trivial": @@ -132,7 +135,7 @@ def _setup_environment_parameters(self): params.IgnoreNonVehicles = self.config.remove_non_vehicles else: raise ValueError(f"Invalid init mode: {self.config.init_mode}") - + params.dynamicsModel = self.dynamics_model_dict[ self.config.dynamics_model ] @@ -217,13 +220,17 @@ def _set_collision_behavior(self, params): object: Updated parameters with collision behavior settings. """ if self.config.collision_behavior == "ignore": - params.collisionBehaviour = madrona_gpudrive.CollisionBehaviour.Ignore + params.collisionBehaviour = ( + madrona_gpudrive.CollisionBehaviour.Ignore + ) elif self.config.collision_behavior == "remove": params.collisionBehaviour = ( madrona_gpudrive.CollisionBehaviour.AgentRemoved ) elif self.config.collision_behavior == "stop": - params.collisionBehaviour = madrona_gpudrive.CollisionBehaviour.AgentStop + params.collisionBehaviour = ( + madrona_gpudrive.CollisionBehaviour.AgentStop + ) else: raise ValueError( f"Invalid collision behavior: {self.config.collision_behavior}" diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index 80b4f603b..2c38ca419 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -99,7 +99,7 @@ class EnvConfig: # Reward settings reward_type: str = "sparse_on_goal_achieved" - # Alternatively, "weighted_combination", "distance_to_logs", "distance_to_vdb_trajs", "reward_conditioned" + # Alternatively, "weighted_combination", "follow_waypoints", "distance_to_vdb_trajs", "reward_conditioned" condition_mode: str = "random" # Options: "random", "fixed", "preset" @@ -134,9 +134,7 @@ class EnvConfig: num_lidar_samples: int = madrona_gpudrive.numLidarSamples # Initialization mode - init_mode: str = ( - "all_non_trivial" # Options: all_non_trivial, all_objects, all_valid, womd_tracks_to_predict - ) + init_mode: str = "all_non_trivial" # Options: all_non_trivial, all_objects, all_valid, womd_tracks_to_predict # VBD model settings use_vbd: bool = False diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 811971cf6..5805dc966 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -66,6 +66,7 @@ def __init__( render_format="mp4", render_fps=15, zoom_radius=50, + plot_waypoints=False, buf=None, **kwargs, ): @@ -97,6 +98,7 @@ def __init__( self.render_format = render_format self.render_fps = render_fps self.zoom_radius = zoom_radius + self.plot_waypoints = plot_waypoints # VBD self.vbd_model_path = vbd_model_path @@ -428,6 +430,7 @@ def render_env(self): env_indices=envs_to_render, time_steps=time_steps, zoom_radius=self.zoom_radius, + plot_waypoints=self.plot_waypoints, ) for idx, render_env_idx in enumerate(envs_to_render): diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index de00920d1..28128708a 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -138,9 +138,6 @@ def _initialize_vbd(self): """ # Set VBD configuration parameters self.use_vbd = self.config.use_vbd - if self.use_vbd: - # Versatile Behavior Diffusion model - from gpudrive.integrations.vbd.sim_agent.sim_actor import VBDTest self.vbd_trajectory_weight = self.config.vbd_trajectory_weight # Set initialization steps - ensure minimum steps for VBD @@ -180,6 +177,9 @@ def _initialize_vbd(self): def _load_vbd_model(self, model_path): """Load the Versatile Behavior Diffusion (VBD) model from checkpoint.""" + from gpudrive.integrations.vbd.sim_agent.sim_actor import VBDTest + + # Versatile Behavior Diffusion model model = VBDTest.load_from_checkpoint( model_path, torch.device(self.device) ) @@ -487,7 +487,7 @@ def get_rewards( goal_achieved_weight=1.0, off_road_weight=-0.5, world_time_steps=None, - log_distance_weight=0.01, + waypoint_radius=1.0, ): """Obtain the rewards for the current step. By default, the reward is a weighted combination of the following components: @@ -578,9 +578,12 @@ def get_rewards( return weighted_rewards - elif self.config.reward_type == "distance_to_logs": - # Reward based on distance to logs and penalty for collision - weighted_rewards = ( + elif self.config.reward_type == "follow_waypoints": + # Reward based on proximity to waypoints within a radius and penalty for collision/off-road + # With maximum reward of 0.1 per time step + + # Calculate base weighted rewards (penalties) + base_rewards = ( collision_weight * collided + goal_achieved_weight * goal_achieved + off_road_weight * off_road @@ -610,11 +613,38 @@ def get_rewards( [agent_state.pos_x, agent_state.pos_y], dim=-1 ) - # compute euclidean distance between agent and logs - dist_to_logs = torch.norm(log_traj_pos_tensor - agent_pos, dim=-1) + # Compute euclidean distance between agent and waypoints + dist_to_waypoints = torch.norm( + log_traj_pos_tensor - agent_pos, dim=-1 + ) + + # Create proximity reward based on waypoint_radius + # Only reward agents within the waypoint radius + # Smoothly increases as agent gets closer to the center + proximity_mask = (dist_to_waypoints <= waypoint_radius).float() - # add reward based on inverse distance to logs - weighted_rewards += log_distance_weight * torch.exp(-dist_to_logs) + # Normalized distance within the radius (1.0 at center, 0.0 at radius) + normalized_proximity = proximity_mask * ( + 1.0 - (dist_to_waypoints / waypoint_radius) + ) + + # Calculate weighted rewards but normalize to max of 0.1 per time step + waypoint_weight = 0.5 + + # Compute the raw weighted rewards + raw_weighted_rewards = (0.5 * base_rewards) + ( + waypoint_weight * normalized_proximity + ) + + # Scale down to ensure maximum is 0.1 per time step + # First ensure rewards are non-negative (for scaling purposes) + non_negative_rewards = torch.clamp(raw_weighted_rewards, min=0.0) + + # Scale down to max of 0.1 + weighted_rewards = 0.1 * ( + non_negative_rewards + / torch.clamp(torch.max(non_negative_rewards), min=1.0) + ) return weighted_rewards diff --git a/gpudrive/utils/compatible.py b/gpudrive/utils/compatible.py new file mode 100644 index 000000000..32ff89f8c --- /dev/null +++ b/gpudrive/utils/compatible.py @@ -0,0 +1,154 @@ +from tqdm import tqdm +import torch +import pandas as pd + +from gpudrive.utils.config import load_config +from gpudrive.utils.rollout import rollout +from gpudrive.utils.env import make +from gpudrive.utils.checkpoint import make_agent + +RESULTS_DIR = "ada/eval/notebooks/results" + + +def get_compatibility_scores( + env, + agent, + data_loader, + num_rollouts, + device, + identifier, + deterministic=False, + render_sim_state=False, +): + """Evaluate policy in the environment.""" + + res_dict = { + "scene": [], + "goal_achieved_count": [], + "goal_achieved_frac": [], + "collided_count": [], + "collided_frac": [], + "off_road_count": [], + "off_road_frac": [], + "other_count": [], + "other_frac": [], + "num_controlled": [], + "episode_lengths": [], + } + + pbar = tqdm( + range(num_rollouts), + desc="Rollout", + total=num_rollouts, + colour="green", + ) + + for rollout_idx in pbar: + pbar.set_description( + f"Rollout {rollout_idx + 1}/{num_rollouts}, Batch size: {env.num_worlds}" + ) + + # Update simulator with the new batch of data + env.swap_data_batch() + + # Rollout policy in the environments + ( + goal_achieved_count, + goal_achieved_frac, + collided_count, + collided_frac, + off_road_count, + off_road_frac, + other_count, + other_frac, + controlled_agents_in_scene, + sim_state_frames, + agent_positions, + episode_lengths, + ) = rollout( + env=env, + policy=agent, + device=device, + deterministic=deterministic, + render_sim_state=render_sim_state, + ) + + # Get names from env + scenario_to_worlds_dict = env.get_env_filenames() + + res_dict["scene"].extend(scenario_to_worlds_dict.values()) + res_dict["goal_achieved_count"].extend( + goal_achieved_count.cpu().numpy() + ) + res_dict["goal_achieved_frac"].extend(goal_achieved_frac.cpu().numpy()) + + res_dict["collided_count"].extend(collided_count.cpu().numpy()) + res_dict["collided_frac"].extend(collided_frac.cpu().numpy()) + + res_dict["off_road_count"].extend(off_road_count.cpu().numpy()) + res_dict["off_road_frac"].extend(off_road_frac.cpu().numpy()) + + res_dict["other_count"].extend(other_count.cpu().numpy()) + res_dict["other_frac"].extend(other_frac.cpu().numpy()) + res_dict["num_controlled"].extend( + controlled_agents_in_scene.cpu().numpy() + ) + res_dict["episode_lengths"].extend(episode_lengths.cpu().numpy()) + + # Convert to pandas dataframe + df_res = pd.DataFrame(res_dict) + df_res["Class"] = identifier + + print(f"\n Evaluated in {df_res.scene.nunique()} unique scenes.") + + return df_res + + +if __name__ == "__main__": + # config = load_config("config/ada/eval/sp_cross_play") + config = load_config("config/exp/pop_play_rew_cond_flat") + EXP_ID = "rew_cond" + + # Set maximum number of agents that policy controls + + # Analysis settings + config.data_dir = "/home/emerge/gpudrive/data/processed/training" + config.num_worlds = 100 + config.dataset_size = 500 + config.sample_with_replacement = True + config.num_rollouts = 10 + config.max_controlled_agents = 64 + config.condition_mode = "fixed" + config.device = "cuda" + # config.agent_type = torch.Tensor([-0.75, 1.0, -0.75]) + + env = make(config) + + # Load sim agent trained through naive self-play + POLICY = "models/baselines/model_pop_play_rew_cond___S_500__03_16_10_41_19_391_007522.pt" + print(f"Loading policy: {POLICY} \n") + cpt = torch.load(POLICY, map_location=config.device, weights_only=False) + agent = make_agent(cpt, config, device=config.device) + # Load sim agent trained through naive self-play + # agent = NeuralNet.from_pretrained( + # "daphne-cornelisse/policy_S10_000_02_27" + # ).to(config.device) + + df = get_compatibility_scores( + env=env, + agent=agent, + data_loader=env.data_loader, + num_rollouts=config.num_rollouts, + device=config.device, + identifier=f"{EXP_ID}_{config.max_controlled_agents}", + ) + df = df.dropna() + + df.to_csv( + f"{RESULTS_DIR}/compatibility_scores_{config.max_controlled_agents}.csv", + index=False, + ) + + print(f"goal_achieved: {df['goal_achieved_frac'].mean()*100:.2f}") + print(f"collided: {df['collided_frac'].mean()*100:.2f}") + print(f"off_road: {df['off_road_frac'].mean()*100:.2f}") \ No newline at end of file diff --git a/gpudrive/visualize/core.py b/gpudrive/visualize/core.py index be9af1614..0273e966d 100644 --- a/gpudrive/visualize/core.py +++ b/gpudrive/visualize/core.py @@ -98,7 +98,7 @@ def plot_simulator_state( time_steps: Optional[List[int]] = None, center_agent_indices: Optional[List[int]] = None, zoom_radius: int = 100, - plot_log_replay_trajectory: bool = False, + plot_waypoints: bool = False, agent_positions: Optional[torch.Tensor] = None, backward_goals: bool = False, policy_masks: Optional[Dict[int, Dict[str, torch.Tensor]]] = None, @@ -118,7 +118,7 @@ def plot_simulator_state( center_agent_indices: Optional list of center agent indices for zooming. figsize: Tuple for figure size of each subplot. zoom_radius: Radius for zooming in around the center agent. - plot_log_replay_trajectory: If True, plots the log replay trajectory. + plot_waypoints: If True, plots the waypoints from the human replays. agent_positions: Optional tensor to plot rolled out agent positions. backward_goals: If True, plots backward goals for controlled agents. policy_mask: dict @@ -300,8 +300,8 @@ def plot_simulator_state( marker_size_scale=marker_scale, ) - if plot_log_replay_trajectory: - self._plot_log_replay_trajectory( + if plot_waypoints: + self._plot_waypoints( ax=ax, control_mask=controlled_live, env_idx=env_idx, @@ -609,7 +609,7 @@ def plot_agent_trajectories( return None - def _plot_log_replay_trajectory( + def _plot_waypoints( self, ax: matplotlib.axes.Axes, env_idx: int, @@ -683,8 +683,12 @@ def _plot_log_replay_trajectory( else: # Original 2D plotting ax.scatter( - log_trajectory.pos_xy[env_idx, control_mask, :, 0].numpy(), - log_trajectory.pos_xy[env_idx, control_mask, :, 1].numpy(), + log_trajectory.pos_xy[env_idx, control_mask, :, 0] + .cpu() + .numpy(), + log_trajectory.pos_xy[env_idx, control_mask, :, 1] + .cpu() + .numpy(), color="lightgreen", linewidth=0.35 * line_width_scale, alpha=0.35, From e8c1bd2be5dff7db8357610023a154d80a8c36d3 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 3 Apr 2025 09:57:59 -0400 Subject: [PATCH 13/81] WIP --- baselines/ppo/config/ppo_base_puffer.yaml | 1 + baselines/ppo/config/ppo_population.yaml | 25 +- .../kshot/analyze_compatibility.py | 0 .../notebooks/04_reward_cond_agents.ipynb | 142 +++- .../05_getting_to_know_the_pop.ipynb | 716 +++++++++--------- gpudrive/utils/compatible.py | 65 +- gpudrive/utils/env.py | 4 +- 7 files changed, 530 insertions(+), 423 deletions(-) create mode 100644 examples/experimental/kshot/analyze_compatibility.py diff --git a/baselines/ppo/config/ppo_base_puffer.yaml b/baselines/ppo/config/ppo_base_puffer.yaml index 7bd99ba38..0b26dd56a 100644 --- a/baselines/ppo/config/ppo_base_puffer.yaml +++ b/baselines/ppo/config/ppo_base_puffer.yaml @@ -21,6 +21,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. collision_weight: -0.75 off_road_weight: -0.75 goal_achieved_weight: 1.0 + init_mode: all_non_trivial # If reward_type is "reward_conditioned", the following parameters are used condition_mode: random diff --git a/baselines/ppo/config/ppo_population.yaml b/baselines/ppo/config/ppo_population.yaml index 00463efff..64ef7bbc5 100644 --- a/baselines/ppo/config/ppo_population.yaml +++ b/baselines/ppo/config/ppo_population.yaml @@ -2,34 +2,35 @@ mode: "train" use_rnn: false eval_model_path: null baseline: false -data_dir: data/processed/examples +data_dir: data/processed/training continue_training: false model_cpt: null environment: # Overrides default environment configs (see pygpudrive/env/config.py) name: "gpudrive" - num_worlds: 50 # Number of parallel environments - k_unique_scenes: 50 # Number of unique scenes to sample from + num_worlds: 30 # Number of parallel environments + k_unique_scenes: 30 # Number of unique scenes to sample from max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp ego_state: true road_map_obs: true partner_obs: true norm_obs: true - remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists) + remove_non_vehicles: true # If false, all agents are included (vehicles, pedestrians, cyclists) lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types - reward_type: "follow_waypoints" #"reward_conditioned" + reward_type: "reward_conditioned" #"follow_waypoints" collision_weight: -0.75 off_road_weight: -0.75 goal_achieved_weight: 1.0 + init_mode: all_non_trivial # If reward_type is "reward_conditioned", the following parameters are used condition_mode: random collision_weight_lb: -3.0 - collision_weight_ub: 0.01 + collision_weight_ub: 0.05 goal_achieved_weight_lb: 1.0 goal_achieved_weight_ub: 3.0 off_road_weight_lb: -3.0 - off_road_weight_ub: 0.01 + off_road_weight_ub: 0.05 dynamics_model: "classic" collision_behavior: "ignore" # Options: "remove", "stop", "ignore" @@ -41,10 +42,10 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. action_space_accel_disc: 7 init_steps: 0 # Warmup steps # Versatile Behavior Diffusion (VBD): This will slow down training - use_vbd: true + use_vbd: false vbd_model_path: "gpudrive/integrations/vbd/weights/epoch=18.ckpt" vbd_trajectory_weight: 0.1 # Importance of distance to the vbd trajectories in the reward function - vbd_in_obs: true + vbd_in_obs: false wandb: entity: "" @@ -54,7 +55,7 @@ wandb: tags: ["ppo", "ff"] train: - exp_id: human # Set dynamically in the script if needed + exp_id: pop_play # Set dynamically in the script if needed seed: 42 cpu_offload: false device: "cuda" # Dynamically set to cuda if available, else cpu @@ -63,7 +64,7 @@ train: compile_mode: "reduce-overhead" # # # Data sampling # # # - resample_scenes: false + resample_scenes: true resample_dataset_size: 10_000 # Number of unique scenes to sample from resample_interval: 2_000_000 sample_with_replacement: true @@ -102,7 +103,7 @@ train: checkpoint_path: "./runs" # # # Rendering # # # - render: true # Determines whether to render the environment (note: will slow down training) + render: false # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d render_interval: 50 # Render every k iterations render_k_scenarios: 2 # Number of scenarios to render diff --git a/examples/experimental/kshot/analyze_compatibility.py b/examples/experimental/kshot/analyze_compatibility.py new file mode 100644 index 000000000..e69de29bb diff --git a/examples/experimental/notebooks/04_reward_cond_agents.ipynb b/examples/experimental/notebooks/04_reward_cond_agents.ipynb index 925de5ab0..d71ef81cb 100644 --- a/examples/experimental/notebooks/04_reward_cond_agents.ipynb +++ b/examples/experimental/notebooks/04_reward_cond_agents.ipynb @@ -2,20 +2,9 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 17, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2025-04-01 10:24:24.086400: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:477] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", - "E0000 00:00:1743517464.093552 1825338 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "E0000 00:00:1743517464.095681 1825338 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n" - ] - } - ], + "outputs": [], "source": [ "import torch\n", "import dataclasses\n", @@ -46,14 +35,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'mode': 'train', 'use_rnn': False, 'eval_model_path': None, 'baseline': False, 'data_dir': 'data/processed/training', 'continue_training': False, 'model_cpt': None, 'environment': {'name': 'gpudrive', 'num_worlds': 75, 'k_unique_scenes': 75, 'max_controlled_agents': 64, 'ego_state': True, 'road_map_obs': True, 'partner_obs': True, 'norm_obs': True, 'remove_non_vehicles': False, 'lidar_obs': False, 'reward_type': 'reward_conditioned', 'collision_weight': -0.75, 'off_road_weight': -0.75, 'goal_achieved_weight': 1.0, 'condition_mode': 'random', 'collision_weight_lb': -3.0, 'collision_weight_ub': 0.01, 'goal_achieved_weight_lb': 1.0, 'goal_achieved_weight_ub': 3.0, 'off_road_weight_lb': -3.0, 'off_road_weight_ub': 0.0, 'dynamics_model': 'classic', 'collision_behavior': 'ignore', 'dist_to_goal_threshold': 2.0, 'polyline_reduction_threshold': 0.1, 'sampling_seed': 42, 'obs_radius': 50.0, 'action_space_steer_disc': 13, 'action_space_accel_disc': 7, 'use_vbd': False, 'vbd_model_path': 'gpudrive/integrations/vbd/weights/epoch=18.ckpt', 'init_steps': 11, 'vbd_trajectory_weight': 0.1, 'vbd_in_obs': False}, 'wandb': {'entity': '', 'project': 'kshotagents', 'group': 'reward_conditioned', 'mode': 'online', 'tags': ['ppo', 'ff']}, 'train': {'exp_id': 'PPO', 'seed': 42, 'cpu_offload': False, 'device': 'cuda', 'bptt_horizon': 1, 'compile': False, 'compile_mode': 'reduce-overhead', 'resample_scenes': True, 'resample_dataset_size': 10000, 'resample_interval': 2000000, 'sample_with_replacement': True, 'shuffle_dataset': False, 'torch_deterministic': False, 'total_timesteps': 2000000000, 'batch_size': 262144, 'minibatch_size': 8192, 'learning_rate': '3e-4', 'anneal_lr': False, 'gamma': 0.99, 'gae_lambda': 0.95, 'update_epochs': 4, 'norm_adv': True, 'clip_coef': 0.2, 'clip_vloss': False, 'vf_clip_coef': 0.2, 'ent_coef': 0.0001, 'vf_coef': 0.3, 'max_grad_norm': 0.5, 'target_kl': None, 'log_window': 1000, 'network': {'input_dim': 64, 'hidden_dim': 128, 'dropout': 0.01, 'class_name': 'NeuralNet', 'num_parameters': 0}, 'checkpoint_interval': 500, 'checkpoint_path': './runs', 'render': False, 'render_3d': True, 'render_interval': 1, 'render_k_scenarios': 10, 'render_format': 'mp4', 'render_fps': 15, 'zoom_radius': 50}, 'vec': {'backend': 'native', 'num_workers': 1, 'env_batch_size': 1, 'zero_copy': False}}\n" + "{'mode': 'train', 'use_rnn': False, 'eval_model_path': None, 'baseline': False, 'data_dir': 'data/processed/training', 'continue_training': False, 'model_cpt': None, 'environment': {'name': 'gpudrive', 'num_worlds': 50, 'k_unique_scenes': 50, 'max_controlled_agents': 64, 'ego_state': True, 'road_map_obs': True, 'partner_obs': True, 'norm_obs': True, 'remove_non_vehicles': False, 'lidar_obs': False, 'reward_type': 'reward_conditioned', 'collision_weight': -0.75, 'off_road_weight': -0.75, 'goal_achieved_weight': 1.0, 'init_mode': 'all_non_trivial', 'condition_mode': 'random', 'collision_weight_lb': -3.0, 'collision_weight_ub': 0.01, 'goal_achieved_weight_lb': 1.0, 'goal_achieved_weight_ub': 3.0, 'off_road_weight_lb': -3.0, 'off_road_weight_ub': 0.0, 'dynamics_model': 'classic', 'collision_behavior': 'ignore', 'dist_to_goal_threshold': 2.0, 'polyline_reduction_threshold': 0.1, 'sampling_seed': 42, 'obs_radius': 50.0, 'action_space_steer_disc': 13, 'action_space_accel_disc': 7, 'use_vbd': False, 'vbd_model_path': 'gpudrive/integrations/vbd/weights/epoch=18.ckpt', 'init_steps': 11, 'vbd_trajectory_weight': 0.1, 'vbd_in_obs': False}, 'wandb': {'entity': '', 'project': 'kshotagents', 'group': 'reward_conditioned', 'mode': 'online', 'tags': ['ppo', 'ff']}, 'train': {'exp_id': 'PPO', 'seed': 42, 'cpu_offload': False, 'device': 'cuda', 'bptt_horizon': 1, 'compile': False, 'compile_mode': 'reduce-overhead', 'resample_scenes': True, 'resample_dataset_size': 10000, 'resample_interval': 2000000, 'sample_with_replacement': True, 'shuffle_dataset': False, 'torch_deterministic': False, 'total_timesteps': 2000000000, 'batch_size': 262144, 'minibatch_size': 8192, 'learning_rate': '3e-4', 'anneal_lr': False, 'gamma': 0.99, 'gae_lambda': 0.95, 'update_epochs': 4, 'norm_adv': True, 'clip_coef': 0.2, 'clip_vloss': False, 'vf_clip_coef': 0.2, 'ent_coef': 0.0001, 'vf_coef': 0.3, 'max_grad_norm': 0.5, 'target_kl': None, 'log_window': 1000, 'network': {'input_dim': 64, 'hidden_dim': 128, 'dropout': 0.01, 'class_name': 'NeuralNet', 'num_parameters': 0}, 'checkpoint_interval': 500, 'checkpoint_path': './runs', 'render': False, 'render_3d': True, 'render_interval': 1, 'render_k_scenarios': 10, 'render_format': 'mp4', 'render_fps': 15, 'zoom_radius': 50}, 'vec': {'backend': 'native', 'num_workers': 1, 'env_batch_size': 1, 'zero_copy': False}}\n" ] } ], @@ -74,20 +63,20 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Load model from /home/emerge/gpudrive/examples/experimental/models/model_PPO____R_10000__03_19_19_05_33_518_006000.pt\n" + "Load model from /home/emerge/gpudrive/examples/experimental/models/rew_conditioned_0321.pt\n" ] } ], "source": [ "agent = load_policy(\n", - " model_name=\"model_PPO____R_10000__03_19_19_05_33_518_006000\",\n", + " model_name=\"rew_conditioned_0321\",\n", " path_to_cpt=\"/home/emerge/gpudrive/examples/experimental/models\",\n", " env_config=config.environment,\n", " device=device\n", @@ -96,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -136,14 +125,14 @@ "env = GPUDriveTorchEnv(\n", " config=env_config,\n", " data_loader=train_loader,\n", - " max_cont_agents=64, #config.max_controlled_agents,\n", + " max_cont_agents=1, #config.max_controlled_agents,\n", " device=device,\n", ")" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -200,7 +189,7 @@ " else:\n", " goal_weight = 1.0\n", " if sample_offroad_weights:\n", - " off_road_weight = random.uniform(-3.0, 0.5)\n", + " off_road_weight = random.uniform(-3.0, 1.0)\n", " else:\n", " off_road_weight = -3.0\n", "\n", @@ -263,7 +252,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -277,7 +266,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -292,7 +281,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Processing rollouts: 100%|██████████| 50/50 [01:07<00:00, 1.35s/rollout]\n" + "Processing rollouts: 100%|██████████| 50/50 [01:25<00:00, 1.70s/rollout]\n" ] } ], @@ -316,8 +305,8 @@ "outputs": [ { "data": { - "image/jpeg": "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", - "image/png": "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", + "image/jpeg": "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", + "image/png": "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", "text/plain": [ "" ] @@ -348,7 +337,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -446,6 +435,103 @@ "div_metrics['entropy_values'].shape" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Effect on human-replay interaction" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "# Set up the styling\n", + "sns.set(\"notebook\", font_scale=1.05, rc={\"figure.figsize\": (10, 5)})\n", + "sns.set_style(\"ticks\", rc={\"figure.facecolor\": \"none\", \"axes.facecolor\": \"none\"})\n", + "%config InlineBackend.figure_format = 'svg'\n", + "# Prepare the data for the plots\n", + "agents = ['Self-play', 'Population play']\n", + "\n", + "# Data for the first plot: controlling all agents\n", + "all_agents_rates = [0.5, 2.85]\n", + "all_agents_df = pd.DataFrame({\n", + " 'Agent': agents,\n", + " 'Collision Rate (%)': all_agents_rates\n", + "})\n", + "\n", + "# Data for the second plot: controlling single agent\n", + "single_agent_rates = [6.0, 9.50]\n", + "single_agent_df = pd.DataFrame({\n", + " 'Agent': agents,\n", + " 'Collision Rate (%)': single_agent_rates\n", + "})\n", + "\n", + "# Calculate relative increase as multiples (times increase) for the third plot\n", + "relative_increases = []\n", + "for i in range(len(agents)):\n", + " # Formula for X times increase: new_value / old_value\n", + " times_increase = single_agent_rates[i] / all_agents_rates[i]\n", + " relative_increases.append(times_increase)\n", + "\n", + "relative_df = pd.DataFrame({\n", + " 'Agent': agents,\n", + " 'Performance drop SP -> Human': relative_increases\n", + "})\n", + "\n", + "# Create 1x3 subplots\n", + "fig, axs = plt.subplots(1, 3, figsize=(12, 4))\n", + "\n", + "# Plot 1: Collision rates controlling all agents\n", + "sns.barplot(x='Agent', y='Collision Rate (%)', hue='Agent', data=all_agents_df, \n", + " palette='muted', legend=False, ax=axs[0])\n", + "axs[0].set_title('Controlling All Agents')\n", + "axs[0].set_ylim(0, max(all_agents_rates) * 1.2) # Add some space above bars\n", + "for i, v in enumerate(all_agents_rates):\n", + " axs[0].text(i, v + 0.1, f\"{v}%\", ha='center')\n", + "\n", + "# Plot 2: Collision rates controlling single agent\n", + "sns.barplot(x='Agent', y='Collision Rate (%)', hue='Agent', data=single_agent_df, \n", + " palette='pastel', legend=False, ax=axs[1])\n", + "axs[1].set_title('Control Single Agent \\n with Human Replays')\n", + "axs[1].set_ylim(0, max(single_agent_rates) * 1.2) # Add some space above bars\n", + "for i, v in enumerate(single_agent_rates):\n", + " axs[1].text(i, v + 0.3, f\"{v}%\", ha='center')\n", + "\n", + "# Plot 3: Times increase\n", + "sns.barplot(x='Agent', y='Performance drop SP -> Human', hue='Agent', data=relative_df, \n", + " palette='dark', legend=False, ax=axs[2])\n", + "axs[2].set_title('Rel. Increase in Collision Rates \\n (X times)', y=1.05)\n", + "for i, v in enumerate(relative_increases):\n", + " axs[2].text(i, v + 0.3, f\"{v:.1f}x\", ha='center')\n", + "\n", + "# Add annotation about risk averse agents\n", + "fig.text(0.5, 0.01, \n", + " \"Note: The Population play agent type is set to be risk averse.\", \n", + " ha='center', fontsize=10, style='italic')\n", + "\n", + "plt.tight_layout()\n", + "plt.subplots_adjust(bottom=0.2) # Make room for annotation\n", + "sns.despine()\n", + "plt.savefig('collision_rates_comparison.png', dpi=300)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, diff --git a/examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb b/examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb index 0c25c02d6..0c812c37a 100644 --- a/examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb +++ b/examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb @@ -37,52 +37,52 @@ "\n", "Policy Entropy by Agent Type (higher = more uncertain):\n", "agent_type\n", - "Risk-averse 1.054958\n", - "Nominal 0.526441\n", - "Aggressive 0.227942\n", + "Risk-averse 1.062902\n", + "Nominal 0.524216\n", + "Aggressive 0.223871\n", "Name: mean, dtype: float64\n", "\n", "Average Log Probability (higher = more confident):\n", "agent_type\n", - "Aggressive -0.225350\n", - "Nominal -0.527219\n", - "Risk-averse -1.052286\n", + "Aggressive -0.217905\n", + "Nominal -0.523595\n", + "Risk-averse -1.069773\n", "Name: logprob, dtype: float64\n", "\n", "Average Acceleration by Agent Type:\n", "agent_type\n", - "Aggressive 3.744939\n", - "Nominal 3.171320\n", - "Risk-averse 1.797634\n", + "Aggressive 3.750397\n", + "Nominal 3.174470\n", + "Risk-averse 1.777386\n", "Name: acceleration, dtype: float64\n", "\n", "Average Steering by Agent Type (absolute value - measures turning intensity):\n", "agent_type\n", - "Aggressive 2.922955\n", - "Nominal 2.645336\n", - "Risk-averse 2.292953\n", + "Aggressive 2.926976\n", + "Nominal 2.650862\n", + "Risk-averse 2.292863\n", "dtype: float64\n", "\n", "Average Goal Achievement Rate by Agent Type:\n", "agent_type\n", - "Aggressive 0.998889\n", - "Nominal 0.996037\n", - "Risk-averse 0.982047\n", + "Aggressive 1.000000\n", + "Nominal 0.995810\n", + "Risk-averse 0.981381\n", "Name: frac_goal_achieved, dtype: float64\n", "\n", "Average Collision Rate by Agent Type:\n", "agent_type\n", - "Aggressive 0.041110\n", - "Risk-averse 0.036129\n", - "Nominal 0.021887\n", + "Risk-averse 0.026548\n", + "Nominal 0.021578\n", + "Aggressive 0.014317\n", "Name: frac_collided, dtype: float64\n", "\n", "Variation Across Scenarios (higher = less consistent behavior):\n", " acceleration steering\n", "agent_type \n", - "Aggressive 0.215828 1.972205\n", - "Nominal 0.483494 1.774786\n", - "Risk-averse 0.790747 1.362483\n" + "Aggressive 0.194577 1.975558\n", + "Nominal 0.491045 1.761305\n", + "Risk-averse 0.738722 1.377157\n" ] } ], @@ -157,24 +157,24 @@ " \n", " \n", " Aggressive\n", - " 0.227942\n", - " 0.372499\n", + " 0.223871\n", + " 0.363283\n", " 0.000582\n", - " 2.857634\n", + " 2.702675\n", " \n", " \n", " Nominal\n", - " 0.526441\n", - " 0.521252\n", + " 0.524216\n", + " 0.519760\n", " 0.000148\n", - " 2.965228\n", + " 3.033609\n", " \n", " \n", " Risk-averse\n", - " 1.054958\n", - " 0.641721\n", + " 1.062902\n", + " 0.646221\n", " 0.000562\n", - " 3.296287\n", + " 3.086809\n", " \n", " \n", "\n", @@ -183,9 +183,9 @@ "text/plain": [ " mean std min max\n", "agent_type \n", - "Aggressive 0.227942 0.372499 0.000582 2.857634\n", - "Nominal 0.526441 0.521252 0.000148 2.965228\n", - "Risk-averse 1.054958 0.641721 0.000562 3.296287" + "Aggressive 0.223871 0.363283 0.000582 2.702675\n", + "Nominal 0.524216 0.519760 0.000148 3.033609\n", + "Risk-averse 1.062902 0.646221 0.000562 3.086809" ] }, "execution_count": 4, @@ -209,7 +209,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -223,7 +223,7 @@ " \n", " \n", " \n", - " 2025-03-21T18:10:51.767008\n", + " 2025-04-02T09:18:58.268498\n", " image/svg+xml\n", " \n", " \n", @@ -260,12 +260,12 @@ " \n", " \n", " \n", - " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -435,7 +435,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -579,7 +579,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -749,16 +749,16 @@ " \n", " \n", + "\" clip-path=\"url(#p11ca9d6354)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n", " \n", " \n", " \n", - " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -802,18 +802,18 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", + "\" clip-path=\"url(#p11ca9d6354)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#p11ca9d6354)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#p11ca9d6354)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", " \n", @@ -1036,12 +1016,22 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", + " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -1169,7 +1181,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1191,7 +1203,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1210,7 +1222,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1249,18 +1261,18 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1302,11 +1314,11 @@ " \n", " \n", + "\" clip-path=\"url(#p9c6d267e53)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1379,18 +1391,18 @@ " \n", " \n", + "\" clip-path=\"url(#p9c6d267e53)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#p9c6d267e53)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#p9c6d267e53)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -1709,7 +1762,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1731,7 +1784,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1750,7 +1803,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1791,11 +1844,11 @@ " \n", " \n", + "\" clip-path=\"url(#p4e937f83b3)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1807,88 +1860,54 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1917,32 +1936,32 @@ "L 134.409134 237.638286 \n", "L 58.264334 237.638286 \n", "z\n", - "\" clip-path=\"url(#paf2c74d801)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", + "\" clip-path=\"url(#p4e937f83b3)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#p4e937f83b3)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#p4e937f83b3)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1994,12 +1992,12 @@ " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -2042,7 +2040,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2064,7 +2062,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2083,7 +2081,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2124,11 +2122,11 @@ " \n", " \n", + "\" clip-path=\"url(#pc9cc822708)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2140,54 +2138,54 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2280,32 +2278,32 @@ "L 492.420134 237.638286 \n", "L 416.275334 237.638286 \n", "z\n", - "\" clip-path=\"url(#p0ca901b711)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", + "\" clip-path=\"url(#pc9cc822708)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pc9cc822708)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pc9cc822708)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2369,7 +2367,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2419,7 +2417,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2441,7 +2439,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2460,7 +2458,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2501,11 +2499,11 @@ " \n", " \n", + "\" clip-path=\"url(#pacd3671d8b)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2519,18 +2517,18 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2539,18 +2537,18 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2605,32 +2603,32 @@ "L 134.409134 415.406286 \n", "L 58.264334 415.406286 \n", "z\n", - "\" clip-path=\"url(#p89b2e8f1f3)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", + "\" clip-path=\"url(#pacd3671d8b)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pacd3671d8b)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pacd3671d8b)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2663,13 +2661,13 @@ " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2734,7 +2732,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2756,7 +2754,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2775,7 +2773,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2816,11 +2814,11 @@ " \n", " \n", + "\" clip-path=\"url(#p4490811b02)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2835,43 +2833,43 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2898,35 +2896,35 @@ " \n", " \n", + "\" clip-path=\"url(#p4490811b02)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#p4490811b02)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#p4490811b02)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", diff --git a/gpudrive/utils/compatible.py b/gpudrive/utils/compatible.py index 32ff89f8c..3a09f2212 100644 --- a/gpudrive/utils/compatible.py +++ b/gpudrive/utils/compatible.py @@ -4,16 +4,17 @@ from gpudrive.utils.config import load_config from gpudrive.utils.rollout import rollout -from gpudrive.utils.env import make -from gpudrive.utils.checkpoint import make_agent +from gpudrive.utils.env import make_env +from gpudrive.utils.checkpoint import load_policy -RESULTS_DIR = "ada/eval/notebooks/results" +from gpudrive.env.dataset import SceneDataLoader + +RESULTS_DIR = "examples/experimental/dataframes" def get_compatibility_scores( env, agent, - data_loader, num_rollouts, device, identifier, @@ -22,6 +23,12 @@ def get_compatibility_scores( ): """Evaluate policy in the environment.""" + if env.config.reward_type == "reward_conditioned": + agent_weights = env.agent_type + set_agent_type = True + + print(f"Controlling {env.max_cont_agents} agents per scenario") + res_dict = { "scene": [], "goal_achieved_count": [], @@ -71,6 +78,8 @@ def get_compatibility_scores( device=device, deterministic=deterministic, render_sim_state=render_sim_state, + set_agent_type=set_agent_type, + agent_weights=agent_weights, ) # Get names from env @@ -105,30 +114,43 @@ def get_compatibility_scores( if __name__ == "__main__": - # config = load_config("config/ada/eval/sp_cross_play") - config = load_config("config/exp/pop_play_rew_cond_flat") + + config = load_config( + "/home/emerge/gpudrive/baselines/ppo/config/ppo_population" + ) EXP_ID = "rew_cond" # Set maximum number of agents that policy controls # Analysis settings - config.data_dir = "/home/emerge/gpudrive/data/processed/training" - config.num_worlds = 100 - config.dataset_size = 500 + config.data_dir = "data/processed/training" + config.environment.num_worlds = 100 + config.dataset_size = 5000 config.sample_with_replacement = True config.num_rollouts = 10 - config.max_controlled_agents = 64 - config.condition_mode = "fixed" + config.environment.max_controlled_agents = 1 config.device = "cuda" - # config.agent_type = torch.Tensor([-0.75, 1.0, -0.75]) + config.environment.reward_type = "reward_conditioned" + config.environment.condition_mode = "fixed" + config.environment.agent_type = torch.Tensor([-1.5, 1.0, -1.5]) + + agent = load_policy( + model_name="rew_conditioned_0321", + path_to_cpt="/home/emerge/gpudrive/examples/experimental/models", + env_config=config.environment, + device=config.device, + ) - env = make(config) + # Create data loader + train_loader = SceneDataLoader( + root=config.data_dir, + batch_size=config.environment.num_worlds, + dataset_size=config.dataset_size, + sample_with_replacement=True, + ) + + env = make_env(config.environment, train_loader, device=config.device) - # Load sim agent trained through naive self-play - POLICY = "models/baselines/model_pop_play_rew_cond___S_500__03_16_10_41_19_391_007522.pt" - print(f"Loading policy: {POLICY} \n") - cpt = torch.load(POLICY, map_location=config.device, weights_only=False) - agent = make_agent(cpt, config, device=config.device) # Load sim agent trained through naive self-play # agent = NeuralNet.from_pretrained( # "daphne-cornelisse/policy_S10_000_02_27" @@ -137,18 +159,17 @@ def get_compatibility_scores( df = get_compatibility_scores( env=env, agent=agent, - data_loader=env.data_loader, num_rollouts=config.num_rollouts, device=config.device, - identifier=f"{EXP_ID}_{config.max_controlled_agents}", + identifier=f"{EXP_ID}_{config.environment.max_controlled_agents}", ) df = df.dropna() df.to_csv( - f"{RESULTS_DIR}/compatibility_scores_{config.max_controlled_agents}.csv", + f"{RESULTS_DIR}/compatibility_scores_{config.environment.max_controlled_agents}.csv", index=False, ) print(f"goal_achieved: {df['goal_achieved_frac'].mean()*100:.2f}") print(f"collided: {df['collided_frac'].mean()*100:.2f}") - print(f"off_road: {df['off_road_frac'].mean()*100:.2f}") \ No newline at end of file + print(f"off_road: {df['off_road_frac'].mean()*100:.2f}") diff --git a/gpudrive/utils/env.py b/gpudrive/utils/env.py index 53aa7e8f9..79d656909 100644 --- a/gpudrive/utils/env.py +++ b/gpudrive/utils/env.py @@ -5,7 +5,7 @@ from gpudrive.env.config import EnvConfig, RenderConfig -def make_env(config, train_loader): +def make_env(config, train_loader, device="cuda"): """Make the environment with the given config.""" # Override any default environment settings @@ -45,7 +45,7 @@ def make_env(config, train_loader): config=env_config, data_loader=train_loader, max_cont_agents=config.max_controlled_agents, - device=config.device, + device=device, render_config=render_config, ) From 24ce94e11dbe8065b34f029f5f100e81958a747a Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 4 Apr 2025 17:36:10 -0400 Subject: [PATCH 14/81] Set defaults --- baselines/ppo/config/ppo_population.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/baselines/ppo/config/ppo_population.yaml b/baselines/ppo/config/ppo_population.yaml index 64ef7bbc5..8e064d1e9 100644 --- a/baselines/ppo/config/ppo_population.yaml +++ b/baselines/ppo/config/ppo_population.yaml @@ -8,14 +8,14 @@ model_cpt: null environment: # Overrides default environment configs (see pygpudrive/env/config.py) name: "gpudrive" - num_worlds: 30 # Number of parallel environments - k_unique_scenes: 30 # Number of unique scenes to sample from + num_worlds: 50 # Number of parallel environments + k_unique_scenes: 50 # Number of unique scenes to sample from max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp ego_state: true road_map_obs: true partner_obs: true norm_obs: true - remove_non_vehicles: true # If false, all agents are included (vehicles, pedestrians, cyclists) + remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists) lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types reward_type: "reward_conditioned" #"follow_waypoints" collision_weight: -0.75 From 117570625b1ee504aadac19e9d6a711db6777456 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 4 Apr 2025 17:38:03 -0400 Subject: [PATCH 15/81] fix network --- gpudrive/networks/late_fusion.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/gpudrive/networks/late_fusion.py b/gpudrive/networks/late_fusion.py index 2b6000236..3cd1be381 100644 --- a/gpudrive/networks/late_fusion.py +++ b/gpudrive/networks/late_fusion.py @@ -98,9 +98,6 @@ def __init__( # Indices for unpacking the observation self.ego_state_idx = constants.EGO_FEAT_DIM - self.partner_obs_idx = ( - constants.PARTNER_FEAT_DIM * self.max_controlled_agents - ) if config is not None: self.config = Box(config) if "reward_type" in self.config: @@ -112,6 +109,10 @@ def __init__( self.vbd_in_obs = self.config.vbd_in_obs + self.partner_obs_idx = self.ego_state_idx + ( + constants.PARTNER_FEAT_DIM * self.max_observable_agents + ) + # Calculate the VBD predictions size: 91 timesteps * 5 features = 455 self.vbd_size = 91 * 5 From 20500ef15fd9c89588aef459e6e86a7d0c98ca21 Mon Sep 17 00:00:00 2001 From: daphnecor Date: Sat, 5 Apr 2025 11:13:12 -0400 Subject: [PATCH 16/81] Small setting updates --- baselines/ppo/config/ppo_population.yaml | 6 +++--- gpudrive/networks/late_fusion.py | 3 +-- gpudrive/utils/generate_sbatch.py | 15 ++++++++------- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/baselines/ppo/config/ppo_population.yaml b/baselines/ppo/config/ppo_population.yaml index 8e064d1e9..cd9ba9733 100644 --- a/baselines/ppo/config/ppo_population.yaml +++ b/baselines/ppo/config/ppo_population.yaml @@ -2,7 +2,7 @@ mode: "train" use_rnn: false eval_model_path: null baseline: false -data_dir: data/processed/training +data_dir: /scratch/kj2676/gpudrive/data/processed/training continue_training: false model_cpt: null @@ -26,11 +26,11 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. # If reward_type is "reward_conditioned", the following parameters are used condition_mode: random collision_weight_lb: -3.0 - collision_weight_ub: 0.05 + collision_weight_ub: 0.0 goal_achieved_weight_lb: 1.0 goal_achieved_weight_ub: 3.0 off_road_weight_lb: -3.0 - off_road_weight_ub: 0.05 + off_road_weight_ub: 0.0 dynamics_model: "classic" collision_behavior: "ignore" # Options: "remove", "stop", "ignore" diff --git a/gpudrive/networks/late_fusion.py b/gpudrive/networks/late_fusion.py index 3cd1be381..65807b2cd 100644 --- a/gpudrive/networks/late_fusion.py +++ b/gpudrive/networks/late_fusion.py @@ -105,8 +105,7 @@ def __init__( # Agents know their "type", consisting of three weights # that determine the reward (collision, goal, off-road) self.ego_state_idx += 3 - self.partner_obs_idx += 3 - + self.vbd_in_obs = self.config.vbd_in_obs self.partner_obs_idx = self.ego_state_idx + ( diff --git a/gpudrive/utils/generate_sbatch.py b/gpudrive/utils/generate_sbatch.py index bcac4761f..f786aebf3 100644 --- a/gpudrive/utils/generate_sbatch.py +++ b/gpudrive/utils/generate_sbatch.py @@ -243,7 +243,7 @@ def save_script(filename, file_path, fields, params, param_order=None): if __name__ == "__main__": - group = "04_01" + group = "04_04" fields = { "time_h": 47, # Max time per job (job will finish if run is done before) @@ -255,17 +255,18 @@ def save_script(filename, file_path, fields, params, param_order=None): hyperparams = { "group": [group], # Group name - "num_worlds": [800], + "num_worlds": [300], "resample_scenes": [1], # Yes - "k_unique_scenes": [800], - "max_controlled_agents": [64, 1], + "k_unique_scenes": [300], + "max_controlled_agents": [64], "resample_interval": [5_000_000], "total_timesteps": [4_000_000_000], "resample_dataset_size": [10_000], - "batch_size": [524288], + "batch_size": [262144], "minibatch_size": [16384], - "update_epochs": [4], - "ent_coef": [0.001, 0.0001], + "update_epochs": [3, 4], + "ent_coef": [0.001, 0.0001, 0.003], + "learning_rate": [1e-4, 3e-4], "render": [0], } From 41235ca88d2b196c2a7fdfae592d3dcd68a28ea9 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Sat, 5 Apr 2025 12:17:35 -0400 Subject: [PATCH 17/81] Improve and extend options for waypoint following rewards --- baselines/ppo/config/ppo_population.yaml | 14 ++-- gpudrive/env/config.py | 9 ++- gpudrive/env/env_torch.py | 97 +++++++++++------------- src/consts.hpp | 2 +- 4 files changed, 60 insertions(+), 62 deletions(-) diff --git a/baselines/ppo/config/ppo_population.yaml b/baselines/ppo/config/ppo_population.yaml index cd9ba9733..471ec798c 100644 --- a/baselines/ppo/config/ppo_population.yaml +++ b/baselines/ppo/config/ppo_population.yaml @@ -2,7 +2,7 @@ mode: "train" use_rnn: false eval_model_path: null baseline: false -data_dir: /scratch/kj2676/gpudrive/data/processed/training +data_dir: data/processed/training continue_training: false model_cpt: null @@ -17,7 +17,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. norm_obs: true remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists) lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types - reward_type: "reward_conditioned" #"follow_waypoints" + reward_type: "follow_waypoints" # Options: "weighted_combination", "reward_conditioned", "follow_waypoints" collision_weight: -0.75 off_road_weight: -0.75 goal_achieved_weight: 1.0 @@ -49,8 +49,8 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. wandb: entity: "" - project: "kshotagents" - group: "04_01" + project: "blended" + group: "follow_waypoints" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] @@ -64,7 +64,7 @@ train: compile_mode: "reduce-overhead" # # # Data sampling # # # - resample_scenes: true + resample_scenes: false resample_dataset_size: 10_000 # Number of unique scenes to sample from resample_interval: 2_000_000 sample_with_replacement: true @@ -103,10 +103,10 @@ train: checkpoint_path: "./runs" # # # Rendering # # # - render: false # Determines whether to render the environment (note: will slow down training) + render: true # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d render_interval: 50 # Render every k iterations - render_k_scenarios: 2 # Number of scenarios to render + render_k_scenarios: 1 # Number of scenarios to render render_format: "mp4" # Options: gif, mp4 render_fps: 20 # Frames per second zoom_radius: 100 diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index 57e2597af..d37a3ac1b 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -101,8 +101,15 @@ class EnvConfig: reward_type: str = "sparse_on_goal_achieved" # Alternatively, "weighted_combination", "follow_waypoints", "distance_to_vdb_trajs", "reward_conditioned" - condition_mode: str = "random" # Options: "random", "fixed", "preset" + # If reward_type is "follow_waypoints", the following parameters are used + waypoint_radius: float = ( + 0.5 # Radius around the waypoint to consider as "reached" + ) + waypoint_sample_interval: int = 10 # Interval for sampling waypoints + waypoint_max_reward: float = 1.0 # Maximum reward for reaching a waypoint + # If reward_type is "reward_conditioned", the following parameters are used + condition_mode: str = "random" # Options: "random", "fixed", "preset" # If condition_mode is "fixed", set the agent weights here agent_type: Optional[Union[str, torch.Tensor]] = None diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index f9d0b62c0..505e3e204 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -82,6 +82,13 @@ def __init__( self.cont_agent_mask.sum().item() ) + self.log_trajectory = LogTrajectory.from_tensor( + self.sim.expert_trajectory_tensor(), + self.num_worlds, + self.max_agent_count, + backend=self.backend, + ) + # Now initialize reward weights tensor if using reward_conditioned reward type if ( hasattr(self.config, "reward_type") @@ -482,16 +489,8 @@ def get_rewards( goal_achieved_weight=1.0, off_road_weight=-0.5, world_time_steps=None, - waypoint_radius=1.0, ): - """Obtain the rewards for the current step. - By default, the reward is a weighted combination of the following components: - - collision - - goal_achieved - - off_road - - The importance of each component is determined by the weights. - """ + """Obtain the rewards for the current step.""" # Return the weighted combination of the reward components info_tensor = self.sim.info_tensor().to_torch().clone() @@ -511,18 +510,15 @@ def get_rewards( + goal_achieved_weight * goal_achieved + off_road_weight * off_road ) - return weighted_rewards elif self.config.reward_type == "reward_conditioned": # Extract individual weight components from the tensor # Shape: [num_worlds, max_agents, 3] + # 0: collision, 1: goal_achieved, 2: off_road if self.reward_weights_tensor is None: self._set_reward_weights() - # Apply the weights in a vectorized manner - # Each index in dimension 2 corresponds to a specific weight: - # 0: collision, 1: goal_achieved, 2: off_road weighted_rewards = ( self.reward_weights_tensor[:, :, 0] * collided + self.reward_weights_tensor[:, :, 1] * goal_achieved @@ -575,73 +571,60 @@ def get_rewards( elif self.config.reward_type == "follow_waypoints": # Reward based on proximity to waypoints within a radius and penalty for collision/off-road - # With maximum reward of 0.1 per time step - # Calculate base weighted rewards (penalties) + # Calculate base weighted rewards base_rewards = ( collision_weight * collided + goal_achieved_weight * goal_achieved + off_road_weight * off_road ) - log_trajectory = LogTrajectory.from_tensor( - self.sim.expert_trajectory_tensor(), - self.num_worlds, - self.max_agent_count, - backend=self.backend, - ) + # Extract waypoints (ground truth) at time t + batch_indices = torch.arange(world_time_steps.shape[0]) + gt_agent_pos = self.log_trajectory.pos_xy[ + batch_indices, :, world_time_steps, : + ] - # Index log positions at current time steps - log_traj_pos = [] - for i in range(self.num_worlds): - log_traj_pos.append( - log_trajectory.pos_xy[i, :, world_time_steps[i], :] - ) - log_traj_pos_tensor = torch.stack(log_traj_pos) + waypoint_mask = ( + (world_time_steps % self.config.waypoint_sample_interval == 0) + .float() + .unsqueeze(1) + ) + # Get actual agent positions agent_state = GlobalEgoState.from_tensor( self.sim.absolute_self_observation_tensor(), self.backend, ) - agent_pos = torch.stack( + actual_agent_pos = torch.stack( [agent_state.pos_x, agent_state.pos_y], dim=-1 ) # Compute euclidean distance between agent and waypoints dist_to_waypoints = torch.norm( - log_traj_pos_tensor - agent_pos, dim=-1 + gt_agent_pos - actual_agent_pos, dim=-1 ) + # Apply waypoint mask to zero out distances for non-sampled time steps + dist_to_waypoints = dist_to_waypoints * waypoint_mask + # Create proximity reward based on waypoint_radius # Only reward agents within the waypoint radius # Smoothly increases as agent gets closer to the center - proximity_mask = (dist_to_waypoints <= waypoint_radius).float() - - # Normalized distance within the radius (1.0 at center, 0.0 at radius) - normalized_proximity = proximity_mask * ( - 1.0 - (dist_to_waypoints / waypoint_radius) - ) - - # Calculate weighted rewards but normalize to max of 0.1 per time step - waypoint_weight = 0.5 - - # Compute the raw weighted rewards - raw_weighted_rewards = (0.5 * base_rewards) + ( - waypoint_weight * normalized_proximity + proximity_mask = ( + dist_to_waypoints <= self.config.waypoint_radius + ).float() + + waypoint_rewards = ( + proximity_mask + * (1.0 - dist_to_waypoints / self.config.waypoint_radius) + * self.config.waypoint_max_reward ) - # Scale down to ensure maximum is 0.1 per time step - # First ensure rewards are non-negative (for scaling purposes) - non_negative_rewards = torch.clamp(raw_weighted_rewards, min=0.0) + rewards = base_rewards + waypoint_rewards - # Scale down to max of 0.1 - weighted_rewards = 0.1 * ( - non_negative_rewards - / torch.clamp(torch.max(non_negative_rewards), min=1.0) - ) - - return weighted_rewards + return rewards def step_dynamics(self, actions): if actions is not None: @@ -1361,6 +1344,14 @@ def swap_data_batch(self, data_batch=None): # Reset static scenario data for the visualizer self.vis.initialize_static_scenario_data(self.cont_agent_mask) + # Obtain new log trajectory + self.log_trajectory = LogTrajectory.from_tensor( + self.sim.expert_trajectory_tensor(), + self.num_worlds, + self.max_agent_count, + backend=self.backend, + ) + def _generate_vbd_trajectories(self): """Generate and store trajectory predictions for all scenes using VBD model.""" if not self.use_vbd or self.vbd_model is None: diff --git a/src/consts.hpp b/src/consts.hpp index 41d7a5282..a99a4c65a 100644 --- a/src/consts.hpp +++ b/src/consts.hpp @@ -22,7 +22,7 @@ inline constexpr float worldLength = 40.f; // This factor rescales the length of the vehicles by a tiny amount // To account for the fact that noise occasionally puts vehicles into initial // collisions. This is a dataset artifact that we are handling here like this. -inline constexpr float vehicleLengthScale = 0.7f; +inline constexpr float vehicleLengthScale = 0.9f; // Each unit of distance forward (+ y axis) rewards the agents by this amount inline constexpr float rewardPerDist = 0.05f; From f2839759210115b8f2b0023b9b9ef9230964c0e9 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Mon, 7 Apr 2025 14:26:13 -0400 Subject: [PATCH 18/81] Eval new model --- .gitignore | 2 +- .../05_getting_to_know_the_pop.ipynb | 1265 ++++++++--------- gpudrive/utils/compatible.py | 43 +- gpudrive/utils/diversity.py | 2 +- 4 files changed, 633 insertions(+), 679 deletions(-) diff --git a/.gitignore b/.gitignore index d19bef1b1..7052a3915 100644 --- a/.gitignore +++ b/.gitignore @@ -27,7 +27,7 @@ data/raw/* data/processed/validation/* data/processed/training/* data/processed/testing/* -data/processed/sampled/* +data/processed/pop_play/* data/processed/hand_designed/* analyze/figures/* diff --git a/examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb b/examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb index 0c812c37a..2e181f503 100644 --- a/examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb +++ b/examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb @@ -37,52 +37,52 @@ "\n", "Policy Entropy by Agent Type (higher = more uncertain):\n", "agent_type\n", - "Risk-averse 1.062902\n", - "Nominal 0.524216\n", - "Aggressive 0.223871\n", + "Risk-averse 2.230663\n", + "Nominal 1.935405\n", + "Aggressive 1.706336\n", "Name: mean, dtype: float64\n", "\n", "Average Log Probability (higher = more confident):\n", "agent_type\n", - "Aggressive -0.217905\n", - "Nominal -0.523595\n", - "Risk-averse -1.069773\n", + "Aggressive -1.715222\n", + "Nominal -1.939547\n", + "Risk-averse -2.238968\n", "Name: logprob, dtype: float64\n", "\n", "Average Acceleration by Agent Type:\n", "agent_type\n", - "Aggressive 3.750397\n", - "Nominal 3.174470\n", - "Risk-averse 1.777386\n", + "Aggressive 3.117953\n", + "Nominal 2.036616\n", + "Risk-averse 0.085136\n", "Name: acceleration, dtype: float64\n", "\n", "Average Steering by Agent Type (absolute value - measures turning intensity):\n", "agent_type\n", - "Aggressive 2.926976\n", - "Nominal 2.650862\n", - "Risk-averse 2.292863\n", + "Risk-averse 2.363364\n", + "Nominal 2.156945\n", + "Aggressive 2.056634\n", "dtype: float64\n", "\n", "Average Goal Achievement Rate by Agent Type:\n", "agent_type\n", "Aggressive 1.000000\n", - "Nominal 0.995810\n", - "Risk-averse 0.981381\n", + "Nominal 0.966185\n", + "Risk-averse 0.756087\n", "Name: frac_goal_achieved, dtype: float64\n", "\n", "Average Collision Rate by Agent Type:\n", "agent_type\n", - "Risk-averse 0.026548\n", - "Nominal 0.021578\n", - "Aggressive 0.014317\n", + "Nominal 0.132341\n", + "Aggressive 0.110032\n", + "Risk-averse 0.090811\n", "Name: frac_collided, dtype: float64\n", "\n", "Variation Across Scenarios (higher = less consistent behavior):\n", " acceleration steering\n", "agent_type \n", - "Aggressive 0.194577 1.975558\n", - "Nominal 0.491045 1.761305\n", - "Risk-averse 0.738722 1.377157\n" + "Aggressive 0.361163 0.170644\n", + "Nominal 0.982940 0.419780\n", + "Risk-averse 1.228092 0.574757\n" ] } ], @@ -157,24 +157,24 @@ " \n", " \n", " Aggressive\n", - " 0.223871\n", - " 0.363283\n", - " 0.000582\n", - " 2.702675\n", + " 1.706336\n", + " 0.702564\n", + " 0.000793\n", + " 3.484450\n", " \n", " \n", " Nominal\n", - " 0.524216\n", - " 0.519760\n", - " 0.000148\n", - " 3.033609\n", + " 1.935405\n", + " 0.737693\n", + " 0.001746\n", + " 3.495515\n", " \n", " \n", " Risk-averse\n", - " 1.062902\n", - " 0.646221\n", - " 0.000562\n", - " 3.086809\n", + " 2.230663\n", + " 0.685508\n", + " 0.014702\n", + " 3.733659\n", " \n", " \n", "\n", @@ -183,9 +183,9 @@ "text/plain": [ " mean std min max\n", "agent_type \n", - "Aggressive 0.223871 0.363283 0.000582 2.702675\n", - "Nominal 0.524216 0.519760 0.000148 3.033609\n", - "Risk-averse 1.062902 0.646221 0.000562 3.086809" + "Aggressive 1.706336 0.702564 0.000793 3.484450\n", + "Nominal 1.935405 0.737693 0.001746 3.495515\n", + "Risk-averse 2.230663 0.685508 0.014702 3.733659" ] }, "execution_count": 4, @@ -223,7 +223,7 @@ " \n", " \n", " \n", - " 2025-04-02T09:18:58.268498\n", + " 2025-04-07T12:56:17.566570\n", " image/svg+xml\n", " \n", " \n", @@ -249,8 +249,8 @@ " \n", " \n", " \n", " \n", " \n", - " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", + "L 337.934234 168.156 \n", + "\" clip-path=\"url(#pa89534f593)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n", " \n", " \n", " \n", - " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", " \n", " \n", - " \n", - " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", " \n", - " \n", - " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", " \n", - " \n", - " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + "\" clip-path=\"url(#pa89534f593)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + "\" clip-path=\"url(#pa89534f593)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + "\" clip-path=\"url(#pa89534f593)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", " \n", @@ -1181,12 +1196,12 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1203,12 +1218,12 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1222,12 +1237,12 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1244,7 +1259,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1261,18 +1276,18 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + "\" clip-path=\"url(#pf74dcec93a)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + "\" clip-path=\"url(#pf74dcec93a)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + "\" clip-path=\"url(#pf74dcec93a)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + "\" clip-path=\"url(#pf74dcec93a)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", " \n", " \n", - " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1784,12 +1761,12 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1803,12 +1780,12 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1825,7 +1802,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1843,12 +1820,12 @@ " \n", " \n", " \n", + "L 337.934234 345.924 \n", + "\" clip-path=\"url(#p70a88f4f01)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1860,54 +1837,54 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -1931,37 +1908,37 @@ " \n", " \n", " \n", - " \n", + "\" clip-path=\"url(#p70a88f4f01)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + "\" clip-path=\"url(#p70a88f4f01)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + "\" clip-path=\"url(#p70a88f4f01)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2028,11 +2005,11 @@ " \n", " \n", " \n", - " \n", " \n", @@ -2040,12 +2017,12 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2062,12 +2039,12 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2081,12 +2058,12 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2103,7 +2080,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2120,79 +2097,61 @@ " \n", " \n", " \n", - " \n", + "\" clip-path=\"url(#p8b19814f01)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", + "\" clip-path=\"url(#p8b19814f01)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + "\" clip-path=\"url(#p8b19814f01)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + "\" clip-path=\"url(#p8b19814f01)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", " \n", " \n", - " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2406,8 +2333,8 @@ " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2437,14 +2364,14 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2456,14 +2383,14 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2478,9 +2405,9 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2495,18 +2422,18 @@ " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", + "L 337.934234 523.692 \n", + "\" clip-path=\"url(#paf0fe61c91)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2515,18 +2442,18 @@ " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", + "L 337.934234 469.549143 \n", + "\" clip-path=\"url(#paf0fe61c91)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2535,18 +2462,18 @@ " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", + "L 337.934234 415.406286 \n", + "\" clip-path=\"url(#paf0fe61c91)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2555,7 +2482,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2598,37 +2525,37 @@ " \n", " \n", " \n", - " \n", + "\" clip-path=\"url(#paf0fe61c91)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + "\" clip-path=\"url(#paf0fe61c91)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + "\" clip-path=\"url(#paf0fe61c91)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2650,29 +2577,29 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2752,14 +2679,14 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2771,14 +2698,14 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2793,9 +2720,9 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2810,20 +2737,20 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + "\" clip-path=\"url(#p8716c480a9)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2831,51 +2758,51 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2894,51 +2821,51 @@ " \n", " \n", " \n", - " \n", + "\" clip-path=\"url(#p8716c480a9)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + "\" clip-path=\"url(#p8716c480a9)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", " \n", - " \n", + "\" clip-path=\"url(#p8716c480a9)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", " \n", " \n", - " \n", " \n", - " \n", + " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -2956,7 +2883,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -3068,23 +2995,23 @@ " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", "\n" diff --git a/gpudrive/utils/compatible.py b/gpudrive/utils/compatible.py index 3a09f2212..1e5d33d64 100644 --- a/gpudrive/utils/compatible.py +++ b/gpudrive/utils/compatible.py @@ -1,6 +1,9 @@ from tqdm import tqdm import torch import pandas as pd +import numpy as np +from pathlib import Path +import mediapy from gpudrive.utils.config import load_config from gpudrive.utils.rollout import rollout @@ -20,6 +23,7 @@ def get_compatibility_scores( identifier, deterministic=False, render_sim_state=False, + render_every_t=10, ): """Evaluate policy in the environment.""" @@ -80,6 +84,7 @@ def get_compatibility_scores( render_sim_state=render_sim_state, set_agent_type=set_agent_type, agent_weights=agent_weights, + render_every_n_steps=render_every_t, ) # Get names from env @@ -110,7 +115,7 @@ def get_compatibility_scores( print(f"\n Evaluated in {df_res.scene.nunique()} unique scenes.") - return df_res + return df_res, sim_state_frames, scenario_to_worlds_dict if __name__ == "__main__": @@ -124,18 +129,18 @@ def get_compatibility_scores( # Analysis settings config.data_dir = "data/processed/training" - config.environment.num_worlds = 100 + config.environment.num_worlds = 10 config.dataset_size = 5000 config.sample_with_replacement = True - config.num_rollouts = 10 - config.environment.max_controlled_agents = 1 - config.device = "cuda" + config.num_rollouts = 1 + config.environment.max_controlled_agents = 64 #1 + config.device = "cuda" config.environment.reward_type = "reward_conditioned" config.environment.condition_mode = "fixed" - config.environment.agent_type = torch.Tensor([-1.5, 1.0, -1.5]) + config.environment.agent_type = torch.Tensor([-0.5, 1.0, -0.5]) agent = load_policy( - model_name="rew_conditioned_0321", + model_name="model_pop_play____R_10000__04_04_18_27_28_702_002500", path_to_cpt="/home/emerge/gpudrive/examples/experimental/models", env_config=config.environment, device=config.device, @@ -156,12 +161,14 @@ def get_compatibility_scores( # "daphne-cornelisse/policy_S10_000_02_27" # ).to(config.device) - df = get_compatibility_scores( + df, frames, filenames = get_compatibility_scores( env=env, agent=agent, num_rollouts=config.num_rollouts, device=config.device, identifier=f"{EXP_ID}_{config.environment.max_controlled_agents}", + render_sim_state=True, + render_every_t=5, ) df = df.dropna() @@ -173,3 +180,23 @@ def get_compatibility_scores( print(f"goal_achieved: {df['goal_achieved_frac'].mean()*100:.2f}") print(f"collided: {df['collided_frac'].mean()*100:.2f}") print(f"off_road: {df['off_road_frac'].mean()*100:.2f}") + + # Save videos + sim_state_arrays = {k: np.array(v) for k, v in frames.items()} + videos_dir = Path(f"videos/reward_conditioned") + videos_dir.mkdir(parents=True, exist_ok=True) + + for env_id, frames in sim_state_arrays.items(): + + filename = filenames[env_id] + video_path = videos_dir / f"{filename}.gif" + + mediapy.write_video( + str(video_path), + frames, + fps=5, + codec='gif', + ) + + print(f"Saved video to {video_path}") + diff --git a/gpudrive/utils/diversity.py b/gpudrive/utils/diversity.py index c47a8a19c..ea27c287b 100644 --- a/gpudrive/utils/diversity.py +++ b/gpudrive/utils/diversity.py @@ -393,7 +393,7 @@ def compare_agent_types(df): config.environment.agent_type = torch.Tensor([-0.2, 1.0, -0.2]) agent = load_policy( - model_name="rew_conditioned_0321", + model_name="model_pop_play____R_10000__04_04_18_27_28_702_002500", path_to_cpt="/home/emerge/gpudrive/examples/experimental/models", env_config=config.environment, device=device, From 493907920c3b614e73d98a8776aad0bac456badf Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Mon, 7 Apr 2025 14:26:26 -0400 Subject: [PATCH 19/81] Formatting --- gpudrive/utils/compatible.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/gpudrive/utils/compatible.py b/gpudrive/utils/compatible.py index 1e5d33d64..39b101741 100644 --- a/gpudrive/utils/compatible.py +++ b/gpudrive/utils/compatible.py @@ -129,12 +129,12 @@ def get_compatibility_scores( # Analysis settings config.data_dir = "data/processed/training" - config.environment.num_worlds = 10 + config.environment.num_worlds = 100 config.dataset_size = 5000 config.sample_with_replacement = True config.num_rollouts = 1 - config.environment.max_controlled_agents = 64 #1 - config.device = "cuda" + config.environment.max_controlled_agents = 64 # 1 + config.device = "cuda" config.environment.reward_type = "reward_conditioned" config.environment.condition_mode = "fixed" config.environment.agent_type = torch.Tensor([-0.5, 1.0, -0.5]) @@ -180,14 +180,14 @@ def get_compatibility_scores( print(f"goal_achieved: {df['goal_achieved_frac'].mean()*100:.2f}") print(f"collided: {df['collided_frac'].mean()*100:.2f}") print(f"off_road: {df['off_road_frac'].mean()*100:.2f}") - + # Save videos sim_state_arrays = {k: np.array(v) for k, v in frames.items()} videos_dir = Path(f"videos/reward_conditioned") videos_dir.mkdir(parents=True, exist_ok=True) for env_id, frames in sim_state_arrays.items(): - + filename = filenames[env_id] video_path = videos_dir / f"{filename}.gif" @@ -195,8 +195,7 @@ def get_compatibility_scores( str(video_path), frames, fps=5, - codec='gif', + codec="gif", ) print(f"Saved video to {video_path}") - From f0d66d57cc8b4e56eddf609eaf68f5530dd79bab Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Mon, 7 Apr 2025 14:55:31 -0400 Subject: [PATCH 20/81] Set default agent_type for fixed condition mode --- gpudrive/env/config.py | 4 +++- gpudrive/env/env_torch.py | 8 ++++++-- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index d37a3ac1b..c60a1018e 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -111,7 +111,9 @@ class EnvConfig: # If reward_type is "reward_conditioned", the following parameters are used condition_mode: str = "random" # Options: "random", "fixed", "preset" # If condition_mode is "fixed", set the agent weights here - agent_type: Optional[Union[str, torch.Tensor]] = None + agent_type: Optional[Union[str, torch.Tensor]] = torch.Tensor( + [-0.75, 1.0, -0.75] + ) # weights for collision, goal_achieved, off_road # Define upper and lower bounds for reward components if using reward_conditioned collision_weight_lb: float = -1.0 diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 505e3e204..e87e7838e 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -451,9 +451,11 @@ def reset( if condition_mode is not None else getattr(self.config, "condition_mode", "random") ) - self.agent_type = agent_type + use_agent_type = ( + agent_type if agent_type is not None else self.agent_type + ) self._set_reward_weights( - env_idx_list, condition_mode=mode, agent_type=self.agent_type + env_idx_list, condition_mode=mode, agent_type=use_agent_type ) self.world_time_steps.zero_() @@ -1509,6 +1511,8 @@ def get_scenario_ids(self): env_config = EnvConfig( dynamics_model="delta_local", + reward_type="reward_conditioned", + condition_mode="fixed", ) render_config = RenderConfig() From d63f370391e3e6a21c30f81d1c349e3188b6e9f8 Mon Sep 17 00:00:00 2001 From: daphnecor Date: Mon, 7 Apr 2025 15:37:21 -0400 Subject: [PATCH 21/81] minor --- baselines/ppo/config/ppo_population.yaml | 11 ++++++----- baselines/ppo/ppo_pufferlib.py | 9 ++++++++- 2 files changed, 14 insertions(+), 6 deletions(-) diff --git a/baselines/ppo/config/ppo_population.yaml b/baselines/ppo/config/ppo_population.yaml index 471ec798c..9f2a62e3e 100644 --- a/baselines/ppo/config/ppo_population.yaml +++ b/baselines/ppo/config/ppo_population.yaml @@ -2,7 +2,7 @@ mode: "train" use_rnn: false eval_model_path: null baseline: false -data_dir: data/processed/training +data_dir: data/processed/pop_play continue_training: false model_cpt: null @@ -17,13 +17,14 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. norm_obs: true remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists) lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types - reward_type: "follow_waypoints" # Options: "weighted_combination", "reward_conditioned", "follow_waypoints" + reward_type: "reward_conditioned" # Options: "weighted_combination", "reward_conditioned", "follow_waypoints" collision_weight: -0.75 off_road_weight: -0.75 goal_achieved_weight: 1.0 init_mode: all_non_trivial # If reward_type is "reward_conditioned", the following parameters are used + randomize_rewards: true condition_mode: random collision_weight_lb: -3.0 collision_weight_ub: 0.0 @@ -49,13 +50,13 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. wandb: entity: "" - project: "blended" - group: "follow_waypoints" + project: "kshotagents" + group: " " mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] train: - exp_id: pop_play # Set dynamically in the script if needed + exp_id: random_rewards # Set dynamically in the script if needed seed: 42 cpu_offload: false device: "cuda" # Dynamically set to cuda if available, else cpu diff --git a/baselines/ppo/ppo_pufferlib.py b/baselines/ppo/ppo_pufferlib.py index 560aa03b9..d97d37125 100644 --- a/baselines/ppo/ppo_pufferlib.py +++ b/baselines/ppo/ppo_pufferlib.py @@ -167,6 +167,7 @@ def run( off_road_weight: Annotated[Optional[float], typer.Option(help="The weight for off-road penalty")] = None, goal_achieved_weight: Annotated[Optional[float], typer.Option(help="The weight for goal-achieved reward")] = None, dist_to_goal_threshold: Annotated[Optional[float], typer.Option(help="The distance threshold for goal-achieved")] = None, + randomize_rewards: Annotated[Optional[int], typer.Option(help="If reward_type == reward_conditioned, choose the condition_mode; 0 or 1")] = 1, sampling_seed: Annotated[Optional[int], typer.Option(help="The seed for sampling scenes")] = None, obs_radius: Annotated[Optional[float], typer.Option(help="The radius for the observation")] = None, collision_behavior: Annotated[Optional[str], typer.Option(help="The collision behavior; 'ignore' or 'remove'")] = None, @@ -201,7 +202,13 @@ def run( # Load default configs config = load_config(config_path) - + + if config.environment.reward_type == "reward_conditioned": + if bool(randomize_rewards): + config.environment.condition_mode = "random" + else: + config.environment.condition_mode = "fixed" # Use the same type for every agent + # Override configs with command-line arguments env_config = { "num_worlds": num_worlds, From d59826a98aeae59a086a9d170b30836b2697b658 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Mon, 7 Apr 2025 18:34:45 -0400 Subject: [PATCH 22/81] Apply reward weight sharing across environments for memory efficiency --- baselines/ppo/config/ppo_population.yaml | 14 +-- baselines/ppo/ppo_pufferlib.py | 10 +- gpudrive/env/env_torch.py | 125 ++++++++++++----------- gpudrive/integrations/puffer/ppo.py | 2 +- 4 files changed, 81 insertions(+), 70 deletions(-) diff --git a/baselines/ppo/config/ppo_population.yaml b/baselines/ppo/config/ppo_population.yaml index 9f2a62e3e..b3bba41bc 100644 --- a/baselines/ppo/config/ppo_population.yaml +++ b/baselines/ppo/config/ppo_population.yaml @@ -25,7 +25,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. # If reward_type is "reward_conditioned", the following parameters are used randomize_rewards: true - condition_mode: random + condition_mode: random # Options: random, fixed collision_weight_lb: -3.0 collision_weight_ub: 0.0 goal_achieved_weight_lb: 1.0 @@ -51,12 +51,12 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. wandb: entity: "" project: "kshotagents" - group: " " + group: "benchmark_500s" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] train: - exp_id: random_rewards # Set dynamically in the script if needed + exp_id: # Set dynamically in the script if needed seed: 42 cpu_offload: false device: "cuda" # Dynamically set to cuda if available, else cpu @@ -65,9 +65,9 @@ train: compile_mode: "reduce-overhead" # # # Data sampling # # # - resample_scenes: false - resample_dataset_size: 10_000 # Number of unique scenes to sample from - resample_interval: 2_000_000 + resample_scenes: true + resample_dataset_size: 500 # Number of unique scenes to sample from + resample_interval: 100_000 sample_with_replacement: true shuffle_dataset: false @@ -104,7 +104,7 @@ train: checkpoint_path: "./runs" # # # Rendering # # # - render: true # Determines whether to render the environment (note: will slow down training) + render: false # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d render_interval: 50 # Render every k iterations render_k_scenarios: 1 # Number of scenarios to render diff --git a/baselines/ppo/ppo_pufferlib.py b/baselines/ppo/ppo_pufferlib.py index d97d37125..ef892fef8 100644 --- a/baselines/ppo/ppo_pufferlib.py +++ b/baselines/ppo/ppo_pufferlib.py @@ -202,13 +202,17 @@ def run( # Load default configs config = load_config(config_path) - + if config.environment.reward_type == "reward_conditioned": if bool(randomize_rewards): config.environment.condition_mode = "random" + config.train.exp_id = "random_weights" else: - config.environment.condition_mode = "fixed" # Use the same type for every agent - + config.environment.condition_mode = ( + "fixed" # Use the same type for every agent + ) + config.train.exp_id = "fixed_weights" + # Override configs with command-line arguments env_config = { "num_worlds": num_worlds, diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index e87e7838e..de1ec7260 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -242,14 +242,10 @@ def _generate_sample_batch(self, init_steps=10): ) return sample_batch - def _set_reward_weights( - self, env_idx_list=None, condition_mode="random", agent_type=None - ): + def _set_reward_weights(self, condition_mode="random", agent_type=None): """Set agent reward weights for all or specific environments. Args: - env_idx_list: List of environment indices to generate new weights for. - If None, all environments are updated. condition_mode: Determines how reward weights are sampled: - "random": Random sampling within bounds (default for training) - "fixed": Use predefined agent_type weights (for testing) @@ -258,14 +254,12 @@ def _set_reward_weights( If condition_mode is "preset", can be one of: "cautious", "aggressive", "balanced" If condition_mode is "fixed", should be a tensor of shape [3] with weight values """ - # Initialize the reward weights tensor if it doesn't exist yet - # Use the shape from controlled agent mask to ensure consistency + # Use weight sharing across environments for memory efficiency if self.reward_weights_tensor is None: self.reward_weights_tensor = torch.zeros( - self.cont_agent_mask.shape[0], # num_worlds self.cont_agent_mask.shape[1], # max_agent_count from mask 3, # collision, goal_achieved, off_road - device=self.device, + device="cpu", dtype=torch.float16, ) @@ -276,8 +270,8 @@ def _set_reward_weights( self.config.goal_achieved_weight_lb, self.config.off_road_weight_lb, ], - device=self.device, - dtype=torch.float16, # Ensure same dtype as reward_weights_tensor + device="cpu", + dtype=torch.float16, ) upper_bounds = torch.tensor( @@ -286,8 +280,8 @@ def _set_reward_weights( self.config.goal_achieved_weight_ub, self.config.off_road_weight_ub, ], - device=self.device, - dtype=torch.float16, # Ensure same dtype as reward_weights_tensor + device="cpu", + dtype=torch.float16, ) bounds_range = upper_bounds - lower_bounds @@ -303,7 +297,7 @@ def _set_reward_weights( * 0.9, # Strong off-road penalty ], device=self.device, - dtype=torch.float16, # Ensure same dtype as reward_weights_tensor + dtype=torch.float16, ), "aggressive": torch.tensor( [ @@ -315,7 +309,7 @@ def _set_reward_weights( * 0.6, # Moderate off-road penalty ], device=self.device, - dtype=torch.float16, # Ensure same dtype as reward_weights_tensor + dtype=torch.float16, ), "balanced": torch.tensor( [ @@ -336,7 +330,7 @@ def _set_reward_weights( / 2, ], device=self.device, - dtype=torch.float16, # Ensure same dtype as reward_weights_tensor + dtype=torch.float16, ), "risk_taker": torch.tensor( [ @@ -347,28 +341,19 @@ def _set_reward_weights( * 0.4, # Low off-road penalty ], device=self.device, - dtype=torch.float16, # Ensure same dtype as reward_weights_tensor + dtype=torch.float16, ), } - - # Determine which environments to update - if env_idx_list is None: - env_idx_list = list(range(self.num_worlds)) - - env_indices = torch.tensor(env_idx_list, device=self.device) - num_envs = len(env_indices) - - # Get the max agents dimension from the controlled agent mask + # Just get the max agents dimension from the controlled agent mask max_agents = self.cont_agent_mask.shape[1] if condition_mode == "random": # Traditional random sampling within bounds random_values = torch.rand( - num_envs, max_agents, 3, - device=self.device, - dtype=torch.float16, # Create directly as float16 + device="cpu", + dtype=torch.float16, ) scaled_values = lower_bounds + random_values * bounds_range @@ -379,13 +364,9 @@ def _set_reward_weights( f"Unknown agent_type: {agent_type}. Available types: {list(agent_presets.keys())}" ) - # Create a tensor with the preset weights for all agents in the specified environments + # CHANGED: Create a tensor with the preset weights for all agents, but no environment dimension preset_weights = agent_presets[agent_type] - scaled_values = ( - preset_weights.unsqueeze(0) - .unsqueeze(0) - .expand(num_envs, max_agents, 3) - ) # Already float16 from agent_presets + scaled_values = preset_weights.unsqueeze(0).expand(max_agents, 3) elif condition_mode == "fixed": # Use custom provided weights @@ -394,25 +375,18 @@ def _set_reward_weights( "For condition_mode='fixed', agent_type must be a tensor of shape [3]" ) - custom_weights = agent_type.to( - device=self.device, dtype=torch.float16 - ) # Ensure float16 + custom_weights = agent_type.to(device="cpu", dtype=torch.float16) if custom_weights.shape != (3,): raise ValueError( f"agent_type tensor must have shape [3], got {custom_weights.shape}" ) - scaled_values = ( - custom_weights.unsqueeze(0) - .unsqueeze(0) - .expand(num_envs, max_agents, 3) - ) # Already float16 from conversion above + scaled_values = custom_weights.unsqueeze(0).expand(max_agents, 3) else: raise ValueError(f"Unknown condition_mode: {condition_mode}") - # Update the weights tensor for the specified environments - self.reward_weights_tensor[env_indices.cpu()] = scaled_values + self.reward_weights_tensor = scaled_values return self.reward_weights_tensor @@ -455,7 +429,7 @@ def reset( agent_type if agent_type is not None else self.agent_type ) self._set_reward_weights( - env_idx_list, condition_mode=mode, agent_type=use_agent_type + condition_mode=mode, agent_type=use_agent_type ) self.world_time_steps.zero_() @@ -515,16 +489,30 @@ def get_rewards( return weighted_rewards elif self.config.reward_type == "reward_conditioned": - # Extract individual weight components from the tensor - # Shape: [num_worlds, max_agents, 3] - # 0: collision, 1: goal_achieved, 2: off_road if self.reward_weights_tensor is None: self._set_reward_weights() + # Compute the weighted rewards + collision_weights = ( + self.reward_weights_tensor[:, 0] + .expand(self.num_worlds, -1) + .to(self.device) + ) + goal_weights = ( + self.reward_weights_tensor[:, 1] + .expand(self.num_worlds, -1) + .to(self.device) + ) + off_road_weights = ( + self.reward_weights_tensor[:, 2] + .expand(self.num_worlds, -1) + .to(self.device) + ) + weighted_rewards = ( - self.reward_weights_tensor[:, :, 0] * collided - + self.reward_weights_tensor[:, :, 1] * goal_achieved - + self.reward_weights_tensor[:, :, 2] * off_road + collision_weights * collided + + goal_weights * goal_achieved + + off_road_weights * off_road ) return weighted_rewards @@ -795,6 +783,18 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: if mask is None: if self.config.reward_type == "reward_conditioned": + # Create expanded weights for all environments + # Expand from [max_agents, 3] to [num_worlds, max_agents] + collision_weights = self.reward_weights_tensor[:, 0].expand( + self.num_worlds, -1 + ) + goal_weights = self.reward_weights_tensor[:, 1].expand( + self.num_worlds, -1 + ) + off_road_weights = self.reward_weights_tensor[:, 2].expand( + self.num_worlds, -1 + ) + return torch.stack( [ ego_state.speed, @@ -803,12 +803,11 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: ego_state.rel_goal_x, ego_state.rel_goal_y, ego_state.is_collided, - self.reward_weights_tensor[:, :, 0], - self.reward_weights_tensor[:, :, 1], - self.reward_weights_tensor[:, :, 2], + collision_weights.to(self.device), + goal_weights.to(self.device), + off_road_weights.to(self.device), ] ).permute(1, 2, 0) - else: return torch.stack( [ @@ -823,6 +822,14 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: else: if self.config.reward_type == "reward_conditioned": + # For masked agents, we need to extract agent indices from the mask + world_indices, agent_indices = torch.where(mask) + + # Get the reward weights for these specific agents + weights_for_masked_agents = self.reward_weights_tensor.to( + self.device + )[agent_indices] + return torch.stack( [ ego_state.speed, @@ -831,9 +838,9 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: ego_state.rel_goal_x, ego_state.rel_goal_y, ego_state.is_collided, - self.reward_weights_tensor[mask][:, 0], - self.reward_weights_tensor[mask][:, 1], - self.reward_weights_tensor[mask][:, 2], + weights_for_masked_agents[:, 0], # Collision weights + weights_for_masked_agents[:, 1], # Goal weights + weights_for_masked_agents[:, 2], # Off-road weights ] ).permute(1, 0) else: diff --git a/gpudrive/integrations/puffer/ppo.py b/gpudrive/integrations/puffer/ppo.py index bdc65ed45..302067a23 100644 --- a/gpudrive/integrations/puffer/ppo.py +++ b/gpudrive/integrations/puffer/ppo.py @@ -113,7 +113,7 @@ def evaluate(data): and data.resample_buffer >= data.config.resample_interval and data.config.resample_dataset_size > data.vecenv.num_worlds ): - print(f"Resampling scenarios at global step {data.global_step}") + data.msg = f"Resampling scenarios at global step {data.global_step}" data.vecenv.resample_scenario_batch() data.resample_buffer = 0 From 38039455060173bfed691a6d3af466165e6021d6 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Mon, 7 Apr 2025 19:09:06 -0400 Subject: [PATCH 23/81] Add condition mode to wrapper --- gpudrive/env/env_puffer.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 5805dc966..88f75e616 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -47,6 +47,7 @@ def __init__( lidar_obs=False, bev_obs=False, reward_type="weighted_combination", + condition_mode="random", collision_behavior="ignore", collision_weight=-0.5, off_road_weight=-0.5, @@ -119,6 +120,7 @@ def __init__( road_map_obs=road_map_obs, partner_obs=partner_obs, reward_type=reward_type, + condition_mode=condition_mode, norm_obs=norm_obs, bev_obs=bev_obs, dynamics_model=dynamics_model, From a95e41fd71811c7ce14edbefc4924c9fdc482c60 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Tue, 8 Apr 2025 12:05:20 -0400 Subject: [PATCH 24/81] Reduce max road points for sim speed up --- src/consts.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/consts.hpp b/src/consts.hpp index a99a4c65a..0768e9cd0 100644 --- a/src/consts.hpp +++ b/src/consts.hpp @@ -10,7 +10,7 @@ namespace consts { inline constexpr madrona::CountT kMaxAgentCount = 64; inline constexpr madrona::CountT kMaxRoadEntityCount = 10000; -inline constexpr madrona::CountT kMaxAgentMapObservationsCount = 200; +inline constexpr madrona::CountT kMaxAgentMapObservationsCount = 128; inline constexpr bool useEstimatedYaw = true; From b1a2c53923987554bb3d858de1af6d0d3fe85cab Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Tue, 8 Apr 2025 12:07:40 -0400 Subject: [PATCH 25/81] Add agent with separate actor and critic network --- baselines/ppo/config/ppo_population.yaml | 18 +-- baselines/ppo/ppo_pufferlib.py | 18 ++- gpudrive/integrations/puffer/ppo.py | 3 + gpudrive/networks/agents.py | 191 +++++++++++++++++++++++ 4 files changed, 215 insertions(+), 15 deletions(-) create mode 100644 gpudrive/networks/agents.py diff --git a/baselines/ppo/config/ppo_population.yaml b/baselines/ppo/config/ppo_population.yaml index b3bba41bc..171458bc9 100644 --- a/baselines/ppo/config/ppo_population.yaml +++ b/baselines/ppo/config/ppo_population.yaml @@ -8,8 +8,8 @@ model_cpt: null environment: # Overrides default environment configs (see pygpudrive/env/config.py) name: "gpudrive" - num_worlds: 50 # Number of parallel environments - k_unique_scenes: 50 # Number of unique scenes to sample from + num_worlds: 100 # Number of parallel environments + k_unique_scenes: 100 # Number of unique scenes to sample from max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp ego_state: true road_map_obs: true @@ -24,8 +24,8 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. init_mode: all_non_trivial # If reward_type is "reward_conditioned", the following parameters are used - randomize_rewards: true - condition_mode: random # Options: random, fixed + randomize_rewards: false + condition_mode: fixed # Options: random, fixed collision_weight_lb: -3.0 collision_weight_ub: 0.0 goal_achieved_weight_lb: 1.0 @@ -51,7 +51,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. wandb: entity: "" project: "kshotagents" - group: "benchmark_500s" + group: "small" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] @@ -65,9 +65,9 @@ train: compile_mode: "reduce-overhead" # # # Data sampling # # # - resample_scenes: true + resample_scenes: false resample_dataset_size: 500 # Number of unique scenes to sample from - resample_interval: 100_000 + resample_interval: 2_000_000 sample_with_replacement: true shuffle_dataset: false @@ -77,7 +77,7 @@ train: batch_size: 131072 minibatch_size: 8192 learning_rate: 3e-4 - anneal_lr: false + anneal_lr: true gamma: 0.99 gae_lambda: 0.95 update_epochs: 4 @@ -85,7 +85,7 @@ train: clip_coef: 0.2 clip_vloss: false vf_clip_coef: 0.2 - ent_coef: 0.0001 + ent_coef: 0.003 vf_coef: 0.3 max_grad_norm: 0.5 target_kl: null diff --git a/baselines/ppo/ppo_pufferlib.py b/baselines/ppo/ppo_pufferlib.py index ef892fef8..158b6dc1f 100644 --- a/baselines/ppo/ppo_pufferlib.py +++ b/baselines/ppo/ppo_pufferlib.py @@ -20,6 +20,7 @@ from gpudrive.env.env_puffer import PufferGPUDrive from gpudrive.networks.late_fusion import NeuralNet +from gpudrive.networks.agents import Agent from gpudrive.env.dataset import SceneDataLoader import pufferlib @@ -71,12 +72,17 @@ def make_agent(env, config): else: # Start from scratch - return NeuralNet( - input_dim=config.train.network.input_dim, + # return NeuralNet( + # input_dim=config.train.network.input_dim, + # action_dim=env.single_action_space.n, + # hidden_dim=config.train.network.hidden_dim, + # dropout=config.train.network.dropout, + # config=config.environment, + # ) + + return Agent( + embed_dim=64, action_dim=env.single_action_space.n, - hidden_dim=config.train.network.hidden_dim, - dropout=config.train.network.dropout, - config=config.environment, ) @@ -167,7 +173,7 @@ def run( off_road_weight: Annotated[Optional[float], typer.Option(help="The weight for off-road penalty")] = None, goal_achieved_weight: Annotated[Optional[float], typer.Option(help="The weight for goal-achieved reward")] = None, dist_to_goal_threshold: Annotated[Optional[float], typer.Option(help="The distance threshold for goal-achieved")] = None, - randomize_rewards: Annotated[Optional[int], typer.Option(help="If reward_type == reward_conditioned, choose the condition_mode; 0 or 1")] = 1, + randomize_rewards: Annotated[Optional[int], typer.Option(help="If reward_type == reward_conditioned, choose the condition_mode; 0 or 1")] = 0, sampling_seed: Annotated[Optional[int], typer.Option(help="The seed for sampling scenes")] = None, obs_radius: Annotated[Optional[float], typer.Option(help="The radius for the observation")] = None, collision_behavior: Annotated[Optional[str], typer.Option(help="The collision behavior; 'ignore' or 'remove'")] = None, diff --git a/gpudrive/integrations/puffer/ppo.py b/gpudrive/integrations/puffer/ppo.py index 302067a23..545d29e9c 100644 --- a/gpudrive/integrations/puffer/ppo.py +++ b/gpudrive/integrations/puffer/ppo.py @@ -383,6 +383,7 @@ def train(data): ): data.last_log_time = time.perf_counter() + data.wandb.log( { "performance/controlled_agent_sps": profile.controlled_agent_sps, @@ -393,6 +394,8 @@ def train(data): "performance/epoch": data.epoch, "performance/uptime": profile.uptime, "train/learning_rate": data.optimizer.param_groups[0]["lr"], + "train/advantages": data.wandb.Histogram(advantages_np), + "train/advantages_var": np.var(advantages_np), **{f"metrics/{k}": v for k, v in data.stats.items()}, **{f"train/{k}": v for k, v in data.losses.items()}, } diff --git a/gpudrive/networks/agents.py b/gpudrive/networks/agents.py new file mode 100644 index 000000000..c81d6b0e9 --- /dev/null +++ b/gpudrive/networks/agents.py @@ -0,0 +1,191 @@ +import torch +import torch.nn as nn + +import numpy as np + +from torch.distributions.categorical import Categorical + +import madrona_gpudrive +from gpudrive.env import constants + +TOP_K_ROAD_POINTS = madrona_gpudrive.kMaxAgentMapObservationsCount + + +def layer_init(layer, std=np.sqrt(2), bias_const=0.0): + torch.nn.init.orthogonal_(layer.weight, std) + torch.nn.init.constant_(layer.bias, bias_const) + return layer + + +class Agent(nn.Module): + """ " + Actor-Critic agent with separate actor and critic networks. + Expects a single observation vector as input. + """ + + def __init__( + self, + embed_dim, + action_dim, + act_func="tanh", + dropout=0.00, + ): + super().__init__() + + self.act_func = nn.Tanh() if act_func == "tanh" else nn.ReLU() + self.dropout = dropout + + # Indices for unpacking the observation modalities + self.ego_state_idx = 9 + self.max_controlled_agents = madrona_gpudrive.kMaxAgentCount + self.max_observable_agents = self.max_controlled_agents - 1 + self.partner_obs_idx = self.ego_state_idx + ( + constants.PARTNER_FEAT_DIM * self.max_observable_agents + ) + + # Actor's embedding networks + self.actor_ego_embed = nn.Sequential( + layer_init(nn.Linear(self.ego_state_idx, embed_dim)), + nn.LayerNorm(embed_dim), + self.act_func, + nn.Dropout(self.dropout), + layer_init(nn.Linear(embed_dim, embed_dim)), + ) + + self.actor_partner_embed = nn.Sequential( + layer_init(nn.Linear(constants.PARTNER_FEAT_DIM, embed_dim)), + nn.LayerNorm(embed_dim), + self.act_func, + nn.Dropout(self.dropout), + layer_init(nn.Linear(embed_dim, embed_dim)), + ) + + self.actor_road_map_embed = nn.Sequential( + layer_init(nn.Linear(constants.ROAD_GRAPH_FEAT_DIM, embed_dim)), + nn.LayerNorm(embed_dim), + self.act_func, + nn.Dropout(self.dropout), + layer_init(nn.Linear(embed_dim, embed_dim)), + ) + + # Critic's embedding networks + self.critic_ego_embed = nn.Sequential( + layer_init(nn.Linear(self.ego_state_idx, embed_dim)), + nn.LayerNorm(embed_dim), + self.act_func, + nn.Dropout(self.dropout), + layer_init(nn.Linear(embed_dim, embed_dim)), + ) + + self.critic_partner_embed = nn.Sequential( + layer_init(nn.Linear(constants.PARTNER_FEAT_DIM, embed_dim)), + nn.LayerNorm(embed_dim), + self.act_func, + nn.Dropout(self.dropout), + layer_init(nn.Linear(embed_dim, embed_dim)), + ) + + self.critic_road_map_embed = nn.Sequential( + layer_init(nn.Linear(constants.ROAD_GRAPH_FEAT_DIM, embed_dim)), + nn.LayerNorm(embed_dim), + self.act_func, + nn.Dropout(self.dropout), + layer_init(nn.Linear(embed_dim, embed_dim)), + ) + + # Critic network + self.critic = nn.Sequential( + layer_init(nn.Linear(3 * embed_dim, 32)), + nn.LayerNorm(32), + self.act_func, + layer_init( + nn.Linear(32, 1), std=1.0 + ), # Fixed the dimension (was 32) + ) + + # Actor network + self.actor = nn.Sequential( + layer_init(nn.Linear(3 * embed_dim, 64)), + nn.LayerNorm(64), + self.act_func, + layer_init(nn.Linear(64, action_dim), std=0.01), + ) + + def get_value(self, x): + # Unpack into modalities + ego_state, partner_obs, road_graph = self.unpack_obs(x) + + # Embed each modality using critic's embedding networks + critic_ego_embed = self.critic_ego_embed(ego_state) + critic_partner_embed = self.critic_partner_embed(partner_obs) + critic_road_embed = self.critic_road_map_embed(road_graph) + + # Concatenate the embeddings + critic_x = torch.cat( + [critic_ego_embed, critic_partner_embed, critic_road_embed], dim=-1 + ) + + return self.critic(critic_x) + + def forward(self, x, action=None): + """Forward pass through the network. + Args: + x: Flattened observation vector of size [B, F]. + action (Optional): Actions to take of size [B, 1]. + If None, a new actions are sampled. + """ + # Unpack into modalities + ego_state, partner_obs, road_graph = self.unpack_obs(x) + + actor_ego_embed = self.actor_ego_embed(ego_state) + actor_partner_embed, _ = self.actor_partner_embed(partner_obs).max( + dim=1 + ) + actor_road_embed, _ = self.actor_road_map_embed(road_graph).max(dim=1) + actor_z = torch.cat( + [actor_ego_embed, actor_partner_embed, actor_road_embed], dim=-1 + ) + + critic_ego_embed = self.critic_ego_embed(ego_state) + critic_partner_embed, _ = self.critic_partner_embed(partner_obs).max( + dim=1 + ) + critic_road_embed, _ = self.critic_road_map_embed(road_graph).max( + dim=1 + ) + critic_z = torch.cat( + [critic_ego_embed, critic_partner_embed, critic_road_embed], dim=-1 + ) + + # Pass to the actor and critic networks + logits = self.actor(actor_z) + probs = Categorical(logits=logits) + + if action is None: + action = probs.sample() + else: + # Reshape action from [B, 1] to [B] to match what Categorical expects + action = action.squeeze(-1) + + return ( + action, + probs.log_prob(action), + probs.entropy(), + self.critic(critic_z), + ) + + def unpack_obs(self, obs_flat): + """Unpack the flattened observation into the ego state, visible simulator state.""" + + ego_state = obs_flat[:, : self.ego_state_idx] + partner_obs = obs_flat[:, self.ego_state_idx : self.partner_obs_idx] + roadgraph_obs = obs_flat[:, self.partner_obs_idx :] + + road_objects = partner_obs.view( + -1, self.max_observable_agents, constants.PARTNER_FEAT_DIM + ) + road_graph = roadgraph_obs.view( + -1, TOP_K_ROAD_POINTS, constants.ROAD_GRAPH_FEAT_DIM + ) + + return ego_state, road_objects, road_graph From 6e3f257f2fca72c895354736f6566ddbf993449c Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Tue, 8 Apr 2025 15:29:22 -0400 Subject: [PATCH 26/81] Bug fix: checkpointing --- baselines/ppo/config/ppo_population.yaml | 13 ++++++------- baselines/ppo/ppo_pufferlib.py | 2 +- gpudrive/networks/agents.py | 1 + 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/baselines/ppo/config/ppo_population.yaml b/baselines/ppo/config/ppo_population.yaml index 171458bc9..d22cf408b 100644 --- a/baselines/ppo/config/ppo_population.yaml +++ b/baselines/ppo/config/ppo_population.yaml @@ -24,8 +24,8 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. init_mode: all_non_trivial # If reward_type is "reward_conditioned", the following parameters are used - randomize_rewards: false - condition_mode: fixed # Options: random, fixed + randomize_rewards: true + condition_mode: random # Options: random, fixed collision_weight_lb: -3.0 collision_weight_ub: 0.0 goal_achieved_weight_lb: 1.0 @@ -51,7 +51,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. wandb: entity: "" project: "kshotagents" - group: "small" + group: "separate_actor_critic" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] @@ -93,14 +93,13 @@ train: # # # Network # # # network: - input_dim: 64 # Embedding of the input features - hidden_dim: 128 # Latent dimension + embed_dim: 64 # Embedding of the input features dropout: 0.01 - class_name: "NeuralNet" + class_name: "Agent" num_parameters: 0 # Total trainable parameters, to be filled at runtime # # # Checkpointing # # # - checkpoint_interval: 500 # Save policy every k iterations + checkpoint_interval: 2 # Save policy every k iterations checkpoint_path: "./runs" # # # Rendering # # # diff --git a/baselines/ppo/ppo_pufferlib.py b/baselines/ppo/ppo_pufferlib.py index 158b6dc1f..6c2fd6f6e 100644 --- a/baselines/ppo/ppo_pufferlib.py +++ b/baselines/ppo/ppo_pufferlib.py @@ -81,7 +81,7 @@ def make_agent(env, config): # ) return Agent( - embed_dim=64, + embed_dim=config.train.network.embed_dim, action_dim=env.single_action_space.n, ) diff --git a/gpudrive/networks/agents.py b/gpudrive/networks/agents.py index c81d6b0e9..0b057afbf 100644 --- a/gpudrive/networks/agents.py +++ b/gpudrive/networks/agents.py @@ -34,6 +34,7 @@ def __init__( self.act_func = nn.Tanh() if act_func == "tanh" else nn.ReLU() self.dropout = dropout + self.action_dim = action_dim # Indices for unpacking the observation modalities self.ego_state_idx = 9 From 57b3ac47927d315958167057c4a7e239c95bfc4f Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Tue, 8 Apr 2025 15:38:01 -0400 Subject: [PATCH 27/81] wip --- baselines/ppo/config/ppo_population.yaml | 2 +- gpudrive/utils/compatible.py | 36 +++++++++++++----------- 2 files changed, 20 insertions(+), 18 deletions(-) diff --git a/baselines/ppo/config/ppo_population.yaml b/baselines/ppo/config/ppo_population.yaml index d22cf408b..9f4c7f9df 100644 --- a/baselines/ppo/config/ppo_population.yaml +++ b/baselines/ppo/config/ppo_population.yaml @@ -99,7 +99,7 @@ train: num_parameters: 0 # Total trainable parameters, to be filled at runtime # # # Checkpointing # # # - checkpoint_interval: 2 # Save policy every k iterations + checkpoint_interval: 250 # Save policy every k iterations checkpoint_path: "./runs" # # # Rendering # # # diff --git a/gpudrive/utils/compatible.py b/gpudrive/utils/compatible.py index 39b101741..e916536c7 100644 --- a/gpudrive/utils/compatible.py +++ b/gpudrive/utils/compatible.py @@ -129,7 +129,7 @@ def get_compatibility_scores( # Analysis settings config.data_dir = "data/processed/training" - config.environment.num_worlds = 100 + config.environment.num_worlds = 20 config.dataset_size = 5000 config.sample_with_replacement = True config.num_rollouts = 1 @@ -137,7 +137,8 @@ def get_compatibility_scores( config.device = "cuda" config.environment.reward_type = "reward_conditioned" config.environment.condition_mode = "fixed" - config.environment.agent_type = torch.Tensor([-0.5, 1.0, -0.5]) + config.environment.agent_type = torch.Tensor([-0.75, 1.0, -0.75]) + config.render = True agent = load_policy( model_name="model_pop_play____R_10000__04_04_18_27_28_702_002500", @@ -167,8 +168,8 @@ def get_compatibility_scores( num_rollouts=config.num_rollouts, device=config.device, identifier=f"{EXP_ID}_{config.environment.max_controlled_agents}", - render_sim_state=True, - render_every_t=5, + render_sim_state=config.render, + render_every_t=2, ) df = df.dropna() @@ -182,20 +183,21 @@ def get_compatibility_scores( print(f"off_road: {df['off_road_frac'].mean()*100:.2f}") # Save videos - sim_state_arrays = {k: np.array(v) for k, v in frames.items()} - videos_dir = Path(f"videos/reward_conditioned") - videos_dir.mkdir(parents=True, exist_ok=True) + if config.render: + sim_state_arrays = {k: np.array(v) for k, v in frames.items()} + videos_dir = Path(f"videos/reward_conditioned") + videos_dir.mkdir(parents=True, exist_ok=True) - for env_id, frames in sim_state_arrays.items(): + for env_id, frames in sim_state_arrays.items(): - filename = filenames[env_id] - video_path = videos_dir / f"{filename}.gif" + filename = filenames[env_id] + video_path = videos_dir / f"{filename}.gif" - mediapy.write_video( - str(video_path), - frames, - fps=5, - codec="gif", - ) + mediapy.write_video( + str(video_path), + frames, + fps=5, + codec="gif", + ) - print(f"Saved video to {video_path}") + print(f"Saved video to {video_path}") From e283c2989adae65fde650013434c75add8cb8696 Mon Sep 17 00:00:00 2001 From: daphnecor Date: Wed, 9 Apr 2025 09:07:51 -0400 Subject: [PATCH 28/81] Set training defaults to best params --- baselines/ppo/config/ppo_population.yaml | 8 ++++---- gpudrive/integrations/puffer/ppo.py | 1 + 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/baselines/ppo/config/ppo_population.yaml b/baselines/ppo/config/ppo_population.yaml index d22cf408b..4ff05427c 100644 --- a/baselines/ppo/config/ppo_population.yaml +++ b/baselines/ppo/config/ppo_population.yaml @@ -68,7 +68,7 @@ train: resample_scenes: false resample_dataset_size: 500 # Number of unique scenes to sample from resample_interval: 2_000_000 - sample_with_replacement: true + sample_with_replacement: false shuffle_dataset: false # # # PPO # # # @@ -85,8 +85,8 @@ train: clip_coef: 0.2 clip_vloss: false vf_clip_coef: 0.2 - ent_coef: 0.003 - vf_coef: 0.3 + ent_coef: 0.001 + vf_coef: 0.5 max_grad_norm: 0.5 target_kl: null log_window: 1000 @@ -99,7 +99,7 @@ train: num_parameters: 0 # Total trainable parameters, to be filled at runtime # # # Checkpointing # # # - checkpoint_interval: 2 # Save policy every k iterations + checkpoint_interval: 250 # Save policy every k iterations checkpoint_path: "./runs" # # # Rendering # # # diff --git a/gpudrive/integrations/puffer/ppo.py b/gpudrive/integrations/puffer/ppo.py index 545d29e9c..813355b5f 100644 --- a/gpudrive/integrations/puffer/ppo.py +++ b/gpudrive/integrations/puffer/ppo.py @@ -396,6 +396,7 @@ def train(data): "train/learning_rate": data.optimizer.param_groups[0]["lr"], "train/advantages": data.wandb.Histogram(advantages_np), "train/advantages_var": np.var(advantages_np), + "train/advantages_mean": np.mean(advantages_np), **{f"metrics/{k}": v for k, v in data.stats.items()}, **{f"train/{k}": v for k, v in data.losses.items()}, } From 6a23e2e8cf4305829f54145b125854a178480b0f Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Wed, 9 Apr 2025 16:16:58 -0400 Subject: [PATCH 29/81] Add separate waypoint following agent --- baselines/ppo/config/ppo_waypoint.yaml | 119 +++++++++ baselines/ppo/ppo_waypoint.py | 327 +++++++++++++++++++++++++ 2 files changed, 446 insertions(+) create mode 100644 baselines/ppo/config/ppo_waypoint.yaml create mode 100644 baselines/ppo/ppo_waypoint.py diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml new file mode 100644 index 000000000..84ea12870 --- /dev/null +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -0,0 +1,119 @@ +mode: "train" +use_rnn: false +eval_model_path: null +baseline: false +data_dir: data/processed/examples +continue_training: false +model_cpt: null + +environment: # Overrides default environment configs (see pygpudrive/env/config.py) + name: "gpudrive" + num_worlds: 100 # Number of parallel environments + k_unique_scenes: 4 # Number of unique scenes to sample from + max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp + ego_state: true + road_map_obs: true + partner_obs: true + norm_obs: true + remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists) + lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types + reward_type: "follow_waypoints" # Options: "weighted_combination", "reward_conditioned", "follow_waypoints" + collision_weight: -0.75 + off_road_weight: -0.75 + goal_achieved_weight: 1.0 + init_mode: all_non_trivial + + # If reward_type is "reward_conditioned", the following parameters are used + randomize_rewards: false + condition_mode: random # Options: random, fixed + collision_weight_lb: -3.0 + collision_weight_ub: 0.0 + goal_achieved_weight_lb: 1.0 + goal_achieved_weight_ub: 3.0 + off_road_weight_lb: -3.0 + off_road_weight_ub: 0.0 + + dynamics_model: "classic" + collision_behavior: "ignore" # Options: "remove", "stop", "ignore" + dist_to_goal_threshold: 2.0 + polyline_reduction_threshold: 0.1 # Rate at which to sample points from the polyline (0 is use all closest points, 1 maximum sparsity), needs to be balanced with kMaxAgentMapObservationsCount + sampling_seed: 42 # If given, the set of scenes to sample from will be deterministic, if None, the set of scenes will be random + obs_radius: 50.0 # Visibility radius of the agents + action_space_steer_disc: 13 + action_space_accel_disc: 7 + init_steps: 0 # Warmup steps + # Versatile Behavior Diffusion (VBD): This will slow down training + use_vbd: false + vbd_model_path: "gpudrive/integrations/vbd/weights/epoch=18.ckpt" + vbd_trajectory_weight: 0.1 # Importance of distance to the vbd trajectories in the reward function + vbd_in_obs: false + +wandb: + entity: "" + project: "blended" + group: "setup" + mode: "online" # Options: online, offline, disabled + tags: ["ppo", "ff"] + +train: + exp_id: # Set dynamically in the script if needed + seed: 42 + cpu_offload: false + device: "cuda" # Dynamically set to cuda if available, else cpu + bptt_horizon: 1 + compile: false + compile_mode: "reduce-overhead" + + # # # Data sampling # # # + resample_scenes: false + resample_dataset_size: 500 # Number of unique scenes to sample from + resample_interval: 2_000_000 + sample_with_replacement: false + shuffle_dataset: false + + # # # PPO # # # + torch_deterministic: false + total_timesteps: 2_000_000_000 + batch_size: 131072 + minibatch_size: 8192 + learning_rate: 3e-4 + anneal_lr: true + gamma: 0.99 + gae_lambda: 0.95 + update_epochs: 4 + norm_adv: true + clip_coef: 0.2 + clip_vloss: false + vf_clip_coef: 0.2 + ent_coef: 0.001 + vf_coef: 0.5 + max_grad_norm: 0.5 + target_kl: null + log_window: 1000 + + # # # Network # # # + network: + embed_dim: 64 # Embedding of the input features + dropout: 0.01 + class_name: "Agent" + num_parameters: 0 # Total trainable parameters, to be filled at runtime + + # # # Checkpointing # # # + checkpoint_interval: 250 # Save policy every k iterations + checkpoint_path: "./runs" + + # # # Rendering # # # + render: true # Determines whether to render the environment (note: will slow down training) + render_3d: false # Render simulator state in 3d or 2d + render_interval: 50 # Render every k iterations + render_k_scenarios: 1 # Number of scenarios to render + render_format: "mp4" # Options: gif, mp4 + render_fps: 20 # Frames per second + zoom_radius: 100 + plot_waypoints: true + +vec: + backend: "native" # Only native is currently supported + num_workers: 1 + env_batch_size: 1 + zero_copy: false diff --git a/baselines/ppo/ppo_waypoint.py b/baselines/ppo/ppo_waypoint.py new file mode 100644 index 000000000..b4375ce65 --- /dev/null +++ b/baselines/ppo/ppo_waypoint.py @@ -0,0 +1,327 @@ +""" +This implementation is adapted from the demo in PufferLib by Joseph Suarez, +which in turn is adapted from Costa Huang's CleanRL PPO + LSTM implementation. +Links +- PufferLib: https://github.com/PufferAI/PufferLib/blob/dev/demo.py +- Cleanrl: https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ppo.py +""" + +import os +from typing import Optional +from typing_extensions import Annotated +import yaml +from datetime import datetime +import torch +import numpy as np +import wandb +from box import Box + +from gpudrive.integrations.puffer import ppo +from gpudrive.env.env_puffer import PufferGPUDrive + +from gpudrive.networks.late_fusion import NeuralNet +from gpudrive.networks.agents import Agent +from gpudrive.env.dataset import SceneDataLoader + +import pufferlib +import pufferlib.vector +import pufferlib.cleanrl +from rich.console import Console + +import typer +from typer import Typer + +app = Typer() + + +def get_model_parameters(policy): + """Helper function to count the number of trainable parameters.""" + params = filter(lambda p: p.requires_grad, policy.parameters()) + return sum([np.prod(p.size()) for p in params]) + + +def load_config(config_path): + """Load the configuration file.""" + with open(config_path, "r") as f: + config = Box(yaml.safe_load(f)) + return pufferlib.namespace(**config) + + +def make_agent(env, config): + """Create a policy based on the environment.""" + + if config.continue_training: + print("Loading checkpoint...") + # Load checkpoint + saved_cpt = torch.load( + f=config.model_cpt, + map_location=config.train.device, + weights_only=False, + ) + policy = NeuralNet( + input_dim=saved_cpt["model_arch"]["input_dim"], + action_dim=saved_cpt["action_dim"], + hidden_dim=saved_cpt["model_arch"]["hidden_dim"], + config=config.environment, + ) + + # Load the model parameters + policy.load_state_dict(saved_cpt["parameters"]) + + return policy + + else: + # Start from scratch + # return NeuralNet( + # input_dim=config.train.network.input_dim, + # action_dim=env.single_action_space.n, + # hidden_dim=config.train.network.hidden_dim, + # dropout=config.train.network.dropout, + # config=config.environment, + # ) + + return Agent( + embed_dim=config.train.network.embed_dim, + action_dim=env.single_action_space.n, + ) + + +def train(args, vecenv): + """Main training loop for the PPO agent.""" + policy = make_agent(env=vecenv.driver_env, config=args).to( + args.train.device + ) + + args.train.network.num_parameters = get_model_parameters(policy) + args.train.env = args.environment.name + + args.wandb = init_wandb(args, args.train.exp_id, id=args.train.exp_id) + args.train.__dict__.update(dict(args.wandb.config.train)) + + data = ppo.create(args.train, vecenv, policy, wandb=args.wandb) + while data.global_step < args.train.total_timesteps: + try: + ppo.evaluate(data) # Rollout + ppo.train(data) # Update policy + except KeyboardInterrupt: + ppo.close(data) + os._exit(0) + except Exception as e: + print(f"An error occurred: {e}") # Log the error + Console().print_exception() + os._exit(1) # Exit with a non-zero status to indicate an error + + ppo.evaluate(data) + ppo.close(data) + + +def init_wandb(args, name, id=None, resume=True): + wandb.init( + id=id or wandb.util.generate_id(), + project=args.wandb.project, + entity=args.wandb.entity, + group=args.wandb.group, + mode=args.wandb.mode, + tags=args.wandb.tags, + config={ + "environment": dict(args.environment), + "train": dict(args.train), + "vec": dict(args.vec), + }, + name=name, + save_code=True, + resume=False, + ) + + return wandb + + +def sweep(args, project="PPO", sweep_name="my_sweep"): + """Initialize a WandB sweep with hyperparameters.""" + sweep_id = wandb.sweep( + sweep=dict( + method="random", + name=sweep_name, + metric={"goal": "maximize", "name": "environment/episode_return"}, + parameters={ + "learning_rate": { + "distribution": "log_uniform_values", + "min": 1e-4, + "max": 1e-1, + }, + "batch_size": {"values": [512, 1024, 2048]}, + "minibatch_size": {"values": [128, 256, 512]}, + }, + ), + project=project, + ) + wandb.agent(sweep_id, lambda: train(args), count=100) + + +@app.command() +def run( + config_path: Annotated[ + str, typer.Argument(help="The path to the default configuration file") + ] = "baselines/ppo/config/ppo_waypoint.yaml", + *, + # fmt: off + # Environment options + num_worlds: Annotated[Optional[int], typer.Option(help="Number of parallel envs")] = None, + max_controlled_agents: Annotated[Optional[int], typer.Option(help="Number of controlled agents")] = None, + k_unique_scenes: Annotated[Optional[int], typer.Option(help="The number of unique scenes to sample")] = None, + collision_weight: Annotated[Optional[float], typer.Option(help="The weight for collision penalty")] = None, + off_road_weight: Annotated[Optional[float], typer.Option(help="The weight for off-road penalty")] = None, + goal_achieved_weight: Annotated[Optional[float], typer.Option(help="The weight for goal-achieved reward")] = None, + dist_to_goal_threshold: Annotated[Optional[float], typer.Option(help="The distance threshold for goal-achieved")] = None, + randomize_rewards: Annotated[Optional[int], typer.Option(help="If reward_type == reward_conditioned, choose the condition_mode; 0 or 1")] = 0, + sampling_seed: Annotated[Optional[int], typer.Option(help="The seed for sampling scenes")] = None, + obs_radius: Annotated[Optional[float], typer.Option(help="The radius for the observation")] = None, + collision_behavior: Annotated[Optional[str], typer.Option(help="The collision behavior; 'ignore' or 'remove'")] = None, + remove_non_vehicles: Annotated[Optional[int], typer.Option(help="Remove non-vehicles from the scene; 0 or 1")] = None, + use_vbd: Annotated[Optional[bool], typer.Option(help="Use VBD model for trajectory predictions")] = False, + vbd_model_path: Annotated[Optional[str], typer.Option(help="Path to VBD model checkpoint")] = None, + vbd_trajectory_weight: Annotated[Optional[float], typer.Option(help="Weight for VBD trajectory deviation penalty")] = 0.1, + vbd_in_obs: Annotated[Optional[bool], typer.Option(help="Include VBD predictions in the observation")] = False, + init_steps: Annotated[Optional[int], typer.Option(help="Environment warmup steps")] = 0, + # Train options + seed: Annotated[Optional[int], typer.Option(help="The seed for training")] = None, + learning_rate: Annotated[Optional[float], typer.Option(help="The learning rate for training")] = None, + anneal_lr: Annotated[Optional[int], typer.Option(help="Whether to anneal the learning rate over time; 0 or 1")] = None, + resample_scenes: Annotated[Optional[int], typer.Option(help="Whether to resample scenes during training; 0 or 1")] = None, + resample_interval: Annotated[Optional[int], typer.Option(help="The interval for resampling scenes")] = None, + resample_dataset_size: Annotated[Optional[int], typer.Option(help="The size of the dataset to sample from")] = None, + total_timesteps: Annotated[Optional[int], typer.Option(help="The total number of training steps")] = None, + ent_coef: Annotated[Optional[float], typer.Option(help="Entropy coefficient")] = None, + update_epochs: Annotated[Optional[int], typer.Option(help="The number of epochs for updating the policy")] = None, + batch_size: Annotated[Optional[int], typer.Option(help="The batch size for training")] = None, + minibatch_size: Annotated[Optional[int], typer.Option(help="The minibatch size for training")] = None, + gamma: Annotated[Optional[float], typer.Option(help="The discount factor for rewards")] = None, + vf_coef: Annotated[Optional[float], typer.Option(help="Weight for vf_loss")] = None, + # Wandb logging options + project: Annotated[Optional[str], typer.Option(help="WandB project name")] = None, + entity: Annotated[Optional[str], typer.Option(help="WandB entity name")] = None, + group: Annotated[Optional[str], typer.Option(help="WandB group name")] = None, + render: Annotated[Optional[int], typer.Option(help="Whether to render the environment; 0 or 1")] = None, +): + """Run PPO training with the given configuration.""" + # fmt: on + + # Load default configs + config = load_config(config_path) + + if config.environment.reward_type == "reward_conditioned": + if bool(randomize_rewards): + config.environment.condition_mode = "random" + config.train.exp_id = "random_weights" + else: + config.environment.condition_mode = ( + "fixed" # Use the same type for every agent + ) + config.train.exp_id = "fixed_weights" + + # Override configs with command-line arguments + env_config = { + "num_worlds": num_worlds, + "max_controlled_agents": max_controlled_agents, + "k_unique_scenes": k_unique_scenes, + "collision_weight": collision_weight, + "off_road_weight": off_road_weight, + "goal_achieved_weight": goal_achieved_weight, + "dist_to_goal_threshold": dist_to_goal_threshold, + "sampling_seed": sampling_seed, + "obs_radius": obs_radius, + "collision_behavior": collision_behavior, + "remove_non_vehicles": None + if remove_non_vehicles is None + else bool(remove_non_vehicles), + "use_vbd": use_vbd, + "vbd_model_path": vbd_model_path, + "vbd_trajectory_weight": vbd_trajectory_weight, + "vbd_in_obs": vbd_in_obs, + "init_steps": init_steps, + } + config.environment.update( + {k: v for k, v in env_config.items() if v is not None} + ) + + train_config = { + "seed": seed, + "learning_rate": learning_rate, + "anneal_lr": None if anneal_lr is None else bool(anneal_lr), + "resample_scenes": None + if resample_scenes is None + else bool(resample_scenes), + "resample_interval": resample_interval, + "resample_dataset_size": resample_dataset_size, + "total_timesteps": total_timesteps, + "ent_coef": ent_coef, + "update_epochs": update_epochs, + "batch_size": batch_size, + "minibatch_size": minibatch_size, + "render": None if render is None else bool(render), + "gamma": gamma, + "vf_coef": vf_coef, + } + config.train.update( + {k: v for k, v in train_config.items() if v is not None} + ) + + wandb_config = { + "project": project, + "entity": entity, + "group": group, + } + config.wandb.update( + {k: v for k, v in wandb_config.items() if v is not None} + ) + + datetime_ = datetime.now().strftime("%m_%d_%H_%M_%S_%f")[:-3] + + if config["continue_training"]: + cont_train = "C" + else: + cont_train = "" + + if config["train"]["resample_scenes"]: + if config["train"]["resample_scenes"]: + dataset_size = config["train"]["resample_dataset_size"] + config["train"][ + "exp_id" + ] = f'{config["train"]["exp_id"]}__{cont_train}__R_{dataset_size}__{datetime_}' + else: + dataset_size = str(config["environment"]["k_unique_scenes"]) + config["train"][ + "exp_id" + ] = f'{config["train"]["exp_id"]}__{cont_train}__S_{dataset_size}__{datetime_}' + + config["environment"]["dataset_size"] = dataset_size + config["train"]["device"] = config["train"].get( + "device", "cpu" + ) # Default to 'cpu' if not set + if torch.cuda.is_available(): + config["train"]["device"] = "cuda" # Set to 'cuda' if available + + # Make dataloader + train_loader = SceneDataLoader( + root=config.data_dir, + batch_size=config.environment.num_worlds, + dataset_size=config.train.resample_dataset_size + if config.train.resample_scenes + else config.environment.k_unique_scenes, + sample_with_replacement=config.train.sample_with_replacement, + shuffle=config.train.shuffle_dataset, + ) + + # Make environment + vecenv = PufferGPUDrive( + data_loader=train_loader, + **config.environment, + **config.train, + ) + + train(config, vecenv) + + +if __name__ == "__main__": + + app() From 196fb5fe1478c5b8335785e36d58d37e1aae6166 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Wed, 9 Apr 2025 16:29:22 -0400 Subject: [PATCH 30/81] Merge dev into branch --- gpudrive/env/env_torch.py | 6 +++--- gpudrive/networks/late_fusion.py | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 3b7eae278..52caafb77 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -796,7 +796,7 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: if mask is None: if self.config.reward_type == "reward_conditioned": - + # Create expanded weights for all environments # Expand from [max_agents, 3] to [num_worlds, max_agents] collision_weights = self.reward_weights_tensor[:, 0].expand( @@ -808,7 +808,7 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: off_road_weights = self.reward_weights_tensor[:, 2].expand( self.num_worlds, -1 ) - + full_fields = base_fields + [ collision_weights, goal_weights, @@ -826,7 +826,7 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: weights_for_masked_agents = self.reward_weights_tensor.to( self.device )[agent_indices] - + return torch.stack( [ ego_state.speed, diff --git a/gpudrive/networks/late_fusion.py b/gpudrive/networks/late_fusion.py index 9bbd4c23b..9144918b6 100644 --- a/gpudrive/networks/late_fusion.py +++ b/gpudrive/networks/late_fusion.py @@ -98,7 +98,7 @@ def __init__( # Ego state base fields self.ego_state_idx = constants.EGO_FEAT_DIM - + if config is not None: self.config = Box(config) if "reward_type" in self.config: From d15363dc7ccdb54ad96679f01297cd478d505c4f Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Wed, 9 Apr 2025 20:27:03 -0400 Subject: [PATCH 31/81] Fix waypoint following implementation --- baselines/ppo/config/ppo_waypoint.yaml | 35 ++++-------- baselines/ppo/ppo_pufferlib.py | 1 + baselines/ppo/ppo_waypoint.py | 75 +++----------------------- gpudrive/env/config.py | 9 ++-- gpudrive/env/env_torch.py | 44 +++++++-------- gpudrive/integrations/puffer/ppo.py | 1 + gpudrive/networks/agents.py | 6 ++- 7 files changed, 47 insertions(+), 124 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 84ea12870..bc5cd803c 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -15,27 +15,12 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. road_map_obs: true partner_obs: true norm_obs: true - remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists) - lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types - reward_type: "follow_waypoints" # Options: "weighted_combination", "reward_conditioned", "follow_waypoints" - collision_weight: -0.75 - off_road_weight: -0.75 - goal_achieved_weight: 1.0 - init_mode: all_non_trivial - - # If reward_type is "reward_conditioned", the following parameters are used - randomize_rewards: false - condition_mode: random # Options: random, fixed - collision_weight_lb: -3.0 - collision_weight_ub: 0.0 - goal_achieved_weight_lb: 1.0 - goal_achieved_weight_ub: 3.0 - off_road_weight_lb: -3.0 - off_road_weight_ub: 0.0 - + collision_behavior: "ignore" + goal_behavior: "ignore" + reward_type: "follow_waypoints" + init_mode: womd_tracks_to_predict dynamics_model: "classic" - collision_behavior: "ignore" # Options: "remove", "stop", "ignore" - dist_to_goal_threshold: 2.0 + polyline_reduction_threshold: 0.1 # Rate at which to sample points from the polyline (0 is use all closest points, 1 maximum sparsity), needs to be balanced with kMaxAgentMapObservationsCount sampling_seed: 42 # If given, the set of scenes to sample from will be deterministic, if None, the set of scenes will be random obs_radius: 50.0 # Visibility radius of the agents @@ -50,16 +35,16 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. wandb: entity: "" - project: "blended" + project: "be_human" group: "setup" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] train: - exp_id: # Set dynamically in the script if needed + exp_id: follow_waypoint # Set dynamically in the script if needed seed: 42 cpu_offload: false - device: "cuda" # Dynamically set to cuda if available, else cpu + device: "cuda" # Dynamically set to cuda if available, else cpu bptt_horizon: 1 compile: false compile_mode: "reduce-overhead" @@ -89,7 +74,7 @@ train: vf_coef: 0.5 max_grad_norm: 0.5 target_kl: null - log_window: 1000 + log_window: 100 # # # Network # # # network: @@ -106,7 +91,7 @@ train: render: true # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d render_interval: 50 # Render every k iterations - render_k_scenarios: 1 # Number of scenarios to render + render_k_scenarios: 2 # Number of scenarios to render render_format: "mp4" # Options: gif, mp4 render_fps: 20 # Frames per second zoom_radius: 100 diff --git a/baselines/ppo/ppo_pufferlib.py b/baselines/ppo/ppo_pufferlib.py index 6c2fd6f6e..076d5623e 100644 --- a/baselines/ppo/ppo_pufferlib.py +++ b/baselines/ppo/ppo_pufferlib.py @@ -81,6 +81,7 @@ def make_agent(env, config): # ) return Agent( + config=config.environment, embed_dim=config.train.network.embed_dim, action_dim=env.single_action_space.n, ) diff --git a/baselines/ppo/ppo_waypoint.py b/baselines/ppo/ppo_waypoint.py index b4375ce65..9e4782277 100644 --- a/baselines/ppo/ppo_waypoint.py +++ b/baselines/ppo/ppo_waypoint.py @@ -18,14 +18,10 @@ from gpudrive.integrations.puffer import ppo from gpudrive.env.env_puffer import PufferGPUDrive - -from gpudrive.networks.late_fusion import NeuralNet from gpudrive.networks.agents import Agent from gpudrive.env.dataset import SceneDataLoader import pufferlib -import pufferlib.vector -import pufferlib.cleanrl from rich.console import Console import typer @@ -49,41 +45,11 @@ def load_config(config_path): def make_agent(env, config): """Create a policy based on the environment.""" - - if config.continue_training: - print("Loading checkpoint...") - # Load checkpoint - saved_cpt = torch.load( - f=config.model_cpt, - map_location=config.train.device, - weights_only=False, - ) - policy = NeuralNet( - input_dim=saved_cpt["model_arch"]["input_dim"], - action_dim=saved_cpt["action_dim"], - hidden_dim=saved_cpt["model_arch"]["hidden_dim"], - config=config.environment, - ) - - # Load the model parameters - policy.load_state_dict(saved_cpt["parameters"]) - - return policy - - else: - # Start from scratch - # return NeuralNet( - # input_dim=config.train.network.input_dim, - # action_dim=env.single_action_space.n, - # hidden_dim=config.train.network.hidden_dim, - # dropout=config.train.network.dropout, - # config=config.environment, - # ) - - return Agent( - embed_dim=config.train.network.embed_dim, - action_dim=env.single_action_space.n, - ) + return Agent( + config=config.environment, + embed_dim=config.train.network.embed_dim, + action_dim=env.single_action_space.n, + ) def train(args, vecenv): @@ -136,28 +102,6 @@ def init_wandb(args, name, id=None, resume=True): return wandb -def sweep(args, project="PPO", sweep_name="my_sweep"): - """Initialize a WandB sweep with hyperparameters.""" - sweep_id = wandb.sweep( - sweep=dict( - method="random", - name=sweep_name, - metric={"goal": "maximize", "name": "environment/episode_return"}, - parameters={ - "learning_rate": { - "distribution": "log_uniform_values", - "min": 1e-4, - "max": 1e-1, - }, - "batch_size": {"values": [512, 1024, 2048]}, - "minibatch_size": {"values": [128, 256, 512]}, - }, - ), - project=project, - ) - wandb.agent(sweep_id, lambda: train(args), count=100) - - @app.command() def run( config_path: Annotated[ @@ -277,22 +221,17 @@ def run( datetime_ = datetime.now().strftime("%m_%d_%H_%M_%S_%f")[:-3] - if config["continue_training"]: - cont_train = "C" - else: - cont_train = "" - if config["train"]["resample_scenes"]: if config["train"]["resample_scenes"]: dataset_size = config["train"]["resample_dataset_size"] config["train"][ "exp_id" - ] = f'{config["train"]["exp_id"]}__{cont_train}__R_{dataset_size}__{datetime_}' + ] = f'{config["train"]["exp_id"]}__R_{dataset_size}__{datetime_}' else: dataset_size = str(config["environment"]["k_unique_scenes"]) config["train"][ "exp_id" - ] = f'{config["train"]["exp_id"]}__{cont_train}__S_{dataset_size}__{datetime_}' + ] = f'{config["train"]["exp_id"]}__S_{dataset_size}__{datetime_}' config["environment"]["dataset_size"] = dataset_size config["train"]["device"] = config["train"].get( diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index 40e2bbc2e..77f54d4f9 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -86,7 +86,7 @@ class EnvConfig: collision_behavior: str = "ignore" # Options: "remove", "stop", "ignore" # Scene configuration - remove_non_vehicles: bool = True # Remove non-vehicle entities from scene + remove_non_vehicles: bool = False # Remove non-vehicle entities from scene # Initialization steps: Number of steps to take before the episode starts init_steps: int = 0 @@ -100,11 +100,8 @@ class EnvConfig: # Alternatively, "weighted_combination", "follow_waypoints", "distance_to_vdb_trajs", "reward_conditioned" # If reward_type is "follow_waypoints", the following parameters are used - waypoint_radius: float = ( - 0.5 # Radius around the waypoint to consider as "reached" - ) - waypoint_sample_interval: int = 10 # Interval for sampling waypoints - waypoint_max_reward: float = 1.0 # Maximum reward for reaching a waypoint + waypoint_sample_interval: int = 1 # Interval for sampling waypoints + waypoint_distance_scale: float = 0.1 # Importance of distance to waypoints # If reward_type is "reward_conditioned", the following parameters are used # Weights for the reward components diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 52caafb77..bbd61c4d7 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -560,10 +560,10 @@ def get_rewards( return weighted_rewards elif self.config.reward_type == "follow_waypoints": - # Reward based on proximity to waypoints within a radius and penalty for collision/off-road + # Reward based on minimizing distance to time-aligned waypoints plus penalty for collision/off-road # Calculate base weighted rewards - base_rewards = ( + self.base_rewards = ( collision_weight * collided + goal_achieved_weight * goal_achieved + off_road_weight * off_road @@ -575,12 +575,6 @@ def get_rewards( batch_indices, :, world_time_steps, : ] - waypoint_mask = ( - (world_time_steps % self.config.waypoint_sample_interval == 0) - .float() - .unsqueeze(1) - ) - # Get actual agent positions agent_state = GlobalEgoState.from_tensor( self.sim.absolute_self_observation_tensor(), @@ -592,27 +586,29 @@ def get_rewards( ) # Compute euclidean distance between agent and waypoints - dist_to_waypoints = torch.norm( + self.dist_to_waypoints = torch.norm( gt_agent_pos - actual_agent_pos, dim=-1 ) - # Apply waypoint mask to zero out distances for non-sampled time steps - dist_to_waypoints = dist_to_waypoints * waypoint_mask - - # Create proximity reward based on waypoint_radius - # Only reward agents within the waypoint radius - # Smoothly increases as agent gets closer to the center - proximity_mask = ( - dist_to_waypoints <= self.config.waypoint_radius - ).float() - - waypoint_rewards = ( - proximity_mask - * (1.0 - dist_to_waypoints / self.config.waypoint_radius) - * self.config.waypoint_max_reward + distance_penalty = ( + -self.config.waypoint_distance_scale + * torch.log(self.dist_to_waypoints + 1.0) ) - rewards = base_rewards + waypoint_rewards + # Apply waypoint mask only if sampling interval is greater than 1 + if self.config.waypoint_sample_interval > 1: + waypoint_mask = ( + ( + world_time_steps % self.config.waypoint_sample_interval + == 0 + ) + .float() + .unsqueeze(1) + ) + distance_penalty = distance_penalty * waypoint_mask + + # Combine base rewards with distance penalty + rewards = self.base_rewards + distance_penalty return rewards diff --git a/gpudrive/integrations/puffer/ppo.py b/gpudrive/integrations/puffer/ppo.py index 813355b5f..4de2a0caf 100644 --- a/gpudrive/integrations/puffer/ppo.py +++ b/gpudrive/integrations/puffer/ppo.py @@ -720,6 +720,7 @@ def save_checkpoint(data, save_checkpoint_to_wandb=True): "action_dim": data.uncompiled_policy.action_dim, "exp_id": config.exp_id, "num_params": config.network["num_parameters"], + "config": config, } torch.save(state, model_path) diff --git a/gpudrive/networks/agents.py b/gpudrive/networks/agents.py index 0b057afbf..962cc2dc1 100644 --- a/gpudrive/networks/agents.py +++ b/gpudrive/networks/agents.py @@ -25,6 +25,7 @@ class Agent(nn.Module): def __init__( self, + config, embed_dim, action_dim, act_func="tanh", @@ -32,12 +33,15 @@ def __init__( ): super().__init__() + self.config = config self.act_func = nn.Tanh() if act_func == "tanh" else nn.ReLU() self.dropout = dropout self.action_dim = action_dim # Indices for unpacking the observation modalities - self.ego_state_idx = 9 + self.ego_state_idx = ( + 9 if config["reward_type"] == "reward_conditioned" else 6 + ) self.max_controlled_agents = madrona_gpudrive.kMaxAgentCount self.max_observable_agents = self.max_controlled_agents - 1 self.partner_obs_idx = self.ego_state_idx + ( From 08513ec2e50ba1f5612dd7f677228f2a8fe9f31c Mon Sep 17 00:00:00 2001 From: daphnecor Date: Thu, 10 Apr 2025 10:43:45 -0400 Subject: [PATCH 32/81] Sbatch --- gpudrive/utils/generate_sbatch.py | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/gpudrive/utils/generate_sbatch.py b/gpudrive/utils/generate_sbatch.py index f786aebf3..e34f26d79 100644 --- a/gpudrive/utils/generate_sbatch.py +++ b/gpudrive/utils/generate_sbatch.py @@ -243,10 +243,10 @@ def save_script(filename, file_path, fields, params, param_order=None): if __name__ == "__main__": - group = "04_04" + group = "separate_actor_critic" fields = { - "time_h": 47, # Max time per job (job will finish if run is done before) + "time_h": 24, # Max time per job (job will finish if run is done before) "num_gpus": 1, # GPUs per job "max_sim_jobs": 30, # Max jobs at the same time "memory": 70, @@ -255,18 +255,17 @@ def save_script(filename, file_path, fields, params, param_order=None): hyperparams = { "group": [group], # Group name - "num_worlds": [300], - "resample_scenes": [1], # Yes - "k_unique_scenes": [300], - "max_controlled_agents": [64], + "num_worlds": [500], + "resample_scenes": [0], + "k_unique_scenes": [500], "resample_interval": [5_000_000], - "total_timesteps": [4_000_000_000], "resample_dataset_size": [10_000], + "total_timesteps": [3_000_000_000], "batch_size": [262144], "minibatch_size": [16384], - "update_epochs": [3, 4], - "ent_coef": [0.001, 0.0001, 0.003], - "learning_rate": [1e-4, 3e-4], + "update_epochs": [4], + "ent_coef": [0.001, 0.003, 0.0001], + "randomize_rewards": [0, 1], "render": [0], } From cfa2081ade15d25b067fab84e07fb1a5e43ffe22 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 10 Apr 2025 10:50:28 -0400 Subject: [PATCH 33/81] Can successful learn waypoint following agent --- baselines/ppo/config/ppo_waypoint.yaml | 5 ++-- gpudrive/env/config.py | 4 ++- gpudrive/env/env_puffer.py | 40 ++++++++++++++++++++++---- gpudrive/env/env_torch.py | 13 +++++---- 4 files changed, 48 insertions(+), 14 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index bc5cd803c..13d8f6797 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -18,9 +18,8 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. collision_behavior: "ignore" goal_behavior: "ignore" reward_type: "follow_waypoints" - init_mode: womd_tracks_to_predict + init_mode: all_non_trivial #womd_tracks_to_predict dynamics_model: "classic" - polyline_reduction_threshold: 0.1 # Rate at which to sample points from the polyline (0 is use all closest points, 1 maximum sparsity), needs to be balanced with kMaxAgentMapObservationsCount sampling_seed: 42 # If given, the set of scenes to sample from will be deterministic, if None, the set of scenes will be random obs_radius: 50.0 # Visibility radius of the agents @@ -35,7 +34,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. wandb: entity: "" - project: "be_human" + project: "humanlike" group: "setup" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index 77f54d4f9..e269252eb 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -101,7 +101,9 @@ class EnvConfig: # If reward_type is "follow_waypoints", the following parameters are used waypoint_sample_interval: int = 1 # Interval for sampling waypoints - waypoint_distance_scale: float = 0.1 # Importance of distance to waypoints + waypoint_distance_scale: float = ( + 0.05 # Importance of distance to waypoints + ) # If reward_type is "reward_conditioned", the following parameters are used # Weights for the reward components diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 1d7937552..2657c8ae7 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -51,6 +51,7 @@ def __init__( condition_mode="random", collision_behavior="ignore", goal_behavior="remove", + init_mode="all_non_trivial", collision_weight=-0.5, off_road_weight=-0.5, goal_achieved_weight=1, @@ -93,6 +94,8 @@ def __init__( self.collision_weight = collision_weight self.off_road_weight = off_road_weight self.goal_achieved_weight = goal_achieved_weight + self.init_mode = init_mode + self.reward_type = reward_type self.render = render self.render_interval = render_interval @@ -129,6 +132,7 @@ def __init__( dynamics_model=dynamics_model, collision_behavior=collision_behavior, goal_behavior=goal_behavior, + init_mode=init_mode, dist_to_goal_threshold=dist_to_goal_threshold, polyline_reduction_threshold=polyline_reduction_threshold, remove_non_vehicles=remove_non_vehicles, @@ -218,6 +222,14 @@ def reset(self, seed=None): self.episode_returns = torch.zeros( self.num_agents, dtype=torch.float32 ).to(self.device) + self.human_like_rewards = torch.zeros( + (self.num_worlds, self.max_cont_agents_per_env), + dtype=torch.float32, + ).to(self.device) + self.internal_rewards = torch.zeros( + (self.num_worlds, self.max_cont_agents_per_env), + dtype=torch.float32, + ).to(self.device) self.agent_episode_returns = torch.zeros( (self.num_worlds, self.max_cont_agents_per_env), dtype=torch.float32, @@ -262,8 +274,19 @@ def step(self, action): goal_achieved_weight=self.goal_achieved_weight, world_time_steps=self.episode_lengths[:, 0].long(), ) + # Flatten rewards; only keep rewards for controlled agents reward_controlled = reward[self.controlled_agent_mask] + + # Store human-like and internal rewards separately + if self.reward_type == "follow_waypoints": + self.human_like_rewards[ + self.live_agent_mask + ] += self.env.distance_penalty[self.live_agent_mask] + self.internal_rewards[ + self.live_agent_mask + ] += self.env.base_rewards[self.live_agent_mask] + terminal = self.env.get_dones().bool() self.render_env() if self.render else None @@ -347,8 +370,13 @@ def step(self, action): / num_finished_agents ) - total_collisions = self.collided_in_episode[done_worlds, :].sum() - total_off_road = self.offroad_in_episode[done_worlds, :].sum() + # Calculate human-likeness metrics for completed episodes + human_like_values = self.human_like_rewards[done_worlds, :][ + controlled_mask + ] + internal_reward_values = self.internal_rewards[done_worlds, :][ + controlled_mask + ] agent_episode_returns = self.agent_episode_returns[done_worlds, :][ controlled_mask @@ -362,6 +390,7 @@ def step(self, action): # fmt: off info_lst.append( { + "num_completed_episodes": len(done_worlds), "mean_episode_reward_per_agent": agent_episode_returns.mean().item(), "perc_goal_achieved": goal_achieved_rate.item(), "perc_off_road": off_road_rate.item(), @@ -370,9 +399,8 @@ def step(self, action): "control_density": self.num_agents / self.controlled_agent_mask.numel(), "episode_length": self.episode_lengths[done_worlds, :].mean().item(), "perc_truncated": num_truncated / num_finished_agents, - "num_completed_episodes": len(done_worlds), - "total_collisions": total_collisions.item(), - "total_off_road": total_off_road.item(), + "mean_waypoint_distance": human_like_values.mean().item(), + "mean_internal_reward": internal_reward_values.mean().item(), } ) # fmt: on @@ -392,6 +420,8 @@ def step(self, action): ] self.offroad_in_episode[done_worlds, :] = 0 self.collided_in_episode[done_worlds, :] = 0 + self.human_like_rewards[done_worlds, :] = 0 + self.internal_rewards[done_worlds, :] = 0 # Get the next observations. Note that we do this after resetting # the worlds so that we always return a fresh observation diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index bbd61c4d7..13bde462b 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -586,13 +586,13 @@ def get_rewards( ) # Compute euclidean distance between agent and waypoints - self.dist_to_waypoints = torch.norm( + dist_to_waypoints = torch.norm( gt_agent_pos - actual_agent_pos, dim=-1 ) - distance_penalty = ( + self.distance_penalty = ( -self.config.waypoint_distance_scale - * torch.log(self.dist_to_waypoints + 1.0) + * torch.log(dist_to_waypoints + 1.0) ) # Apply waypoint mask only if sampling interval is greater than 1 @@ -605,10 +605,13 @@ def get_rewards( .float() .unsqueeze(1) ) - distance_penalty = distance_penalty * waypoint_mask + self.distance_penalty = self.distance_penalty * waypoint_mask + + if self.distance_penalty.max() > 10: + print("huh") # Combine base rewards with distance penalty - rewards = self.base_rewards + distance_penalty + rewards = self.base_rewards + self.distance_penalty return rewards From 6ba22ae63225e34d9d9733c72eea1e7d3243c161 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 10 Apr 2025 10:57:31 -0400 Subject: [PATCH 34/81] Add goal state to ego state by default, so that agents know when the goal is reached. --- baselines/ppo/config/ppo_waypoint.yaml | 1 + gpudrive/networks/agents.py | 5 ++++- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 13d8f6797..5ba2ef31d 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -15,6 +15,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. road_map_obs: true partner_obs: true norm_obs: true + add_goal_state: true collision_behavior: "ignore" goal_behavior: "ignore" reward_type: "follow_waypoints" diff --git a/gpudrive/networks/agents.py b/gpudrive/networks/agents.py index 962cc2dc1..ff34064c9 100644 --- a/gpudrive/networks/agents.py +++ b/gpudrive/networks/agents.py @@ -40,8 +40,11 @@ def __init__( # Indices for unpacking the observation modalities self.ego_state_idx = ( - 9 if config["reward_type"] == "reward_conditioned" else 6 + 9 if self.config["reward_type"] == "reward_conditioned" else 6 ) + if self.config["add_goal_state"]: + self.ego_state_idx += 1 + self.max_controlled_agents = madrona_gpudrive.kMaxAgentCount self.max_observable_agents = self.max_controlled_agents - 1 self.partner_obs_idx = self.ego_state_idx + ( From 3acdec83b543408fb32bc6731ec4d8e4e9e985c3 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 10 Apr 2025 12:34:52 -0400 Subject: [PATCH 35/81] Increase log window size --- baselines/ppo/config/ppo_waypoint.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 5ba2ef31d..3247ee209 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -74,7 +74,7 @@ train: vf_coef: 0.5 max_grad_norm: 0.5 target_kl: null - log_window: 100 + log_window: 500 # # # Network # # # network: From 4e2a256e1a433f96c4c264dc116073db236b9df7 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Sat, 12 Apr 2025 11:54:17 -0400 Subject: [PATCH 36/81] Remove the goal reward when following waypoints --- gpudrive/env/env_torch.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 13bde462b..8ef80c4bd 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -462,7 +462,7 @@ def get_infos(self): def get_rewards( self, collision_weight=-0.5, - goal_achieved_weight=1.0, + goal_achieved_weight=0.5, off_road_weight=-0.5, world_time_steps=None, ): @@ -561,12 +561,8 @@ def get_rewards( elif self.config.reward_type == "follow_waypoints": # Reward based on minimizing distance to time-aligned waypoints plus penalty for collision/off-road - - # Calculate base weighted rewards self.base_rewards = ( - collision_weight * collided - + goal_achieved_weight * goal_achieved - + off_road_weight * off_road + collision_weight * collided + off_road_weight * off_road ) # Extract waypoints (ground truth) at time t From 84a139b0e0e36c7f776960db452466235443cd5d Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Sat, 12 Apr 2025 11:58:47 -0400 Subject: [PATCH 37/81] Set roadpoints to default to avoid switching --- src/consts.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/consts.hpp b/src/consts.hpp index 0768e9cd0..a99a4c65a 100644 --- a/src/consts.hpp +++ b/src/consts.hpp @@ -10,7 +10,7 @@ namespace consts { inline constexpr madrona::CountT kMaxAgentCount = 64; inline constexpr madrona::CountT kMaxRoadEntityCount = 10000; -inline constexpr madrona::CountT kMaxAgentMapObservationsCount = 128; +inline constexpr madrona::CountT kMaxAgentMapObservationsCount = 200; inline constexpr bool useEstimatedYaw = true; From 37ebb565039013970f215ae9d9f17c33efc35c4d Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Mon, 14 Apr 2025 15:30:55 -0400 Subject: [PATCH 38/81] Implement reference path in reward and observation --- baselines/ppo/config/ppo_base_puffer.yaml | 2 +- baselines/ppo/config/ppo_waypoint.yaml | 18 ++-- gpudrive/datatypes/trajectory.py | 47 +++++++++- gpudrive/env/config.py | 6 +- gpudrive/env/env_puffer.py | 7 +- gpudrive/env/env_torch.py | 102 ++++++++++++++++++---- gpudrive/networks/agents.py | 6 +- gpudrive/networks/late_fusion.py | 4 +- 8 files changed, 158 insertions(+), 34 deletions(-) diff --git a/baselines/ppo/config/ppo_base_puffer.yaml b/baselines/ppo/config/ppo_base_puffer.yaml index 728d4e129..12d290344 100644 --- a/baselines/ppo/config/ppo_base_puffer.yaml +++ b/baselines/ppo/config/ppo_base_puffer.yaml @@ -15,7 +15,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. road_map_obs: true partner_obs: true norm_obs: true - add_goal_state: false # If true, the goal state is added to the ego observation + add_reference_path: false # If true, the goal state is added to the ego observation remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists) lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types reward_type: "reward_conditioned" # Options: "weighted_combination", "reward_conditioned" diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 3247ee209..cce3d0a7a 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -8,16 +8,15 @@ model_cpt: null environment: # Overrides default environment configs (see pygpudrive/env/config.py) name: "gpudrive" - num_worlds: 100 # Number of parallel environments + num_worlds: 75 # Number of parallel environments k_unique_scenes: 4 # Number of unique scenes to sample from max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp ego_state: true road_map_obs: true partner_obs: true norm_obs: true - add_goal_state: true collision_behavior: "ignore" - goal_behavior: "ignore" + goal_behavior: "remove" reward_type: "follow_waypoints" init_mode: all_non_trivial #womd_tracks_to_predict dynamics_model: "classic" @@ -27,16 +26,23 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. action_space_steer_disc: 13 action_space_accel_disc: 7 init_steps: 0 # Warmup steps + collision_weight: 0.0 + off_road_weight: 0.0 + # Versatile Behavior Diffusion (VBD): This will slow down training use_vbd: false vbd_model_path: "gpudrive/integrations/vbd/weights/epoch=18.ckpt" vbd_trajectory_weight: 0.1 # Importance of distance to the vbd trajectories in the reward function vbd_in_obs: false + # Planning guidance + add_reference_path: true # If true, the goal state is added to the ego observation + prob_reference_dropout: 0.0 # Value between 0 and 1, probability of a reference point to be zeroed out + wandb: entity: "" project: "humanlike" - group: "setup" + group: "reference_path" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] @@ -88,10 +94,10 @@ train: checkpoint_path: "./runs" # # # Rendering # # # - render: true # Determines whether to render the environment (note: will slow down training) + render: false # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d render_interval: 50 # Render every k iterations - render_k_scenarios: 2 # Number of scenarios to render + render_k_scenarios: 1 # Number of scenarios to render render_format: "mp4" # Options: gif, mp4 render_fps: 20 # Frames per second zoom_radius: 100 diff --git a/gpudrive/datatypes/trajectory.py b/gpudrive/datatypes/trajectory.py index aeeffed79..72ae534bb 100644 --- a/gpudrive/datatypes/trajectory.py +++ b/gpudrive/datatypes/trajectory.py @@ -5,6 +5,45 @@ TRAJ_LEN = 91 # Length of the logged trajectory +def to_local_frame(global_xy: torch.Tensor, ego_pos: torch.Tensor, ego_yaw: torch.Tensor): + """ + Transform trajectory from global coordinates to ego-centric frame. + Args: + global_xy: Shape (agents, time_steps, 2) containing x,y positions of the trajectory + ego_pos: Shape (agents, 2) containing respective ego x,y positions + ego_yaw: Shape (agents, 1) containing ego yaw angle in radians + + Returns: + transformed pos_xy: Shape (agents, time_steps, 2) in ego-centric frame + """ + # Translate trajectory to be relative to ego position + translated_pos_xy = global_xy - ego_pos.unsqueeze(1) + + # Create rotation matrices for each agent + cos_yaw = torch.cos(ego_yaw).squeeze(-1) + sin_yaw = torch.sin(ego_yaw).squeeze(-1) + + # Create 2x2 rotation matrix for each agent + num_agents = global_xy.shape[0] + rotation_matrices = torch.zeros(num_agents, 2, 2, device=global_xy.device) + rotation_matrices[:, 0, 0] = cos_yaw + rotation_matrices[:, 0, 1] = sin_yaw + rotation_matrices[:, 1, 0] = -sin_yaw + rotation_matrices[:, 1, 1] = cos_yaw + + # Apply rotation + num_agents, time_steps = global_xy.shape[0], global_xy.shape[1] + local_pos_xy = torch.zeros_like(global_xy) + + for t in range(time_steps): + pos_t = translated_pos_xy[:, t] + local_pos_xy[:, t] = torch.bmm( + rotation_matrices, + pos_t.unsqueeze(-1) + ).squeeze(-1) + + return local_pos_xy + @dataclass class LogTrajectory: """A class to represent the logged human trajectories. Initialized from `expert_trajectory_tensor` (src/bindings.cpp). @@ -37,6 +76,11 @@ def __init__( self.inferred_actions = raw_logs[:, :, 6 * TRAJ_LEN: 16 * TRAJ_LEN].view( num_worlds, max_agents, TRAJ_LEN, -1 ) + + # Zero-out invalid timesteps + self.pos_xy = self.pos_xy * self.valids + self.vel_xy = self.vel_xy * self.valids + self.yaw = self.yaw * self.valids @classmethod def from_tensor( @@ -62,4 +106,5 @@ def restore_mean(self, mean_x, mean_y): # Apply to x and y coordinates self.pos_xy[:, :, :, 0] += mean_x_reshaped - self.pos_xy[:, :, :, 1] += mean_y_reshaped \ No newline at end of file + self.pos_xy[:, :, :, 1] += mean_y_reshaped + \ No newline at end of file diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index e269252eb..45a9965ee 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -93,7 +93,11 @@ class EnvConfig: # Goal behavior settings goal_behavior: str = "remove" # Options: "stop", "ignore", "remove" - add_goal_state: bool = False # Add goal state to the scene + + # Reference points settings + add_reference_path: bool = False + prob_reference_dropout: float = 0.0 # Probability of dropping reference points + min_reference_points: int = 1 # Minimum number of reference points # Reward settings reward_type: str = "sparse_on_goal_achieved" diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 2657c8ae7..ac4891d81 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -46,7 +46,8 @@ def __init__( norm_obs=True, lidar_obs=False, bev_obs=False, - add_goal_state=False, + add_reference_path=False, + prob_reference_dropout=0.0, reward_type="weighted_combination", condition_mode="random", collision_behavior="ignore", @@ -96,6 +97,7 @@ def __init__( self.goal_achieved_weight = goal_achieved_weight self.init_mode = init_mode self.reward_type = reward_type + self.prob_reference_dropout = prob_reference_dropout self.render = render self.render_interval = render_interval @@ -128,7 +130,8 @@ def __init__( condition_mode=condition_mode, norm_obs=norm_obs, bev_obs=bev_obs, - add_goal_state=add_goal_state, + add_reference_path=add_reference_path, + prob_reference_dropout=prob_reference_dropout, dynamics_model=dynamics_model, collision_behavior=collision_behavior, goal_behavior=goal_behavior, diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 8ef80c4bd..d59370fe8 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -18,7 +18,7 @@ from gpudrive.env import constants from gpudrive.env.config import EnvConfig, RenderConfig from gpudrive.env.base_env import GPUDriveGymEnv -from gpudrive.datatypes.trajectory import LogTrajectory +from gpudrive.datatypes.trajectory import LogTrajectory, to_local_frame from gpudrive.datatypes.roadgraph import ( LocalRoadGraphPoints, GlobalRoadGraphPoints, @@ -570,7 +570,7 @@ def get_rewards( gt_agent_pos = self.log_trajectory.pos_xy[ batch_indices, :, world_time_steps, : ] - + # Get actual agent positions agent_state = GlobalEgoState.from_tensor( self.sim.absolute_self_observation_tensor(), @@ -580,7 +580,7 @@ def get_rewards( actual_agent_pos = torch.stack( [agent_state.pos_x, agent_state.pos_y], dim=-1 ) - + # Compute euclidean distance between agent and waypoints dist_to_waypoints = torch.norm( gt_agent_pos - actual_agent_pos, dim=-1 @@ -778,18 +778,53 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: ego_state.normalize() base_fields = [ - ego_state.speed, - ego_state.vehicle_length, - ego_state.vehicle_width, - ego_state.rel_goal_x, - ego_state.rel_goal_y, - ego_state.is_collided, + ego_state.speed.unsqueeze(-1), + ego_state.vehicle_length.unsqueeze(-1), + ego_state.vehicle_width.unsqueeze(-1), + ego_state.rel_goal_x.unsqueeze(-1), + ego_state.rel_goal_y.unsqueeze(-1), + ego_state.is_collided.unsqueeze(-1), ] - - if self.config.add_goal_state: - base_fields.append(ego_state.is_goal_reached) - + if mask is None: + + if self.config.add_reference_path: + + # Shape: [batch, 91, 2] + glob_ego_states = self.sim.absolute_self_observation_tensor().to_torch().clone() + glob_ego_pos_xy = glob_ego_states[:, :, :2] + glob_ego_yaw = glob_ego_states[:, :, 7] + + reference_xy = self.log_trajectory.pos_xy + + # Normalize + reference_xy /= constants.MAX_REL_GOAL_COORD + + # Transform reference path to be relative to current + # agent positions and heading + for i in range(self.num_worlds): + reference_xy[i] = to_local_frame( + reference_xy[i], + glob_ego_pos_xy[i], + glob_ego_yaw[i], + ) + + batch_size = reference_xy.shape[0] + num_points = reference_xy.shape[1] + time_steps = reference_xy.shape[2] + + # Create dropout mask for the time dimension + # Shape: [batch_size, num_points, time_steps, 1] + point_dropout_mask = torch.bernoulli( + torch.ones(batch_size, num_points, time_steps, 1, device=reference_xy.device) * (1 - self.config.prob_reference_dropout) + ).bool() + + # Apply dropout mask + reference_xy = reference_xy * point_dropout_mask + + # Flatten the dimensions for stacking + base_fields.append(reference_xy.flatten(start_dim=2)) + if self.config.reward_type == "reward_conditioned": # Create expanded weights for all environments @@ -811,8 +846,40 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: ] return torch.stack(full_fields).permute(1, 2, 0) else: - return torch.stack(base_fields).permute(1, 2, 0) + return torch.cat(base_fields, dim=-1) else: + if self.config.add_reference_path: + + # Shape: [batch, 91, 2] + glob_ego_states = self.sim.absolute_self_observation_tensor().to_torch().clone()[mask] + glob_ego_pos_xy = glob_ego_states[:, :2] + glob_ego_yaw = glob_ego_states[:, 7] + + reference_xy = self.log_trajectory.pos_xy[mask] + + # Transform reference path to be relative to current agent positions and heading + local_reference_xy = to_local_frame( + reference_xy, + glob_ego_pos_xy, + glob_ego_yaw, + ) + + # Normalize to [-1, 1] + local_reference_xy /= constants.MAX_REL_GOAL_COORD + + batch_size = reference_xy.shape[0] + num_points = reference_xy.shape[1] + + point_dropout_mask = torch.bernoulli( + torch.ones((batch_size, num_points), device=local_reference_xy.device) * (1 - self.config.prob_reference_dropout) + ).bool() + + # Dropout fraction of points in the reference path + local_reference_xy = local_reference_xy * point_dropout_mask.unsqueeze(2) + + # Stack + base_fields.append(local_reference_xy.view(batch_size, -1)) + if self.config.reward_type == "reward_conditioned": # For masked agents, we need to extract agent indices from the mask world_indices, agent_indices = torch.where(mask) @@ -836,7 +903,7 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: ] ).permute(1, 0) else: - return torch.stack(base_fields).permute(1, 0) + return torch.cat(base_fields, dim=1) def _get_partner_obs(self, mask=None): """Get partner observations.""" @@ -1500,9 +1567,8 @@ def get_scenario_ids(self): if __name__ == "__main__": env_config = EnvConfig( - dynamics_model="delta_local", - reward_type="reward_conditioned", - condition_mode="fixed", + dynamics_model="classic", + reward_type="follow_waypoints", ) render_config = RenderConfig() diff --git a/gpudrive/networks/agents.py b/gpudrive/networks/agents.py index ff34064c9..9f5d048af 100644 --- a/gpudrive/networks/agents.py +++ b/gpudrive/networks/agents.py @@ -40,10 +40,10 @@ def __init__( # Indices for unpacking the observation modalities self.ego_state_idx = ( - 9 if self.config["reward_type"] == "reward_conditioned" else 6 + 9 if self.config["reward_type"] == "reward_conditioned" else constants.EGO_FEAT_DIM ) - if self.config["add_goal_state"]: - self.ego_state_idx += 1 + if self.config["add_reference_path"]: # Every agent receives a reference path + self.ego_state_idx += 91 * 2 self.max_controlled_agents = madrona_gpudrive.kMaxAgentCount self.max_observable_agents = self.max_controlled_agents - 1 diff --git a/gpudrive/networks/late_fusion.py b/gpudrive/networks/late_fusion.py index 9144918b6..b984c452f 100644 --- a/gpudrive/networks/late_fusion.py +++ b/gpudrive/networks/late_fusion.py @@ -106,8 +106,8 @@ def __init__( # Agents know their "type", consisting of three weights # that determine the reward (collision, goal, off-road) self.ego_state_idx += 3 - if "add_goal_state" in self.config: - self.ego_state_idx += 1 + if "add_reference_path" in self.config: + self.ego_state_idx += 2 * madrona_gpudrive.kTrajectoryLength self.vbd_in_obs = self.config.vbd_in_obs From ddce91c0183e70d6b59ca2a28f225a4a71f48b2c Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Mon, 14 Apr 2025 18:44:32 -0400 Subject: [PATCH 39/81] Bug fixes --- baselines/ppo/config/ppo_waypoint.yaml | 4 +- gpudrive/datatypes/trajectory.py | 81 ++++++------- gpudrive/env/constants.py | 4 +- gpudrive/env/env_puffer.py | 3 + gpudrive/env/env_torch.py | 161 ++++++++++++++++--------- gpudrive/visualize/core.py | 12 +- 6 files changed, 153 insertions(+), 112 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index cce3d0a7a..f0a71e130 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -23,8 +23,8 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. polyline_reduction_threshold: 0.1 # Rate at which to sample points from the polyline (0 is use all closest points, 1 maximum sparsity), needs to be balanced with kMaxAgentMapObservationsCount sampling_seed: 42 # If given, the set of scenes to sample from will be deterministic, if None, the set of scenes will be random obs_radius: 50.0 # Visibility radius of the agents - action_space_steer_disc: 13 - action_space_accel_disc: 7 + action_space_steer_disc: 31 + action_space_accel_disc: 11 init_steps: 0 # Warmup steps collision_weight: 0.0 off_road_weight: 0.0 diff --git a/gpudrive/datatypes/trajectory.py b/gpudrive/datatypes/trajectory.py index 72ae534bb..2e4a1493c 100644 --- a/gpudrive/datatypes/trajectory.py +++ b/gpudrive/datatypes/trajectory.py @@ -5,45 +5,39 @@ TRAJ_LEN = 91 # Length of the logged trajectory -def to_local_frame(global_xy: torch.Tensor, ego_pos: torch.Tensor, ego_yaw: torch.Tensor): +def to_local_frame( + global_pos_xy: torch.Tensor, + ego_pos: torch.Tensor, + ego_yaw: torch.Tensor, + device: str, +) -> torch.Tensor: """ Transform trajectory from global coordinates to ego-centric frame. Args: - global_xy: Shape (agents, time_steps, 2) containing x,y positions of the trajectory - ego_pos: Shape (agents, 2) containing respective ego x,y positions - ego_yaw: Shape (agents, 1) containing ego yaw angle in radians - + global_pos_xy: Shape (time_steps, 2) containing x,y coordinates in global frame + ego_pos: Shape (2,) containing ego x,y position + ego_yaw: Shape (1,) containing ego yaw angle in radians Returns: - transformed pos_xy: Shape (agents, time_steps, 2) in ego-centric frame + transformed_trajectory: Shape (time_steps, 2) in ego-centric frame """ - # Translate trajectory to be relative to ego position - translated_pos_xy = global_xy - ego_pos.unsqueeze(1) - - # Create rotation matrices for each agent - cos_yaw = torch.cos(ego_yaw).squeeze(-1) - sin_yaw = torch.sin(ego_yaw).squeeze(-1) - - # Create 2x2 rotation matrix for each agent - num_agents = global_xy.shape[0] - rotation_matrices = torch.zeros(num_agents, 2, 2, device=global_xy.device) - rotation_matrices[:, 0, 0] = cos_yaw - rotation_matrices[:, 0, 1] = sin_yaw - rotation_matrices[:, 1, 0] = -sin_yaw - rotation_matrices[:, 1, 1] = cos_yaw - - # Apply rotation - num_agents, time_steps = global_xy.shape[0], global_xy.shape[1] - local_pos_xy = torch.zeros_like(global_xy) - - for t in range(time_steps): - pos_t = translated_pos_xy[:, t] - local_pos_xy[:, t] = torch.bmm( - rotation_matrices, - pos_t.unsqueeze(-1) - ).squeeze(-1) - - return local_pos_xy - + # Step 1: Translate trajectory to be relative to ego position + translated = global_pos_xy - ego_pos + + # Step 2: Rotate trajectory to align with ego orientation + # Create rotation matrix + cos_yaw = torch.cos(ego_yaw).to(device) + sin_yaw = torch.sin(ego_yaw).to(device) + rotation_matrix = torch.tensor( + [[cos_yaw, sin_yaw], [-sin_yaw, cos_yaw]] + ).to(device) + + # Apply rotation matrix to the translated trajectory + # We need to transpose rotation_matrix for batch matrix multiplication + transformed_trajectory = torch.matmul(translated, rotation_matrix.T) + + return transformed_trajectory + + @dataclass class LogTrajectory: """A class to represent the logged human trajectories. Initialized from `expert_trajectory_tensor` (src/bindings.cpp). @@ -67,16 +61,18 @@ def __init__( self.vel_xy = raw_logs[:, :, 2 * TRAJ_LEN : 4 * TRAJ_LEN].view( num_worlds, max_agents, TRAJ_LEN, -1 ) - self.yaw = raw_logs[:, :, 4 * TRAJ_LEN: 5 * TRAJ_LEN].view( + self.yaw = raw_logs[:, :, 4 * TRAJ_LEN : 5 * TRAJ_LEN].view( num_worlds, max_agents, TRAJ_LEN, -1 ) - self.valids = raw_logs[:, :, 5 * TRAJ_LEN:6 * TRAJ_LEN].view( - num_worlds, max_agents, TRAJ_LEN, -1 - ).to(torch.int32) - self.inferred_actions = raw_logs[:, :, 6 * TRAJ_LEN: 16 * TRAJ_LEN].view( - num_worlds, max_agents, TRAJ_LEN, -1 + self.valids = ( + raw_logs[:, :, 5 * TRAJ_LEN : 6 * TRAJ_LEN] + .view(num_worlds, max_agents, TRAJ_LEN, -1) + .to(torch.int32) ) - + self.inferred_actions = raw_logs[ + :, :, 6 * TRAJ_LEN : 16 * TRAJ_LEN + ].view(num_worlds, max_agents, TRAJ_LEN, -1) + # Zero-out invalid timesteps self.pos_xy = self.pos_xy * self.valids self.vel_xy = self.vel_xy * self.valids @@ -103,8 +99,7 @@ def restore_mean(self, mean_x, mean_y): # Reshape for broadcasting: [num_worlds, agents, time_steps] mean_x_reshaped = mean_x.view(-1, 1, 1) mean_y_reshaped = mean_y.view(-1, 1, 1) - + # Apply to x and y coordinates self.pos_xy[:, :, :, 0] += mean_x_reshaped self.pos_xy[:, :, :, 1] += mean_y_reshaped - \ No newline at end of file diff --git a/gpudrive/env/constants.py b/gpudrive/env/constants.py index 76562a903..3a509d3f5 100644 --- a/gpudrive/env/constants.py +++ b/gpudrive/env/constants.py @@ -13,6 +13,8 @@ MAX_REL_AGENT_POS = 1000 MAX_ORIENTATION_RAD = 2 * np.pi +MAX_REF_POINT = 1000 + # Road graph constants MIN_RG_COORD = -1000 MAX_RG_COORD = 1000 @@ -20,7 +22,7 @@ MAX_ROAD_SCALE = 100 # Feature shape constants -EGO_FEAT_DIM = 6 # Ego state base fields +EGO_FEAT_DIM = 6 # Ego state base fields PARTNER_FEAT_DIM = 6 ROAD_GRAPH_FEAT_DIM = 13 diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index ac4891d81..3b1f11b01 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -404,6 +404,9 @@ def step(self, action): "perc_truncated": num_truncated / num_finished_agents, "mean_waypoint_distance": human_like_values.mean().item(), "mean_internal_reward": internal_reward_values.mean().item(), + "waypoint_distance_distrib": wandb.Histogram( + human_like_values.cpu().numpy(), + ), } ) # fmt: on diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index d59370fe8..8cb0a5a80 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -570,17 +570,18 @@ def get_rewards( gt_agent_pos = self.log_trajectory.pos_xy[ batch_indices, :, world_time_steps, : ] - + # Get actual agent positions agent_state = GlobalEgoState.from_tensor( self.sim.absolute_self_observation_tensor(), self.backend, + self.device, ) actual_agent_pos = torch.stack( [agent_state.pos_x, agent_state.pos_y], dim=-1 ) - + # Compute euclidean distance between agent and waypoints dist_to_waypoints = torch.norm( gt_agent_pos - actual_agent_pos, dim=-1 @@ -603,9 +604,6 @@ def get_rewards( ) self.distance_penalty = self.distance_penalty * waypoint_mask - if self.distance_penalty.max() > 10: - print("huh") - # Combine base rewards with distance penalty rewards = self.base_rewards + self.distance_penalty @@ -785,46 +783,67 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: ego_state.rel_goal_y.unsqueeze(-1), ego_state.is_collided.unsqueeze(-1), ] - + if mask is None: - + if self.config.add_reference_path: - + # Shape: [batch, 91, 2] - glob_ego_states = self.sim.absolute_self_observation_tensor().to_torch().clone() + glob_ego_states = ( + self.sim.absolute_self_observation_tensor() + .to_torch() + .clone() + ) glob_ego_pos_xy = glob_ego_states[:, :, :2] glob_ego_yaw = glob_ego_states[:, :, 7] - - reference_xy = self.log_trajectory.pos_xy - - # Normalize - reference_xy /= constants.MAX_REL_GOAL_COORD - + glob_reference_xy = self.log_trajectory.pos_xy + + local_reference_xy = torch.empty_like(glob_reference_xy) # Transform reference path to be relative to current # agent positions and heading - for i in range(self.num_worlds): - reference_xy[i] = to_local_frame( - reference_xy[i], - glob_ego_pos_xy[i], - glob_ego_yaw[i], - ) - - batch_size = reference_xy.shape[0] - num_points = reference_xy.shape[1] - time_steps = reference_xy.shape[2] - + for world_idx in range(self.num_worlds): + for agent_idx in range(self.max_cont_agents): + local_reference_xy[ + world_idx, agent_idx, :, : + ] = to_local_frame( + global_pos_xy=glob_reference_xy[ + world_idx, agent_idx, :, : + ], + ego_pos=glob_ego_pos_xy[world_idx, agent_idx], + ego_yaw=glob_ego_yaw[world_idx, agent_idx], + device=self.device, + ) + + # Normalize + local_reference_xy /= constants.MAX_REF_POINT + + batch_size = local_reference_xy.shape[0] + num_points = local_reference_xy.shape[1] + time_steps = local_reference_xy.shape[2] + # Create dropout mask for the time dimension # Shape: [batch_size, num_points, time_steps, 1] point_dropout_mask = torch.bernoulli( - torch.ones(batch_size, num_points, time_steps, 1, device=reference_xy.device) * (1 - self.config.prob_reference_dropout) + torch.ones( + batch_size, + num_points, + time_steps, + 1, + device=local_reference_xy.device, + ) + * (1 - self.config.prob_reference_dropout) ).bool() # Apply dropout mask - reference_xy = reference_xy * point_dropout_mask + self.local_reference_xy = ( + local_reference_xy * point_dropout_mask + ) # Flatten the dimensions for stacking - base_fields.append(reference_xy.flatten(start_dim=2)) - + base_fields.append( + self.local_reference_xy.flatten(start_dim=2) + ) + if self.config.reward_type == "reward_conditioned": # Create expanded weights for all environments @@ -849,37 +868,50 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: return torch.cat(base_fields, dim=-1) else: if self.config.add_reference_path: - + # Shape: [batch, 91, 2] - glob_ego_states = self.sim.absolute_self_observation_tensor().to_torch().clone()[mask] + glob_ego_states = ( + self.sim.absolute_self_observation_tensor() + .to_torch() + .clone()[mask] + ) glob_ego_pos_xy = glob_ego_states[:, :2] glob_ego_yaw = glob_ego_states[:, 7] - - reference_xy = self.log_trajectory.pos_xy[mask] - - # Transform reference path to be relative to current agent positions and heading - local_reference_xy = to_local_frame( - reference_xy, - glob_ego_pos_xy, - glob_ego_yaw, - ) - + glob_reference_xy = self.log_trajectory.pos_xy[mask] + + local_reference_xy = torch.empty_like(glob_reference_xy) + batch_size = local_reference_xy.shape[0] + num_points = local_reference_xy.shape[1] + + for agent_idx in range(batch_size): + local_reference_xy[agent_idx, :, :] = to_local_frame( + global_pos_xy=glob_reference_xy[agent_idx, :, :], + ego_pos=glob_ego_pos_xy[agent_idx], + ego_yaw=glob_ego_yaw[agent_idx], + device=self.device, + ) + # Normalize to [-1, 1] - local_reference_xy /= constants.MAX_REL_GOAL_COORD - - batch_size = reference_xy.shape[0] - num_points = reference_xy.shape[1] - + local_reference_xy /= constants.MAX_REF_POINT + point_dropout_mask = torch.bernoulli( - torch.ones((batch_size, num_points), device=local_reference_xy.device) * (1 - self.config.prob_reference_dropout) + torch.ones( + (batch_size, num_points), + device=local_reference_xy.device, + ) + * (1 - self.config.prob_reference_dropout) ).bool() - - # Dropout fraction of points in the reference path - local_reference_xy = local_reference_xy * point_dropout_mask.unsqueeze(2) - + + # Dropout fraction of points in the reference path + self.local_reference_xy = ( + local_reference_xy * point_dropout_mask.unsqueeze(2) + ) + # Stack - base_fields.append(local_reference_xy.view(batch_size, -1)) - + base_fields.append( + self.local_reference_xy.view(batch_size, -1) + ) + if self.config.reward_type == "reward_conditioned": # For masked agents, we need to extract agent indices from the mask world_indices, agent_indices = torch.where(mask) @@ -1429,6 +1461,7 @@ def _generate_vbd_trajectories(self): agent_indices = sample_batch["agents_id"] self.vbd_trajectories.zero_() + # Process each world separately for world_idx in range(self.num_worlds): world_agent_indices = agent_indices[world_idx] @@ -1567,8 +1600,10 @@ def get_scenario_ids(self): if __name__ == "__main__": env_config = EnvConfig( - dynamics_model="classic", + dynamics_model="delta_local", reward_type="follow_waypoints", + add_reference_path=True, + prob_reference_dropout=0.8, ) render_config = RenderConfig() @@ -1586,7 +1621,7 @@ def get_scenario_ids(self): config=env_config, data_loader=train_loader, max_cont_agents=64, # Number of agents to control - device="cpu", + device="cuda", ) control_mask = env.cont_agent_mask @@ -1601,7 +1636,7 @@ def get_scenario_ids(self): env_idx = 0 - for t in range(91): + for t in range(10): print(f"Step: {t}") # Step the environment @@ -1617,7 +1652,8 @@ def get_scenario_ids(self): env_indices=[env_idx], zoom_radius=80, time_steps=[t], - # center_agent_indices=[highlight_agent], + center_agent_indices=[highlight_agent], + plot_waypoints=True, ) agent_obs = env.vis.plot_agent_observation( @@ -1629,8 +1665,15 @@ def get_scenario_ids(self): sim_frames.append(img_from_fig(sim_states[0])) agent_obs_frames.append(img_from_fig(agent_obs)) + world_time_steps = ( + torch.Tensor([t]).repeat((1, env.num_worlds)).long().to(env.device) + ) + obs = env.get_obs() - reward = env.get_rewards() + reward = env.get_rewards(world_time_steps=world_time_steps) + + print(f"Reward: {reward[:, env_idx, highlight_agent]}") + done = env.get_dones() info = env.get_infos() diff --git a/gpudrive/visualize/core.py b/gpudrive/visualize/core.py index 0273e966d..8bc11da83 100644 --- a/gpudrive/visualize/core.py +++ b/gpudrive/visualize/core.py @@ -1704,16 +1704,14 @@ def plot_agent_observation( if trajectory is not None and len(trajectory) > 0: # Plot the trajectory as a line - ax.plot( + ax.scatter( trajectory[:, 0], # x coordinates trajectory[:, 1], # y coordinates - color="blue", # trajectory color - linestyle="-", # solid line - linewidth=1.0, # line width + color="lightgreen", + linewidth=0.35, marker="o", # circular markers at each point - markersize=1, # size of markers - alpha=0.7, # slight transparency - label="Trajectory", # label for legend + alpha=0.8, # slight transparency + zorder=0, ) ax.set_xlim((-self.env_config.obs_radius, self.env_config.obs_radius)) From 3248fc94a07b3e57cd36f65fdf27258f821e2ec2 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Tue, 15 Apr 2025 18:37:34 -0400 Subject: [PATCH 40/81] Working kinematic metrics --- baselines/ppo/config/ppo_waypoint.yaml | 17 ++- gpudrive/env/env_puffer.py | 189 +++++++++++++++++++++++++ 2 files changed, 199 insertions(+), 7 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index f0a71e130..29885edc5 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -8,7 +8,7 @@ model_cpt: null environment: # Overrides default environment configs (see pygpudrive/env/config.py) name: "gpudrive" - num_worlds: 75 # Number of parallel environments + num_worlds: 50 # Number of parallel environments k_unique_scenes: 4 # Number of unique scenes to sample from max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp ego_state: true @@ -26,8 +26,8 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. action_space_steer_disc: 31 action_space_accel_disc: 11 init_steps: 0 # Warmup steps - collision_weight: 0.0 - off_road_weight: 0.0 + collision_weight: -0.2 + off_road_weight: -0.2 # Versatile Behavior Diffusion (VBD): This will slow down training use_vbd: false @@ -36,18 +36,18 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. vbd_in_obs: false # Planning guidance - add_reference_path: true # If true, the goal state is added to the ego observation + add_reference_path: false # If true, the goal state is added to the ego observation prob_reference_dropout: 0.0 # Value between 0 and 1, probability of a reference point to be zeroed out wandb: entity: "" project: "humanlike" - group: "reference_path" + group: "wosac" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] train: - exp_id: follow_waypoint # Set dynamically in the script if needed + exp_id: waypoint # Set dynamically in the script if needed seed: 42 cpu_offload: false device: "cuda" # Dynamically set to cuda if available, else cpu @@ -80,7 +80,10 @@ train: vf_coef: 0.5 max_grad_norm: 0.5 target_kl: null + + # # # Logging # # # log_window: 500 + track_realism: true # Log human-like metrics # # # Network # # # network: @@ -97,7 +100,7 @@ train: render: false # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d render_interval: 50 # Render every k iterations - render_k_scenarios: 1 # Number of scenarios to render + render_k_scenarios: 2 # Number of scenarios to render render_format: "mp4" # Options: gif, mp4 render_fps: 20 # Frames per second zoom_radius: 100 diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 3b1f11b01..4fbab1bb4 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -10,6 +10,7 @@ from gpudrive.env.env_torch import GPUDriveTorchEnv from gpudrive.datatypes.observation import ( LocalEgoState, + GlobalEgoState, ) from gpudrive.visualize.utils import img_from_fig @@ -19,6 +20,26 @@ from gpudrive import GPU_DRIVE_DATA_DIR +def get_state(env, num_worlds): + ego_state = GlobalEgoState.from_tensor( + env.sim.absolute_self_observation_tensor(), + backend=env.backend, + device=env.device, + ) + mean_xy = env.sim.world_means_tensor().to_torch()[:, :2] + #mean_x = mean_xy[:, 0].unsqueeze(1) + #mean_y = mean_xy[:, 1].unsqueeze(1) + + glob_ego_pos_x = ego_state.pos_x#+mean_x + glob_ego_pos_y = ego_state.pos_y#+mean_y + return ( + glob_ego_pos_x[:num_worlds, :], + glob_ego_pos_y[:num_worlds, :], + ego_state.pos_z[:num_worlds, :], + ego_state.rotation_angle[:num_worlds, :], + ego_state.id[:num_worlds, :], + ) + def env_creator(name="gpudrive", **kwargs): return lambda: PufferGPUDrive(**kwargs) @@ -252,6 +273,18 @@ def reset(self, seed=None): (self.num_worlds, self.max_cont_agents_per_env), dtype=torch.float32, ).to(self.device) + + # Storage for computing realism metrics + self.worlds_to_track = 2 + self.pos_xyz = torch.zeros( + (self.worlds_to_track, self.max_cont_agents_per_env, 91, 3), + dtype=torch.float32, + ).to(self.device) + + self.headings = torch.zeros( + (self.worlds_to_track, self.max_cont_agents_per_env, 91), + dtype=torch.float32, + ).to(self.device) return self.observations, [] @@ -313,6 +346,13 @@ def step(self, action): info = self.env.get_infos() self.offroad_in_episode += info.off_road self.collided_in_episode += info.collided + + # Log global states + batch_indices = torch.arange(self.worlds_to_track, device=self.device) + pos_x, pos_y, pos_z, heading, ids = get_state(self.env, num_worlds=self.worlds_to_track) + episode_time_steps = self.episode_lengths[:self.worlds_to_track, 0].long() - 1 + self.pos_xyz[batch_indices, :, episode_time_steps, :] = torch.stack([pos_x, pos_y, pos_z], dim=-1) + self.headings[batch_indices, :, episode_time_steps] = heading # Mask used for buffer self.masks = self.live_agent_mask[self.controlled_agent_mask] @@ -428,6 +468,12 @@ def step(self, action): self.collided_in_episode[done_worlds, :] = 0 self.human_like_rewards[done_worlds, :] = 0 self.internal_rewards[done_worlds, :] = 0 + + tracked_done_worlds = done_worlds.tolist() and list(range(self.worlds_to_track)) + if len(tracked_done_worlds): + self.compute_realism_metrics(tracked_done_worlds) + self.pos_xyz[tracked_done_worlds, :] = 0 + self.headings[tracked_done_worlds, :] = 0 # Get the next observations. Note that we do this after resetting # the worlds so that we always return a fresh observation @@ -557,3 +603,146 @@ def log_data_coverage(self): }, step=self.global_step, ) + + def compute_realism_metrics(self, done_worlds): + """Compute realism metrics. + + Args: + done_worlds: List of indices of the worlds to track. + """ + import tensorflow as tf + import numpy as np + from waymo_open_dataset.wdl_limited.sim_agents_metrics.trajectory_features import ( + compute_displacement_error, + compute_kinematic_features, + compute_kinematic_validity + ) + + # [worlds, max_cont_agents] + control_mask = self.controlled_agent_mask[done_worlds].detach().cpu().numpy() + # [batch, time, 1] + valid_mask = self.env.log_trajectory.valids[done_worlds].detach().cpu().numpy()[control_mask].squeeze(-1) + + # Take human logs (ground-truth) + # Shape: [worlds, max_cont_agents, time, 2] -> [batch, time, 2] + ref_pos_xy_np = self.env.log_trajectory.pos_xy[done_worlds].detach().cpu().numpy()[control_mask] + ref_pos_z_np = np.zeros_like(ref_pos_xy_np[:, :, 0]) + # Shape: [worlds, max_cont_agents, time, 1] -> [batch, time, 1] + ref_headings_np = self.env.log_trajectory.yaw[done_worlds].detach().cpu().numpy()[control_mask].squeeze(-1) + + # Get agent information and convert to numpy + agent_headings_np = self.headings[done_worlds].detach().cpu().numpy()[control_mask] + agent_pos_xyz_np = self.pos_xyz[done_worlds].detach().cpu().numpy()[control_mask] + + # Extract x, y, z components + agent_x_np = agent_pos_xyz_np[..., 0] + agent_y_np = agent_pos_xyz_np[..., 1] + agent_z_np = agent_pos_xyz_np[..., 2] + + ref_x_np = ref_pos_xy_np[..., 0] + ref_y_np = ref_pos_xy_np[..., 1] + + # Convert to TensorFlow tensors + ref_x = tf.convert_to_tensor(ref_x_np, dtype=tf.float32) + ref_y = tf.convert_to_tensor(ref_y_np, dtype=tf.float32) + ref_z = tf.convert_to_tensor(ref_pos_z_np, dtype=tf.float32) + ref_heading = tf.convert_to_tensor(ref_headings_np, dtype=tf.float32) + + agent_x = tf.convert_to_tensor(agent_x_np, dtype=tf.float32) + agent_y = tf.convert_to_tensor(agent_y_np, dtype=tf.float32) + agent_z = tf.convert_to_tensor(agent_z_np, dtype=tf.float32) + agent_heading = tf.convert_to_tensor(agent_headings_np, dtype=tf.float32) + + valid_mask = tf.convert_to_tensor(valid_mask, dtype=tf.bool) + + # Step duration in seconds + seconds_per_step = 0.1 # Assuming 10Hz sampling rate + + speed_validity, accel_validity = compute_kinematic_validity(valid_mask) + + # Compute kinematic features for agents + agent_speed, agent_accel, agent_angular_speed, agent_angular_accel = compute_kinematic_features( + agent_x, agent_y, agent_z, agent_heading, seconds_per_step + ) + + # Compute kinematic features for reference trajectories + ref_speed, ref_accel, ref_angular_speed, ref_angular_accel = compute_kinematic_features( + ref_x, ref_y, ref_z, ref_heading, seconds_per_step + ) + + # Compute displacement error + displacement_error = compute_displacement_error( + agent_x, agent_y, agent_z, ref_x, ref_y, ref_z + ) + + # Compute additional metrics + speed_error = tf.abs(agent_speed - ref_speed) + accel_error = tf.abs(agent_accel - ref_accel) + angular_speed_error = tf.abs(agent_angular_speed - ref_angular_speed) + angular_accel_error = tf.abs(agent_angular_accel - ref_angular_accel) + + def masked_mean_no_nan_inf(tensor): + """Compute mean excluding NaN and Inf values.""" + # Create masks for non-NaN and non-Inf values + non_nan_mask = tf.math.logical_not(tf.math.is_nan(tensor)) + non_inf_mask = tf.math.logical_not(tf.math.is_inf(tensor)) + valid_values_mask = tf.logical_and(non_nan_mask, non_inf_mask) + + # Apply mask to tensor + masked_tensor = tf.boolean_mask(tensor, valid_values_mask) + + # If all values are filtered out, return 0.0 + if tf.size(masked_tensor) == 0: + return tf.constant(0.0, dtype=tf.float32) + + # Compute mean of valid values + return tf.reduce_mean(masked_tensor) + + def masked_mean_with_validity_no_inf(tensor, validity_mask): + """Compute mean excluding NaN and Inf values and applying validity mask.""" + # Create masks for non-NaN and non-Inf values + non_nan_mask = tf.math.logical_not(tf.math.is_nan(tensor)) + non_inf_mask = tf.math.logical_not(tf.math.is_inf(tensor)) + data_valid_mask = tf.logical_and(non_nan_mask, non_inf_mask) + + # Combine with validity mask + combined_mask = tf.logical_and(data_valid_mask, validity_mask) + + # Apply combined mask to tensor + masked_tensor = tf.boolean_mask(tensor, combined_mask) + + # If all values are filtered out, return 0.0 + if tf.size(masked_tensor) == 0: + return tf.constant(0.0, dtype=tf.float32) + + # Compute mean of valid values + return tf.reduce_mean(masked_tensor) + + # Create metrics dictionary + metrics = { + 'displacement_error': float(masked_mean_no_nan_inf(displacement_error).numpy()), + 'speed_error': float(masked_mean_with_validity_no_inf(speed_error, speed_validity).numpy()), + 'accel_error': float(masked_mean_with_validity_no_inf(accel_error, accel_validity).numpy()), + 'angular_speed_error': float(masked_mean_with_validity_no_inf(angular_speed_error, speed_validity).numpy()), + 'angular_accel_error': float(masked_mean_with_validity_no_inf(angular_accel_error, accel_validity).numpy()), + + 'agent_speed': float(masked_mean_with_validity_no_inf(agent_speed, speed_validity).numpy()), + 'agent_accel': float(masked_mean_with_validity_no_inf(agent_accel, accel_validity).numpy()), + 'agent_angular_speed': float(masked_mean_with_validity_no_inf(agent_angular_speed, speed_validity).numpy()), + 'agent_angular_accel': float(masked_mean_with_validity_no_inf(agent_angular_accel, accel_validity).numpy()), + + 'ref_speed': float(masked_mean_with_validity_no_inf(ref_speed, speed_validity).numpy()), + 'ref_accel': float(masked_mean_with_validity_no_inf(ref_accel, accel_validity).numpy()), + 'ref_angular_speed': float(masked_mean_with_validity_no_inf(ref_angular_speed, speed_validity).numpy()), + 'ref_angular_accel': float(masked_mean_with_validity_no_inf(ref_angular_accel, accel_validity).numpy()), + } + + # Prepare wandb logging dictionary with "realism/" prefix + wandb_metrics = {} + for key, value in metrics.items(): + wandb_metrics[f"realism/{key}"] = value + + # Log metrics to wandb + wandb.log(wandb_metrics) + + del wandb_metrics \ No newline at end of file From 58c2ef0c74ec474d7a2936f4433eb031703bcbbc Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Tue, 15 Apr 2025 18:40:48 -0400 Subject: [PATCH 41/81] Minor --- gpudrive/env/env_puffer.py | 230 +++++++++++++++++++++++++------------ 1 file changed, 159 insertions(+), 71 deletions(-) diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 4fbab1bb4..3ff108013 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -27,19 +27,20 @@ def get_state(env, num_worlds): device=env.device, ) mean_xy = env.sim.world_means_tensor().to_torch()[:, :2] - #mean_x = mean_xy[:, 0].unsqueeze(1) - #mean_y = mean_xy[:, 1].unsqueeze(1) - - glob_ego_pos_x = ego_state.pos_x#+mean_x - glob_ego_pos_y = ego_state.pos_y#+mean_y + # mean_x = mean_xy[:, 0].unsqueeze(1) + # mean_y = mean_xy[:, 1].unsqueeze(1) + + glob_ego_pos_x = ego_state.pos_x # +mean_x + glob_ego_pos_y = ego_state.pos_y # +mean_y return ( - glob_ego_pos_x[:num_worlds, :], - glob_ego_pos_y[:num_worlds, :], - ego_state.pos_z[:num_worlds, :], - ego_state.rotation_angle[:num_worlds, :], + glob_ego_pos_x[:num_worlds, :], + glob_ego_pos_y[:num_worlds, :], + ego_state.pos_z[:num_worlds, :], + ego_state.rotation_angle[:num_worlds, :], ego_state.id[:num_worlds, :], ) + def env_creator(name="gpudrive", **kwargs): return lambda: PufferGPUDrive(**kwargs) @@ -273,14 +274,14 @@ def reset(self, seed=None): (self.num_worlds, self.max_cont_agents_per_env), dtype=torch.float32, ).to(self.device) - + # Storage for computing realism metrics self.worlds_to_track = 2 self.pos_xyz = torch.zeros( (self.worlds_to_track, self.max_cont_agents_per_env, 91, 3), dtype=torch.float32, ).to(self.device) - + self.headings = torch.zeros( (self.worlds_to_track, self.max_cont_agents_per_env, 91), dtype=torch.float32, @@ -346,12 +347,18 @@ def step(self, action): info = self.env.get_infos() self.offroad_in_episode += info.off_road self.collided_in_episode += info.collided - + # Log global states batch_indices = torch.arange(self.worlds_to_track, device=self.device) - pos_x, pos_y, pos_z, heading, ids = get_state(self.env, num_worlds=self.worlds_to_track) - episode_time_steps = self.episode_lengths[:self.worlds_to_track, 0].long() - 1 - self.pos_xyz[batch_indices, :, episode_time_steps, :] = torch.stack([pos_x, pos_y, pos_z], dim=-1) + pos_x, pos_y, pos_z, heading, ids = get_state( + self.env, num_worlds=self.worlds_to_track + ) + episode_time_steps = ( + self.episode_lengths[: self.worlds_to_track, 0].long() - 1 + ) + self.pos_xyz[batch_indices, :, episode_time_steps, :] = torch.stack( + [pos_x, pos_y, pos_z], dim=-1 + ) self.headings[batch_indices, :, episode_time_steps] = heading # Mask used for buffer @@ -468,8 +475,10 @@ def step(self, action): self.collided_in_episode[done_worlds, :] = 0 self.human_like_rewards[done_worlds, :] = 0 self.internal_rewards[done_worlds, :] = 0 - - tracked_done_worlds = done_worlds.tolist() and list(range(self.worlds_to_track)) + + tracked_done_worlds = done_worlds.tolist() and list( + range(self.worlds_to_track) + ) if len(tracked_done_worlds): self.compute_realism_metrics(tracked_done_worlds) self.pos_xyz[tracked_done_worlds, :] = 0 @@ -606,7 +615,7 @@ def log_data_coverage(self): def compute_realism_metrics(self, done_worlds): """Compute realism metrics. - + Args: done_worlds: List of indices of the worlds to track. """ @@ -615,30 +624,53 @@ def compute_realism_metrics(self, done_worlds): from waymo_open_dataset.wdl_limited.sim_agents_metrics.trajectory_features import ( compute_displacement_error, compute_kinematic_features, - compute_kinematic_validity + compute_kinematic_validity, ) - + # [worlds, max_cont_agents] - control_mask = self.controlled_agent_mask[done_worlds].detach().cpu().numpy() + control_mask = ( + self.controlled_agent_mask[done_worlds].detach().cpu().numpy() + ) # [batch, time, 1] - valid_mask = self.env.log_trajectory.valids[done_worlds].detach().cpu().numpy()[control_mask].squeeze(-1) - - # Take human logs (ground-truth) + valid_mask = ( + self.env.log_trajectory.valids[done_worlds] + .detach() + .cpu() + .numpy()[control_mask] + .squeeze(-1) + ) + + # Take human logs (ground-truth) # Shape: [worlds, max_cont_agents, time, 2] -> [batch, time, 2] - ref_pos_xy_np = self.env.log_trajectory.pos_xy[done_worlds].detach().cpu().numpy()[control_mask] + ref_pos_xy_np = ( + self.env.log_trajectory.pos_xy[done_worlds] + .detach() + .cpu() + .numpy()[control_mask] + ) ref_pos_z_np = np.zeros_like(ref_pos_xy_np[:, :, 0]) # Shape: [worlds, max_cont_agents, time, 1] -> [batch, time, 1] - ref_headings_np = self.env.log_trajectory.yaw[done_worlds].detach().cpu().numpy()[control_mask].squeeze(-1) - + ref_headings_np = ( + self.env.log_trajectory.yaw[done_worlds] + .detach() + .cpu() + .numpy()[control_mask] + .squeeze(-1) + ) + # Get agent information and convert to numpy - agent_headings_np = self.headings[done_worlds].detach().cpu().numpy()[control_mask] - agent_pos_xyz_np = self.pos_xyz[done_worlds].detach().cpu().numpy()[control_mask] - - # Extract x, y, z components + agent_headings_np = ( + self.headings[done_worlds].detach().cpu().numpy()[control_mask] + ) + agent_pos_xyz_np = ( + self.pos_xyz[done_worlds].detach().cpu().numpy()[control_mask] + ) + + # Extract x, y, z components agent_x_np = agent_pos_xyz_np[..., 0] agent_y_np = agent_pos_xyz_np[..., 1] agent_z_np = agent_pos_xyz_np[..., 2] - + ref_x_np = ref_pos_xy_np[..., 0] ref_y_np = ref_pos_xy_np[..., 1] @@ -647,34 +679,46 @@ def compute_realism_metrics(self, done_worlds): ref_y = tf.convert_to_tensor(ref_y_np, dtype=tf.float32) ref_z = tf.convert_to_tensor(ref_pos_z_np, dtype=tf.float32) ref_heading = tf.convert_to_tensor(ref_headings_np, dtype=tf.float32) - + agent_x = tf.convert_to_tensor(agent_x_np, dtype=tf.float32) agent_y = tf.convert_to_tensor(agent_y_np, dtype=tf.float32) agent_z = tf.convert_to_tensor(agent_z_np, dtype=tf.float32) - agent_heading = tf.convert_to_tensor(agent_headings_np, dtype=tf.float32) - + agent_heading = tf.convert_to_tensor( + agent_headings_np, dtype=tf.float32 + ) + valid_mask = tf.convert_to_tensor(valid_mask, dtype=tf.bool) - - # Step duration in seconds + + # Step duration in seconds seconds_per_step = 0.1 # Assuming 10Hz sampling rate - + speed_validity, accel_validity = compute_kinematic_validity(valid_mask) - + # Compute kinematic features for agents - agent_speed, agent_accel, agent_angular_speed, agent_angular_accel = compute_kinematic_features( + ( + agent_speed, + agent_accel, + agent_angular_speed, + agent_angular_accel, + ) = compute_kinematic_features( agent_x, agent_y, agent_z, agent_heading, seconds_per_step ) - + # Compute kinematic features for reference trajectories - ref_speed, ref_accel, ref_angular_speed, ref_angular_accel = compute_kinematic_features( + ( + ref_speed, + ref_accel, + ref_angular_speed, + ref_angular_accel, + ) = compute_kinematic_features( ref_x, ref_y, ref_z, ref_heading, seconds_per_step ) - + # Compute displacement error displacement_error = compute_displacement_error( agent_x, agent_y, agent_z, ref_x, ref_y, ref_z ) - + # Compute additional metrics speed_error = tf.abs(agent_speed - ref_speed) accel_error = tf.abs(agent_accel - ref_accel) @@ -687,14 +731,14 @@ def masked_mean_no_nan_inf(tensor): non_nan_mask = tf.math.logical_not(tf.math.is_nan(tensor)) non_inf_mask = tf.math.logical_not(tf.math.is_inf(tensor)) valid_values_mask = tf.logical_and(non_nan_mask, non_inf_mask) - + # Apply mask to tensor masked_tensor = tf.boolean_mask(tensor, valid_values_mask) - + # If all values are filtered out, return 0.0 if tf.size(masked_tensor) == 0: return tf.constant(0.0, dtype=tf.float32) - + # Compute mean of valid values return tf.reduce_mean(masked_tensor) @@ -704,45 +748,89 @@ def masked_mean_with_validity_no_inf(tensor, validity_mask): non_nan_mask = tf.math.logical_not(tf.math.is_nan(tensor)) non_inf_mask = tf.math.logical_not(tf.math.is_inf(tensor)) data_valid_mask = tf.logical_and(non_nan_mask, non_inf_mask) - + # Combine with validity mask combined_mask = tf.logical_and(data_valid_mask, validity_mask) - + # Apply combined mask to tensor masked_tensor = tf.boolean_mask(tensor, combined_mask) - + # If all values are filtered out, return 0.0 if tf.size(masked_tensor) == 0: return tf.constant(0.0, dtype=tf.float32) - + # Compute mean of valid values return tf.reduce_mean(masked_tensor) - # Create metrics dictionary metrics = { - 'displacement_error': float(masked_mean_no_nan_inf(displacement_error).numpy()), - 'speed_error': float(masked_mean_with_validity_no_inf(speed_error, speed_validity).numpy()), - 'accel_error': float(masked_mean_with_validity_no_inf(accel_error, accel_validity).numpy()), - 'angular_speed_error': float(masked_mean_with_validity_no_inf(angular_speed_error, speed_validity).numpy()), - 'angular_accel_error': float(masked_mean_with_validity_no_inf(angular_accel_error, accel_validity).numpy()), - - 'agent_speed': float(masked_mean_with_validity_no_inf(agent_speed, speed_validity).numpy()), - 'agent_accel': float(masked_mean_with_validity_no_inf(agent_accel, accel_validity).numpy()), - 'agent_angular_speed': float(masked_mean_with_validity_no_inf(agent_angular_speed, speed_validity).numpy()), - 'agent_angular_accel': float(masked_mean_with_validity_no_inf(agent_angular_accel, accel_validity).numpy()), - - 'ref_speed': float(masked_mean_with_validity_no_inf(ref_speed, speed_validity).numpy()), - 'ref_accel': float(masked_mean_with_validity_no_inf(ref_accel, accel_validity).numpy()), - 'ref_angular_speed': float(masked_mean_with_validity_no_inf(ref_angular_speed, speed_validity).numpy()), - 'ref_angular_accel': float(masked_mean_with_validity_no_inf(ref_angular_accel, accel_validity).numpy()), + "displacement_error": float( + masked_mean_no_nan_inf(displacement_error).numpy() + ), + "speed_error": float( + masked_mean_with_validity_no_inf( + speed_error, speed_validity + ).numpy() + ), + "accel_error": float( + masked_mean_with_validity_no_inf( + accel_error, accel_validity + ).numpy() + ), + "angular_speed_error": float( + masked_mean_with_validity_no_inf( + angular_speed_error, speed_validity + ).numpy() + ), + "angular_accel_error": float( + masked_mean_with_validity_no_inf( + angular_accel_error, accel_validity + ).numpy() + ), + "agent_speed": float( + masked_mean_with_validity_no_inf( + agent_speed, speed_validity + ).numpy() + ), + "agent_accel": float( + masked_mean_with_validity_no_inf( + agent_accel, accel_validity + ).numpy() + ), + "agent_angular_speed": float( + masked_mean_with_validity_no_inf( + agent_angular_speed, speed_validity + ).numpy() + ), + "agent_angular_accel": float( + masked_mean_with_validity_no_inf( + agent_angular_accel, accel_validity + ).numpy() + ), + "ref_speed": float( + masked_mean_with_validity_no_inf( + ref_speed, speed_validity + ).numpy() + ), + "ref_accel": float( + masked_mean_with_validity_no_inf( + ref_accel, accel_validity + ).numpy() + ), + "ref_angular_speed": float( + masked_mean_with_validity_no_inf( + ref_angular_speed, speed_validity + ).numpy() + ), + "ref_angular_accel": float( + masked_mean_with_validity_no_inf( + ref_angular_accel, accel_validity + ).numpy() + ), } - # Prepare wandb logging dictionary with "realism/" prefix wandb_metrics = {} for key, value in metrics.items(): wandb_metrics[f"realism/{key}"] = value - - # Log metrics to wandb wandb.log(wandb_metrics) - del wandb_metrics \ No newline at end of file + del wandb_metrics From 565b63ede1aaa55f5c33b32f76cdc08d4d301324 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Tue, 15 Apr 2025 20:52:45 -0400 Subject: [PATCH 42/81] Make logging realism metrics optional --- baselines/ppo/config/ppo_waypoint.yaml | 5 +- gpudrive/env/env_puffer.py | 66 +++++++++++++++----------- 2 files changed, 40 insertions(+), 31 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 29885edc5..644e13a3c 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -8,7 +8,7 @@ model_cpt: null environment: # Overrides default environment configs (see pygpudrive/env/config.py) name: "gpudrive" - num_worlds: 50 # Number of parallel environments + num_worlds: 75 # Number of parallel environments k_unique_scenes: 4 # Number of unique scenes to sample from max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp ego_state: true @@ -83,7 +83,8 @@ train: # # # Logging # # # log_window: 500 - track_realism: true # Log human-like metrics + track_realism_metrics: true # Log human-like metrics + track_n_worlds: 2 # Number of worlds to track # # # Network # # # network: diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 3ff108013..3c1f49321 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -85,6 +85,8 @@ def __init__( use_vbd=False, vbd_model_path=None, vbd_trajectory_weight=0.1, + track_realism_metrics=False, + track_n_worlds=2, render=False, render_3d=True, render_interval=50, @@ -129,6 +131,8 @@ def __init__( self.render_fps = render_fps self.zoom_radius = zoom_radius self.plot_waypoints = plot_waypoints + self.track_realism_metrics = track_realism_metrics + self.track_n_worlds = track_n_worlds # VBD self.vbd_model_path = vbd_model_path @@ -276,16 +280,17 @@ def reset(self, seed=None): ).to(self.device) # Storage for computing realism metrics - self.worlds_to_track = 2 - self.pos_xyz = torch.zeros( - (self.worlds_to_track, self.max_cont_agents_per_env, 91, 3), - dtype=torch.float32, - ).to(self.device) - - self.headings = torch.zeros( - (self.worlds_to_track, self.max_cont_agents_per_env, 91), - dtype=torch.float32, - ).to(self.device) + if self.track_realism_metrics: + self.worlds_to_track = self.track_n_worlds + self.pos_xyz = torch.zeros( + (self.worlds_to_track, self.max_cont_agents_per_env, 91, 3), + dtype=torch.float32, + ).to(self.device) + + self.headings = torch.zeros( + (self.worlds_to_track, self.max_cont_agents_per_env, 91), + dtype=torch.float32, + ).to(self.device) return self.observations, [] @@ -348,18 +353,20 @@ def step(self, action): self.offroad_in_episode += info.off_road self.collided_in_episode += info.collided - # Log global states - batch_indices = torch.arange(self.worlds_to_track, device=self.device) - pos_x, pos_y, pos_z, heading, ids = get_state( - self.env, num_worlds=self.worlds_to_track - ) - episode_time_steps = ( - self.episode_lengths[: self.worlds_to_track, 0].long() - 1 - ) - self.pos_xyz[batch_indices, :, episode_time_steps, :] = torch.stack( - [pos_x, pos_y, pos_z], dim=-1 - ) - self.headings[batch_indices, :, episode_time_steps] = heading + if self.track_realism_metrics: # Log global states + batch_indices = torch.arange( + self.worlds_to_track, device=self.device + ) + pos_x, pos_y, pos_z, heading, ids = get_state( + self.env, num_worlds=self.worlds_to_track + ) + episode_time_steps = ( + self.episode_lengths[: self.worlds_to_track, 0].long() - 1 + ) + self.pos_xyz[ + batch_indices, :, episode_time_steps, : + ] = torch.stack([pos_x, pos_y, pos_z], dim=-1) + self.headings[batch_indices, :, episode_time_steps] = heading # Mask used for buffer self.masks = self.live_agent_mask[self.controlled_agent_mask] @@ -476,13 +483,14 @@ def step(self, action): self.human_like_rewards[done_worlds, :] = 0 self.internal_rewards[done_worlds, :] = 0 - tracked_done_worlds = done_worlds.tolist() and list( - range(self.worlds_to_track) - ) - if len(tracked_done_worlds): - self.compute_realism_metrics(tracked_done_worlds) - self.pos_xyz[tracked_done_worlds, :] = 0 - self.headings[tracked_done_worlds, :] = 0 + if self.track_realism_metrics: + tracked_done_worlds = done_worlds.tolist() and list( + range(self.worlds_to_track) + ) + if len(tracked_done_worlds): + self.compute_realism_metrics(tracked_done_worlds) + self.pos_xyz[tracked_done_worlds, :] = 0 + self.headings[tracked_done_worlds, :] = 0 # Get the next observations. Note that we do this after resetting # the worlds so that we always return a fresh observation From 97aa5a183f007f9d47294881f93dc10b4d5f0919 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Wed, 16 Apr 2025 09:28:06 -0400 Subject: [PATCH 43/81] WIP --- baselines/ppo/config/ppo_waypoint.yaml | 22 +++++++++++----------- gpudrive/env/env_puffer.py | 3 --- 2 files changed, 11 insertions(+), 14 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 644e13a3c..27650964a 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -2,14 +2,14 @@ mode: "train" use_rnn: false eval_model_path: null baseline: false -data_dir: data/processed/examples +data_dir: data/processed/training continue_training: false model_cpt: null environment: # Overrides default environment configs (see pygpudrive/env/config.py) name: "gpudrive" - num_worlds: 75 # Number of parallel environments - k_unique_scenes: 4 # Number of unique scenes to sample from + num_worlds: 1 # Number of parallel environments + k_unique_scenes: 1 # Number of unique scenes to sample from max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp ego_state: true road_map_obs: true @@ -23,8 +23,8 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. polyline_reduction_threshold: 0.1 # Rate at which to sample points from the polyline (0 is use all closest points, 1 maximum sparsity), needs to be balanced with kMaxAgentMapObservationsCount sampling_seed: 42 # If given, the set of scenes to sample from will be deterministic, if None, the set of scenes will be random obs_radius: 50.0 # Visibility radius of the agents - action_space_steer_disc: 31 - action_space_accel_disc: 11 + action_space_steer_disc: 13 + action_space_accel_disc: 7 init_steps: 0 # Warmup steps collision_weight: -0.2 off_road_weight: -0.2 @@ -56,10 +56,10 @@ train: compile_mode: "reduce-overhead" # # # Data sampling # # # - resample_scenes: false - resample_dataset_size: 500 # Number of unique scenes to sample from - resample_interval: 2_000_000 - sample_with_replacement: false + resample_scenes: true + resample_dataset_size: 10_000 # Number of unique scenes to sample from + resample_interval: 1000 #2_000_000 + sample_with_replacement: true shuffle_dataset: false # # # PPO # # # @@ -83,7 +83,7 @@ train: # # # Logging # # # log_window: 500 - track_realism_metrics: true # Log human-like metrics + track_realism_metrics: false # Log human-like metrics track_n_worlds: 2 # Number of worlds to track # # # Network # # # @@ -100,7 +100,7 @@ train: # # # Rendering # # # render: false # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d - render_interval: 50 # Render every k iterations + render_interval: 250 # Render every k iterations render_k_scenarios: 2 # Number of scenarios to render render_format: "mp4" # Options: gif, mp4 render_fps: 20 # Frames per second diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 3c1f49321..a81e97155 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -458,9 +458,6 @@ def step(self, action): "perc_truncated": num_truncated / num_finished_agents, "mean_waypoint_distance": human_like_values.mean().item(), "mean_internal_reward": internal_reward_values.mean().item(), - "waypoint_distance_distrib": wandb.Histogram( - human_like_values.cpu().numpy(), - ), } ) # fmt: on From 78a363d0ab364188dd5b7da313e44c0c39ca3731 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Wed, 16 Apr 2025 12:09:36 -0400 Subject: [PATCH 44/81] Add simple agent --- gpudrive/networks/agents.py | 153 +++++++++++++++++++++++++++++++++++- 1 file changed, 151 insertions(+), 2 deletions(-) diff --git a/gpudrive/networks/agents.py b/gpudrive/networks/agents.py index 9f5d048af..a35fbdfe6 100644 --- a/gpudrive/networks/agents.py +++ b/gpudrive/networks/agents.py @@ -18,6 +18,151 @@ def layer_init(layer, std=np.sqrt(2), bias_const=0.0): class Agent(nn.Module): + """ + Actor-Critic agent with shared embedding networks and separate actor and critic heads. + Expects a single observation vector as input. + """ + + def __init__( + self, + config, + embed_dim, + action_dim, + act_func="tanh", + dropout=0.00, + ): + super().__init__() + + self.config = config + self.act_func = nn.Tanh() if act_func == "tanh" else nn.ReLU() + self.dropout = dropout + self.action_dim = action_dim + + # Indices for unpacking the observation modalities + self.ego_state_idx = ( + 9 + if self.config["reward_type"] == "reward_conditioned" + else constants.EGO_FEAT_DIM + ) + if self.config[ + "add_reference_path" + ]: # Every agent receives a reference path + self.ego_state_idx += 91 * 2 + + self.max_controlled_agents = madrona_gpudrive.kMaxAgentCount + self.max_observable_agents = self.max_controlled_agents - 1 + self.partner_obs_idx = self.ego_state_idx + ( + constants.PARTNER_FEAT_DIM * self.max_observable_agents + ) + + # Shared embedding networks for both actor and critic + self.ego_embed = nn.Sequential( + layer_init(nn.Linear(self.ego_state_idx, embed_dim)), + nn.LayerNorm(embed_dim), + self.act_func, + nn.Dropout(self.dropout), + layer_init(nn.Linear(embed_dim, embed_dim)), + ) + + self.partner_embed = nn.Sequential( + layer_init(nn.Linear(constants.PARTNER_FEAT_DIM, embed_dim)), + nn.LayerNorm(embed_dim), + self.act_func, + nn.Dropout(self.dropout), + layer_init(nn.Linear(embed_dim, embed_dim)), + ) + + self.road_map_embed = nn.Sequential( + layer_init(nn.Linear(constants.ROAD_GRAPH_FEAT_DIM, embed_dim)), + nn.LayerNorm(embed_dim), + self.act_func, + nn.Dropout(self.dropout), + layer_init(nn.Linear(embed_dim, embed_dim)), + ) + + # Critic network + self.critic = nn.Sequential( + layer_init(nn.Linear(3 * embed_dim, 32)), + nn.LayerNorm(32), + self.act_func, + layer_init(nn.Linear(32, 1), std=1.0), + ) + + # Actor network + self.actor = nn.Sequential( + layer_init(nn.Linear(3 * embed_dim, 64)), + nn.LayerNorm(64), + self.act_func, + layer_init(nn.Linear(64, action_dim), std=0.01), + ) + + def get_value(self, x): + # Unpack into modalities + ego_state, partner_obs, road_graph = self.unpack_obs(x) + + # Embed each modality using shared embedding networks + ego_embed = self.ego_embed(ego_state) + partner_embed, _ = self.partner_embed(partner_obs).max(dim=1) + road_embed, _ = self.road_map_embed(road_graph).max(dim=1) + + # Concatenate the embeddings + x = torch.cat([ego_embed, partner_embed, road_embed], dim=-1) + + return self.critic(x) + + def forward(self, x, action=None): + """Forward pass through the network. + Args: + x: Flattened observation vector of size [B, F]. + action (Optional): Actions to take of size [B, 1]. + If None, a new actions are sampled. + """ + # Unpack into modalities + ego_state, partner_obs, road_graph = self.unpack_obs(x) + + # Use shared embedding networks for both actor and critic + ego_embed = self.ego_embed(ego_state) + partner_embed, _ = self.partner_embed(partner_obs).max(dim=1) + road_embed, _ = self.road_map_embed(road_graph).max(dim=1) + + # Concatenate the embeddings + z = torch.cat([ego_embed, partner_embed, road_embed], dim=-1) + + # Pass to the actor and critic networks + logits = self.actor(z) + probs = Categorical(logits=logits) + + if action is None: + action = probs.sample() + else: + # Reshape action from [B, 1] to [B] to match what Categorical expects + action = action.squeeze(-1) + + return ( + action, + probs.log_prob(action), + probs.entropy(), + self.critic(z), + ) + + def unpack_obs(self, obs_flat): + """Unpack the flattened observation into the ego state, visible simulator state.""" + + ego_state = obs_flat[:, : self.ego_state_idx] + partner_obs = obs_flat[:, self.ego_state_idx : self.partner_obs_idx] + roadgraph_obs = obs_flat[:, self.partner_obs_idx :] + + road_objects = partner_obs.view( + -1, self.max_observable_agents, constants.PARTNER_FEAT_DIM + ) + road_graph = roadgraph_obs.view( + -1, TOP_K_ROAD_POINTS, constants.ROAD_GRAPH_FEAT_DIM + ) + + return ego_state, road_objects, road_graph + + +class SeparateActorCriticAgent(nn.Module): """ " Actor-Critic agent with separate actor and critic networks. Expects a single observation vector as input. @@ -40,9 +185,13 @@ def __init__( # Indices for unpacking the observation modalities self.ego_state_idx = ( - 9 if self.config["reward_type"] == "reward_conditioned" else constants.EGO_FEAT_DIM + 9 + if self.config["reward_type"] == "reward_conditioned" + else constants.EGO_FEAT_DIM ) - if self.config["add_reference_path"]: # Every agent receives a reference path + if self.config[ + "add_reference_path" + ]: # Every agent receives a reference path self.ego_state_idx += 91 * 2 self.max_controlled_agents = madrona_gpudrive.kMaxAgentCount From 1886bc0d1797e4d46a50a620f9f311923a00a9c8 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Wed, 16 Apr 2025 18:05:56 -0400 Subject: [PATCH 45/81] Update settings --- baselines/ppo/config/ppo_base_puffer.yaml | 4 +-- baselines/ppo/config/ppo_waypoint.yaml | 12 ++++----- baselines/ppo/ppo_pufferlib.py | 20 +++++---------- gpudrive/networks/agents.py | 30 +++++++++-------------- gpudrive/networks/late_fusion.py | 2 +- src/consts.hpp | 2 +- 6 files changed, 27 insertions(+), 43 deletions(-) diff --git a/baselines/ppo/config/ppo_base_puffer.yaml b/baselines/ppo/config/ppo_base_puffer.yaml index 12d290344..ab942aa55 100644 --- a/baselines/ppo/config/ppo_base_puffer.yaml +++ b/baselines/ppo/config/ppo_base_puffer.yaml @@ -8,8 +8,8 @@ model_cpt: null environment: # Overrides default environment configs (see pygpudrive/env/config.py) name: "gpudrive" - num_worlds: 50 # Number of parallel environments - k_unique_scenes: 50 # Number of unique scenes to sample from + num_worlds: 100 # Number of parallel environments + k_unique_scenes: 100 # Number of unique scenes to sample from max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp ego_state: true road_map_obs: true diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 27650964a..7c7758ea6 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -8,8 +8,8 @@ model_cpt: null environment: # Overrides default environment configs (see pygpudrive/env/config.py) name: "gpudrive" - num_worlds: 1 # Number of parallel environments - k_unique_scenes: 1 # Number of unique scenes to sample from + num_worlds: 100 # Number of parallel environments + k_unique_scenes: 100 # Number of unique scenes to sample from max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp ego_state: true road_map_obs: true @@ -42,7 +42,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. wandb: entity: "" project: "humanlike" - group: "wosac" + group: "minimal" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] @@ -56,9 +56,9 @@ train: compile_mode: "reduce-overhead" # # # Data sampling # # # - resample_scenes: true + resample_scenes: false resample_dataset_size: 10_000 # Number of unique scenes to sample from - resample_interval: 1000 #2_000_000 + resample_interval: 5_000_000 sample_with_replacement: true shuffle_dataset: false @@ -82,7 +82,7 @@ train: target_kl: null # # # Logging # # # - log_window: 500 + log_window: 1000 track_realism_metrics: false # Log human-like metrics track_n_worlds: 2 # Number of worlds to track diff --git a/baselines/ppo/ppo_pufferlib.py b/baselines/ppo/ppo_pufferlib.py index 076d5623e..c995b15ab 100644 --- a/baselines/ppo/ppo_pufferlib.py +++ b/baselines/ppo/ppo_pufferlib.py @@ -20,7 +20,6 @@ from gpudrive.env.env_puffer import PufferGPUDrive from gpudrive.networks.late_fusion import NeuralNet -from gpudrive.networks.agents import Agent from gpudrive.env.dataset import SceneDataLoader import pufferlib @@ -72,21 +71,14 @@ def make_agent(env, config): else: # Start from scratch - # return NeuralNet( - # input_dim=config.train.network.input_dim, - # action_dim=env.single_action_space.n, - # hidden_dim=config.train.network.hidden_dim, - # dropout=config.train.network.dropout, - # config=config.environment, - # ) - - return Agent( - config=config.environment, - embed_dim=config.train.network.embed_dim, + return NeuralNet( + input_dim=config.train.network.input_dim, action_dim=env.single_action_space.n, + hidden_dim=config.train.network.hidden_dim, + dropout=config.train.network.dropout, + config=config.environment, ) - def train(args, vecenv): """Main training loop for the PPO agent.""" policy = make_agent(env=vecenv.driver_env, config=args).to( @@ -163,7 +155,7 @@ def sweep(args, project="PPO", sweep_name="my_sweep"): def run( config_path: Annotated[ str, typer.Argument(help="The path to the default configuration file") - ] = "baselines/ppo/config/ppo_population.yaml", + ] = "baselines/ppo/config/ppo_base_puffer.yaml", *, # fmt: off # Environment options diff --git a/gpudrive/networks/agents.py b/gpudrive/networks/agents.py index a35fbdfe6..7d8fcb37f 100644 --- a/gpudrive/networks/agents.py +++ b/gpudrive/networks/agents.py @@ -30,6 +30,7 @@ def __init__( action_dim, act_func="tanh", dropout=0.00, + top_k=3, # Max pooling features to keep ): super().__init__() @@ -37,6 +38,7 @@ def __init__( self.act_func = nn.Tanh() if act_func == "tanh" else nn.ReLU() self.dropout = dropout self.action_dim = action_dim + self.top_k = top_k # Indices for unpacking the observation modalities self.ego_state_idx = ( @@ -82,7 +84,7 @@ def __init__( # Critic network self.critic = nn.Sequential( - layer_init(nn.Linear(3 * embed_dim, 32)), + layer_init(nn.Linear((2*top_k + 1) * embed_dim, 32)), nn.LayerNorm(32), self.act_func, layer_init(nn.Linear(32, 1), std=1.0), @@ -90,26 +92,12 @@ def __init__( # Actor network self.actor = nn.Sequential( - layer_init(nn.Linear(3 * embed_dim, 64)), + layer_init(nn.Linear((2*top_k + 1) * embed_dim, 64)), nn.LayerNorm(64), self.act_func, layer_init(nn.Linear(64, action_dim), std=0.01), ) - def get_value(self, x): - # Unpack into modalities - ego_state, partner_obs, road_graph = self.unpack_obs(x) - - # Embed each modality using shared embedding networks - ego_embed = self.ego_embed(ego_state) - partner_embed, _ = self.partner_embed(partner_obs).max(dim=1) - road_embed, _ = self.road_map_embed(road_graph).max(dim=1) - - # Concatenate the embeddings - x = torch.cat([ego_embed, partner_embed, road_embed], dim=-1) - - return self.critic(x) - def forward(self, x, action=None): """Forward pass through the network. Args: @@ -122,11 +110,15 @@ def forward(self, x, action=None): # Use shared embedding networks for both actor and critic ego_embed = self.ego_embed(ego_state) - partner_embed, _ = self.partner_embed(partner_obs).max(dim=1) - road_embed, _ = self.road_map_embed(road_graph).max(dim=1) + partner_embed = self.partner_embed(partner_obs) + road_embed = self.road_map_embed(road_graph) + + # Take top k features from partner and road embeddings + partner_max_pool = torch.topk(partner_embed, k=self.top_k, dim=1)[0].flatten(start_dim=1) #partner_embed.max(dim=1) + road_max_pool = torch.topk(road_embed, k=self.top_k, dim=1)[0].flatten(start_dim=1) # Concatenate the embeddings - z = torch.cat([ego_embed, partner_embed, road_embed], dim=-1) + z = torch.cat([ego_embed, partner_max_pool, road_max_pool], dim=-1) # Pass to the actor and critic networks logits = self.actor(z) diff --git a/gpudrive/networks/late_fusion.py b/gpudrive/networks/late_fusion.py index b984c452f..504c78187 100644 --- a/gpudrive/networks/late_fusion.py +++ b/gpudrive/networks/late_fusion.py @@ -107,7 +107,7 @@ def __init__( # that determine the reward (collision, goal, off-road) self.ego_state_idx += 3 if "add_reference_path" in self.config: - self.ego_state_idx += 2 * madrona_gpudrive.kTrajectoryLength + self.ego_state_idx += 2 * 91 self.vbd_in_obs = self.config.vbd_in_obs diff --git a/src/consts.hpp b/src/consts.hpp index a99a4c65a..0768e9cd0 100644 --- a/src/consts.hpp +++ b/src/consts.hpp @@ -10,7 +10,7 @@ namespace consts { inline constexpr madrona::CountT kMaxAgentCount = 64; inline constexpr madrona::CountT kMaxRoadEntityCount = 10000; -inline constexpr madrona::CountT kMaxAgentMapObservationsCount = 200; +inline constexpr madrona::CountT kMaxAgentMapObservationsCount = 128; inline constexpr bool useEstimatedYaw = true; From c844ec6544f12704b2487e8f0a2a3b894560a39f Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Wed, 16 Apr 2025 19:45:27 -0400 Subject: [PATCH 46/81] Add condition in dones such tthat agents are not allowed to terminate before the log end --- baselines/ppo/config/ppo_waypoint.yaml | 6 +++--- gpudrive/env/env_puffer.py | 4 +++- gpudrive/env/env_torch.py | 30 +++++++++++++++++++------- 3 files changed, 28 insertions(+), 12 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 7c7758ea6..29861569f 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -2,7 +2,7 @@ mode: "train" use_rnn: false eval_model_path: null baseline: false -data_dir: data/processed/training +data_dir: data/processed/examples continue_training: false model_cpt: null @@ -16,7 +16,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. partner_obs: true norm_obs: true collision_behavior: "ignore" - goal_behavior: "remove" + goal_behavior: "stop" reward_type: "follow_waypoints" init_mode: all_non_trivial #womd_tracks_to_predict dynamics_model: "classic" @@ -101,7 +101,7 @@ train: render: false # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d render_interval: 250 # Render every k iterations - render_k_scenarios: 2 # Number of scenarios to render + render_k_scenarios: 1 # Number of scenarios to render render_format: "mp4" # Options: gif, mp4 render_fps: 20 # Frames per second zoom_radius: 100 diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index a81e97155..c9c4adcc4 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -329,7 +329,9 @@ def step(self, action): self.live_agent_mask ] += self.env.base_rewards[self.live_agent_mask] - terminal = self.env.get_dones().bool() + terminal = self.env.get_dones( + world_time_steps=self.episode_lengths[:, 0].long() + ) self.render_env() if self.render else None diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 8cb0a5a80..913346628 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -443,14 +443,28 @@ def reset( return self.get_obs(mask) - def get_dones(self): - return ( - self.sim.done_tensor() - .to_torch() - .clone() - .squeeze(dim=2) - .to(torch.float) - ) + def get_dones(self, world_time_steps=None): + """ + Returns tensor indicating which agents have terminated. + + Args: + world_time_steps: Optional tensor [num_worlds] with current timestep per world. + + Returns: + torch.Tensor: Boolean tensor [num_worlds, num_agents] where True indicates done. + """ + terminal = self.sim.done_tensor().to_torch().clone().squeeze(dim=2).to(torch.float) + + if world_time_steps is not None and self.config.reward_type == "follow_waypoints": + # Find last valid timestep for each agent + agent_episode_length = 90 - torch.argmax(self.log_trajectory.valids.squeeze(-1).flip(2), dim=2) + + # Compare with expanded world timesteps + expanded_time_steps = world_time_steps.unsqueeze(1).expand_as(agent_episode_length) + return terminal.bool() & (expanded_time_steps >= agent_episode_length) + + else: + return terminal.bool() def get_infos(self): return Info.from_tensor( From f50589a8764b5d3b1818e32ebf3fdb7d299b0d1a Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 17 Apr 2025 11:52:04 -0400 Subject: [PATCH 47/81] Update realism metrics and support for adding the reference speed --- baselines/ppo/config/ppo_waypoint.yaml | 9 +- gpudrive/datatypes/trajectory.py | 5 + gpudrive/env/config.py | 1 + gpudrive/env/env_puffer.py | 290 +++++++++++-------------- gpudrive/env/env_torch.py | 17 +- gpudrive/networks/agents.py | 2 + gpudrive/utils/wosac.py | 223 +++++++++++++++++++ 7 files changed, 371 insertions(+), 176 deletions(-) create mode 100644 gpudrive/utils/wosac.py diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 29861569f..3322447d1 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -2,7 +2,7 @@ mode: "train" use_rnn: false eval_model_path: null baseline: false -data_dir: data/processed/examples +data_dir: data/processed/training continue_training: false model_cpt: null @@ -37,6 +37,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. # Planning guidance add_reference_path: false # If true, the goal state is added to the ego observation + add_reference_speed: true # If true, the reference speed is added to the ego observation prob_reference_dropout: 0.0 # Value between 0 and 1, probability of a reference point to be zeroed out wandb: @@ -83,7 +84,7 @@ train: # # # Logging # # # log_window: 1000 - track_realism_metrics: false # Log human-like metrics + track_realism_metrics: true # Log human-like metrics track_n_worlds: 2 # Number of worlds to track # # # Network # # # @@ -100,8 +101,8 @@ train: # # # Rendering # # # render: false # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d - render_interval: 250 # Render every k iterations - render_k_scenarios: 1 # Number of scenarios to render + render_interval: 100 # Render every k iterations + render_k_scenarios: 2 # Number of scenarios to render render_format: "mp4" # Options: gif, mp4 render_fps: 20 # Frames per second zoom_radius: 100 diff --git a/gpudrive/datatypes/trajectory.py b/gpudrive/datatypes/trajectory.py index 2e4a1493c..e966ebd1c 100644 --- a/gpudrive/datatypes/trajectory.py +++ b/gpudrive/datatypes/trajectory.py @@ -77,6 +77,7 @@ def __init__( self.pos_xy = self.pos_xy * self.valids self.vel_xy = self.vel_xy * self.valids self.yaw = self.yaw * self.valids + self.ref_speed = self.comp_reference_speed() @classmethod def from_tensor( @@ -103,3 +104,7 @@ def restore_mean(self, mean_x, mean_y): # Apply to x and y coordinates self.pos_xy[:, :, :, 0] += mean_x_reshaped self.pos_xy[:, :, :, 1] += mean_y_reshaped + + def comp_reference_speed(self): + """Returns the average speed of the trajectory.""" + return torch.sqrt(self.vel_xy[:, :, :, 0]**2 + self.vel_xy[:, :, :, 1]**2) \ No newline at end of file diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index 45a9965ee..f402e211f 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -95,6 +95,7 @@ class EnvConfig: goal_behavior: str = "remove" # Options: "stop", "ignore", "remove" # Reference points settings + add_reference_speed: bool = False # Include reference speed in observations add_reference_path: bool = False prob_reference_dropout: float = 0.0 # Probability of dropping reference points min_reference_points: int = 1 # Minimum number of reference points diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index c9c4adcc4..911971ea2 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -19,6 +19,80 @@ from pufferlib.environment import PufferEnv from gpudrive import GPU_DRIVE_DATA_DIR +"""Metrics from + https://github.com/waymo-research/waymo-open-dataset/blob/master/src/waymo_open_dataset/wdl_limited/sim_agents_metrics/trajectory_features.py + implemented with numpy instead of tensorflow. +""" +def central_diff_np(t, pad_value): + """NumPy version of central_diff function. + + Computes central difference along the last axis. + """ + # Check if input is at least length 3 (needed for central diff) + if t.shape[-1] < 3: + result = np.full_like(t, pad_value) + return result + + # Create proper padding tensors + pad_shape = t.shape[:-1] + (1,) + pad_array = np.full(pad_shape, pad_value) + + # Compute central difference for middle elements + diff_t = (t[..., 2:] - t[..., :-2]) / 2 + + return np.concatenate([pad_array, diff_t, pad_array], axis=-1) + +def central_logical_and_np(t, pad_value): + """NumPy version of central_logical_and function.""" + # Check if input is at least length 3 + if t.shape[-1] < 3: + result = np.full_like(t, pad_value) + return result + + pad_shape = t.shape[:-1] + (1,) + pad_array = np.full(pad_shape, pad_value) + diff_t = np.logical_and(t[..., :-2], t[..., 2:]) + return np.concatenate([pad_array, diff_t, pad_array], axis=-1) + +def wrap_angle_np(angle): + """Wraps angles in the range [-pi, pi].""" + return (angle + np.pi) % (2 * np.pi) - np.pi + +def compute_kinematic_features_np(x, y, heading, seconds_per_step): + """NumPy version of compute_kinematic_features function, for x,y only.""" + # Compute positions and displacement + batch_shape = x.shape[:-1] + time_steps = x.shape[-1] + + # For very short trajectories, just return placeholders + if time_steps < 3: + placeholder = np.full(x.shape, np.nan) + return placeholder, placeholder, placeholder, placeholder + + # Linear speed - compute displacement first then magnitude + dx = central_diff_np(x, pad_value=np.nan) + dy = central_diff_np(y, pad_value=np.nan) + + # Calculate displacement norm directly (avoid reshaping issues) + displacements = np.sqrt(dx**2 + dy**2) + linear_speed = displacements / seconds_per_step + + # Linear acceleration (scalar) + linear_accel = central_diff_np(linear_speed, pad_value=np.nan) / seconds_per_step + + # Angular speed and acceleration + dh_step = wrap_angle_np(central_diff_np(heading, pad_value=np.nan)) + angular_speed = dh_step / seconds_per_step + angular_accel = central_diff_np(angular_speed, pad_value=np.nan) / seconds_per_step + + return linear_speed, linear_accel, angular_speed, angular_accel + +def compute_kinematic_validity_np(valid): + """NumPy version of compute_kinematic_validity function.""" + speed_validity = central_logical_and_np(valid, pad_value=False) + acceleration_validity = central_logical_and_np(speed_validity, pad_value=False) + return speed_validity, acceleration_validity + def get_state(env, num_worlds): ego_state = GlobalEgoState.from_tensor( @@ -69,6 +143,7 @@ def __init__( lidar_obs=False, bev_obs=False, add_reference_path=False, + add_reference_speed=False, prob_reference_dropout=0.0, reward_type="weighted_combination", condition_mode="random", @@ -121,7 +196,6 @@ def __init__( self.goal_achieved_weight = goal_achieved_weight self.init_mode = init_mode self.reward_type = reward_type - self.prob_reference_dropout = prob_reference_dropout self.render = render self.render_interval = render_interval @@ -157,6 +231,7 @@ def __init__( norm_obs=norm_obs, bev_obs=bev_obs, add_reference_path=add_reference_path, + add_reference_speed=add_reference_speed, prob_reference_dropout=prob_reference_dropout, dynamics_model=dynamics_model, collision_behavior=collision_behavior, @@ -626,13 +701,6 @@ def compute_realism_metrics(self, done_worlds): Args: done_worlds: List of indices of the worlds to track. """ - import tensorflow as tf - import numpy as np - from waymo_open_dataset.wdl_limited.sim_agents_metrics.trajectory_features import ( - compute_displacement_error, - compute_kinematic_features, - compute_kinematic_validity, - ) # [worlds, max_cont_agents] control_mask = ( @@ -655,7 +723,6 @@ def compute_realism_metrics(self, done_worlds): .cpu() .numpy()[control_mask] ) - ref_pos_z_np = np.zeros_like(ref_pos_xy_np[:, :, 0]) # Shape: [worlds, max_cont_agents, time, 1] -> [batch, time, 1] ref_headings_np = ( self.env.log_trajectory.yaw[done_worlds] @@ -665,7 +732,6 @@ def compute_realism_metrics(self, done_worlds): .squeeze(-1) ) - # Get agent information and convert to numpy agent_headings_np = ( self.headings[done_worlds].detach().cpu().numpy()[control_mask] ) @@ -673,171 +739,59 @@ def compute_realism_metrics(self, done_worlds): self.pos_xyz[done_worlds].detach().cpu().numpy()[control_mask] ) - # Extract x, y, z components + # Extract x, y components (z is not informative) agent_x_np = agent_pos_xyz_np[..., 0] agent_y_np = agent_pos_xyz_np[..., 1] - agent_z_np = agent_pos_xyz_np[..., 2] ref_x_np = ref_pos_xy_np[..., 0] ref_y_np = ref_pos_xy_np[..., 1] - # Convert to TensorFlow tensors - ref_x = tf.convert_to_tensor(ref_x_np, dtype=tf.float32) - ref_y = tf.convert_to_tensor(ref_y_np, dtype=tf.float32) - ref_z = tf.convert_to_tensor(ref_pos_z_np, dtype=tf.float32) - ref_heading = tf.convert_to_tensor(ref_headings_np, dtype=tf.float32) - - agent_x = tf.convert_to_tensor(agent_x_np, dtype=tf.float32) - agent_y = tf.convert_to_tensor(agent_y_np, dtype=tf.float32) - agent_z = tf.convert_to_tensor(agent_z_np, dtype=tf.float32) - agent_heading = tf.convert_to_tensor( - agent_headings_np, dtype=tf.float32 - ) - - valid_mask = tf.convert_to_tensor(valid_mask, dtype=tf.bool) - # Step duration in seconds seconds_per_step = 0.1 # Assuming 10Hz sampling rate - - speed_validity, accel_validity = compute_kinematic_validity(valid_mask) - - # Compute kinematic features for agents - ( - agent_speed, - agent_accel, - agent_angular_speed, - agent_angular_accel, - ) = compute_kinematic_features( - agent_x, agent_y, agent_z, agent_heading, seconds_per_step + + # Compute the metrics for agent trajectories + agent_linear_speed, agent_linear_accel, agent_angular_speed, agent_angular_accel = compute_kinematic_features_np( + agent_x_np, agent_y_np, agent_headings_np, seconds_per_step ) - - # Compute kinematic features for reference trajectories - ( - ref_speed, - ref_accel, - ref_angular_speed, - ref_angular_accel, - ) = compute_kinematic_features( - ref_x, ref_y, ref_z, ref_heading, seconds_per_step + + # Compute the metrics for reference trajectories + ref_linear_speed, ref_linear_accel, ref_angular_speed, ref_angular_accel = compute_kinematic_features_np( + ref_x_np, ref_y_np, ref_headings_np, seconds_per_step ) - - # Compute displacement error - displacement_error = compute_displacement_error( - agent_x, agent_y, agent_z, ref_x, ref_y, ref_z - ) - - # Compute additional metrics - speed_error = tf.abs(agent_speed - ref_speed) - accel_error = tf.abs(agent_accel - ref_accel) - angular_speed_error = tf.abs(agent_angular_speed - ref_angular_speed) - angular_accel_error = tf.abs(agent_angular_accel - ref_angular_accel) - - def masked_mean_no_nan_inf(tensor): - """Compute mean excluding NaN and Inf values.""" - # Create masks for non-NaN and non-Inf values - non_nan_mask = tf.math.logical_not(tf.math.is_nan(tensor)) - non_inf_mask = tf.math.logical_not(tf.math.is_inf(tensor)) - valid_values_mask = tf.logical_and(non_nan_mask, non_inf_mask) - - # Apply mask to tensor - masked_tensor = tf.boolean_mask(tensor, valid_values_mask) - - # If all values are filtered out, return 0.0 - if tf.size(masked_tensor) == 0: - return tf.constant(0.0, dtype=tf.float32) - - # Compute mean of valid values - return tf.reduce_mean(masked_tensor) - - def masked_mean_with_validity_no_inf(tensor, validity_mask): - """Compute mean excluding NaN and Inf values and applying validity mask.""" - # Create masks for non-NaN and non-Inf values - non_nan_mask = tf.math.logical_not(tf.math.is_nan(tensor)) - non_inf_mask = tf.math.logical_not(tf.math.is_inf(tensor)) - data_valid_mask = tf.logical_and(non_nan_mask, non_inf_mask) - - # Combine with validity mask - combined_mask = tf.logical_and(data_valid_mask, validity_mask) - - # Apply combined mask to tensor - masked_tensor = tf.boolean_mask(tensor, combined_mask) - - # If all values are filtered out, return 0.0 - if tf.size(masked_tensor) == 0: - return tf.constant(0.0, dtype=tf.float32) - - # Compute mean of valid values - return tf.reduce_mean(masked_tensor) - - metrics = { - "displacement_error": float( - masked_mean_no_nan_inf(displacement_error).numpy() - ), - "speed_error": float( - masked_mean_with_validity_no_inf( - speed_error, speed_validity - ).numpy() - ), - "accel_error": float( - masked_mean_with_validity_no_inf( - accel_error, accel_validity - ).numpy() - ), - "angular_speed_error": float( - masked_mean_with_validity_no_inf( - angular_speed_error, speed_validity - ).numpy() - ), - "angular_accel_error": float( - masked_mean_with_validity_no_inf( - angular_accel_error, accel_validity - ).numpy() - ), - "agent_speed": float( - masked_mean_with_validity_no_inf( - agent_speed, speed_validity - ).numpy() - ), - "agent_accel": float( - masked_mean_with_validity_no_inf( - agent_accel, accel_validity - ).numpy() - ), - "agent_angular_speed": float( - masked_mean_with_validity_no_inf( - agent_angular_speed, speed_validity - ).numpy() - ), - "agent_angular_accel": float( - masked_mean_with_validity_no_inf( - agent_angular_accel, accel_validity - ).numpy() - ), - "ref_speed": float( - masked_mean_with_validity_no_inf( - ref_speed, speed_validity - ).numpy() - ), - "ref_accel": float( - masked_mean_with_validity_no_inf( - ref_accel, accel_validity - ).numpy() - ), - "ref_angular_speed": float( - masked_mean_with_validity_no_inf( - ref_angular_speed, speed_validity - ).numpy() - ), - "ref_angular_accel": float( - masked_mean_with_validity_no_inf( - ref_angular_accel, accel_validity - ).numpy() - ), - } - - wandb_metrics = {} - for key, value in metrics.items(): - wandb_metrics[f"realism/{key}"] = value - wandb.log(wandb_metrics) - - del wandb_metrics + + # Check which time steps are valid + speed_valid, accel_valid = compute_kinematic_validity_np(valid_mask) + + # Calculate absolute diffs between agent and reference trajectories + linear_speed_error = np.abs(agent_linear_speed - ref_linear_speed) + linear_accel_error = np.abs(agent_linear_accel - ref_linear_accel) + angular_speed_error = np.abs(agent_angular_speed - ref_angular_speed) + angular_accel_error = np.abs(agent_angular_accel - ref_angular_accel) + + # Apply validity masks + masked_speed_error = np.ma.array(linear_speed_error, mask=~speed_valid) + masked_accel_error = np.ma.array(linear_accel_error, mask=~accel_valid) + masked_angular_speed_error = np.ma.array(angular_speed_error, mask=~speed_valid) + masked_angular_accel_error = np.ma.array(angular_accel_error, mask=~accel_valid) + + # Compute MAEs + mean_linear_speed_error = masked_speed_error.mean() + mean_linear_accel_error = masked_accel_error.mean() + mean_angular_speed_error = masked_angular_speed_error.mean() + mean_angular_accel_error = masked_angular_accel_error.mean() + + if self.wandb_obj is not None: + self.wandb_obj.log( + { + "realism/kinematic_linear_speed_mae": mean_linear_speed_error, + "realism/kinematic_linear_accel_mae": mean_linear_accel_error, + "realism/kinematic_angular_speed_mae": mean_angular_speed_error, + "realism/kinematic_angular_accel_mae": mean_angular_accel_error, + "realism/kinematic_ref_linear_speed_dist": wandb.Histogram(ref_linear_speed[speed_valid]), + "realism/kinematic_ref_linear_accel_dist": wandb.Histogram(ref_linear_accel[accel_valid]), + "realism/kinematic_agent_linear_speed_dist": wandb.Histogram(agent_linear_speed[speed_valid]), + "realism/kinematic_agent_linear_accel_dist": wandb.Histogram(agent_linear_speed[accel_valid]), + + }, + step=self.global_step, + ) \ No newline at end of file diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 913346628..7b33d5874 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -456,10 +456,9 @@ def get_dones(self, world_time_steps=None): terminal = self.sim.done_tensor().to_torch().clone().squeeze(dim=2).to(torch.float) if world_time_steps is not None and self.config.reward_type == "follow_waypoints": - # Find last valid timestep for each agent + # Find last valid timestep for each agent, this is the ground-truth episode length agent_episode_length = 90 - torch.argmax(self.log_trajectory.valids.squeeze(-1).flip(2), dim=2) - - # Compare with expanded world timesteps + expanded_time_steps = world_time_steps.unsqueeze(1).expand_as(agent_episode_length) return terminal.bool() & (expanded_time_steps >= agent_episode_length) @@ -788,7 +787,8 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: if self.config.norm_obs: ego_state.normalize() - + + base_fields = [ ego_state.speed.unsqueeze(-1), ego_state.vehicle_length.unsqueeze(-1), @@ -799,6 +799,10 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: ] if mask is None: + + if self.config.add_reference_speed: + avg_ref_speed = self.log_trajectory.ref_speed.mean(axis=-1) / constants.MAX_SPEED + base_fields.append(avg_ref_speed.unsqueeze(-1)) if self.config.add_reference_path: @@ -881,6 +885,11 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: else: return torch.cat(base_fields, dim=-1) else: + + if self.config.add_reference_speed: + avg_ref_speed = self.log_trajectory.ref_speed[mask].mean(axis=-1) / constants.MAX_SPEED + base_fields.append(avg_ref_speed.unsqueeze(-1)) + if self.config.add_reference_path: # Shape: [batch, 91, 2] diff --git a/gpudrive/networks/agents.py b/gpudrive/networks/agents.py index 7d8fcb37f..c34edd498 100644 --- a/gpudrive/networks/agents.py +++ b/gpudrive/networks/agents.py @@ -51,6 +51,8 @@ def __init__( ]: # Every agent receives a reference path self.ego_state_idx += 91 * 2 + if self.config["add_reference_speed"]: + self.ego_state_idx += 1 self.max_controlled_agents = madrona_gpudrive.kMaxAgentCount self.max_observable_agents = self.max_controlled_agents - 1 self.partner_obs_idx = self.ego_state_idx + ( diff --git a/gpudrive/utils/wosac.py b/gpudrive/utils/wosac.py new file mode 100644 index 000000000..ad29ef5e7 --- /dev/null +++ b/gpudrive/utils/wosac.py @@ -0,0 +1,223 @@ +import wandb +import tensorflow as tf +import numpy as np +from waymo_open_dataset.wdl_limited.sim_agents_metrics.trajectory_features import ( + compute_displacement_error, + compute_kinematic_features, + compute_kinematic_validity, +) + +def compute_realism_metrics(self, done_worlds): + """Compute realism metrics. + + Args: + done_worlds: List of indices of the worlds to track. + """ + + # [worlds, max_cont_agents] + control_mask = ( + self.controlled_agent_mask[done_worlds].detach().cpu().numpy() + ) + # [batch, time, 1] + valid_mask = ( + self.env.log_trajectory.valids[done_worlds] + .detach() + .cpu() + .numpy()[control_mask] + .squeeze(-1) + ) + + # Take human logs (ground-truth) + # Shape: [worlds, max_cont_agents, time, 2] -> [batch, time, 2] + ref_pos_xy_np = ( + self.env.log_trajectory.pos_xy[done_worlds] + .detach() + .cpu() + .numpy()[control_mask] + ) + ref_pos_z_np = np.zeros_like(ref_pos_xy_np[:, :, 0]) + # Shape: [worlds, max_cont_agents, time, 1] -> [batch, time, 1] + ref_headings_np = ( + self.env.log_trajectory.yaw[done_worlds] + .detach() + .cpu() + .numpy()[control_mask] + .squeeze(-1) + ) + + # Get agent information and convert to numpy + agent_headings_np = ( + self.headings[done_worlds].detach().cpu().numpy()[control_mask] + ) + agent_pos_xyz_np = ( + self.pos_xyz[done_worlds].detach().cpu().numpy()[control_mask] + ) + + # Extract x, y, z components + agent_x_np = agent_pos_xyz_np[..., 0] + agent_y_np = agent_pos_xyz_np[..., 1] + agent_z_np = agent_pos_xyz_np[..., 2] + + ref_x_np = ref_pos_xy_np[..., 0] + ref_y_np = ref_pos_xy_np[..., 1] + + # Convert to TensorFlow tensors + ref_x = tf.convert_to_tensor(ref_x_np, dtype=tf.float32) + ref_y = tf.convert_to_tensor(ref_y_np, dtype=tf.float32) + ref_z = tf.convert_to_tensor(ref_pos_z_np, dtype=tf.float32) + ref_heading = tf.convert_to_tensor(ref_headings_np, dtype=tf.float32) + + agent_x = tf.convert_to_tensor(agent_x_np, dtype=tf.float32) + agent_y = tf.convert_to_tensor(agent_y_np, dtype=tf.float32) + agent_z = tf.convert_to_tensor(agent_z_np, dtype=tf.float32) + agent_heading = tf.convert_to_tensor( + agent_headings_np, dtype=tf.float32 + ) + + valid_mask = tf.convert_to_tensor(valid_mask, dtype=tf.bool) + + # Step duration in seconds + seconds_per_step = 0.1 # Assuming 10Hz sampling rate + + speed_validity, accel_validity = compute_kinematic_validity(valid_mask) + + # Compute kinematic features for agents + ( + agent_speed, + agent_accel, + agent_angular_speed, + agent_angular_accel, + ) = compute_kinematic_features( + agent_x, agent_y, agent_z, agent_heading, seconds_per_step + ) + + # Compute kinematic features for reference trajectories + ( + ref_speed, + ref_accel, + ref_angular_speed, + ref_angular_accel, + ) = compute_kinematic_features( + ref_x, ref_y, ref_z, ref_heading, seconds_per_step + ) + + # Compute displacement error + displacement_error = compute_displacement_error( + agent_x, agent_y, agent_z, ref_x, ref_y, ref_z + ) + + # Compute additional metrics + speed_error = tf.abs(agent_speed - ref_speed) + accel_error = tf.abs(agent_accel - ref_accel) + angular_speed_error = tf.abs(agent_angular_speed - ref_angular_speed) + angular_accel_error = tf.abs(agent_angular_accel - ref_angular_accel) + + def masked_mean_no_nan_inf(tensor): + """Compute mean excluding NaN and Inf values.""" + # Create masks for non-NaN and non-Inf values + non_nan_mask = tf.math.logical_not(tf.math.is_nan(tensor)) + non_inf_mask = tf.math.logical_not(tf.math.is_inf(tensor)) + valid_values_mask = tf.logical_and(non_nan_mask, non_inf_mask) + + # Apply mask to tensor + masked_tensor = tf.boolean_mask(tensor, valid_values_mask) + + # If all values are filtered out, return 0.0 + if tf.size(masked_tensor) == 0: + return tf.constant(0.0, dtype=tf.float32) + + # Compute mean of valid values + return tf.reduce_mean(masked_tensor) + + def masked_mean_with_validity_no_inf(tensor, validity_mask): + """Compute mean excluding NaN and Inf values and applying validity mask.""" + # Create masks for non-NaN and non-Inf values + non_nan_mask = tf.math.logical_not(tf.math.is_nan(tensor)) + non_inf_mask = tf.math.logical_not(tf.math.is_inf(tensor)) + data_valid_mask = tf.logical_and(non_nan_mask, non_inf_mask) + + # Combine with validity mask + combined_mask = tf.logical_and(data_valid_mask, validity_mask) + + # Apply combined mask to tensor + masked_tensor = tf.boolean_mask(tensor, combined_mask) + + # If all values are filtered out, return 0.0 + if tf.size(masked_tensor) == 0: + return tf.constant(0.0, dtype=tf.float32) + + # Compute mean of valid values + return tf.reduce_mean(masked_tensor) + + metrics = { + "displacement_error": float( + masked_mean_no_nan_inf(displacement_error).numpy() + ), + "speed_error": float( + masked_mean_with_validity_no_inf( + speed_error, speed_validity + ).numpy() + ), + "accel_error": float( + masked_mean_with_validity_no_inf( + accel_error, accel_validity + ).numpy() + ), + "angular_speed_error": float( + masked_mean_with_validity_no_inf( + angular_speed_error, speed_validity + ).numpy() + ), + "angular_accel_error": float( + masked_mean_with_validity_no_inf( + angular_accel_error, accel_validity + ).numpy() + ), + "agent_speed": float( + masked_mean_with_validity_no_inf( + agent_speed, speed_validity + ).numpy() + ), + "agent_accel": float( + masked_mean_with_validity_no_inf( + agent_accel, accel_validity + ).numpy() + ), + "agent_angular_speed": float( + masked_mean_with_validity_no_inf( + agent_angular_speed, speed_validity + ).numpy() + ), + "agent_angular_accel": float( + masked_mean_with_validity_no_inf( + agent_angular_accel, accel_validity + ).numpy() + ), + "ref_speed": float( + masked_mean_with_validity_no_inf( + ref_speed, speed_validity + ).numpy() + ), + "ref_accel": float( + masked_mean_with_validity_no_inf( + ref_accel, accel_validity + ).numpy() + ), + "ref_angular_speed": float( + masked_mean_with_validity_no_inf( + ref_angular_speed, speed_validity + ).numpy() + ), + "ref_angular_accel": float( + masked_mean_with_validity_no_inf( + ref_angular_accel, accel_validity + ).numpy() + ), + } + + wandb_metrics = {} + for key, value in metrics.items(): + wandb_metrics[f"realism/{key}"] = value + wandb.log(wandb_metrics) + + del wandb_metrics From bae9eeff05c17b5f6ae4b1d58d27ca594527fe0f Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 17 Apr 2025 11:52:10 -0400 Subject: [PATCH 48/81] Update realism metrics and support for adding the reference speed --- gpudrive/datatypes/trajectory.py | 4 +- gpudrive/env/config.py | 14 +++-- gpudrive/env/env_puffer.py | 95 +++++++++++++++++++++----------- gpudrive/env/env_torch.py | 54 ++++++++++++------ gpudrive/networks/agents.py | 18 ++++-- gpudrive/utils/wosac.py | 15 ++--- 6 files changed, 130 insertions(+), 70 deletions(-) diff --git a/gpudrive/datatypes/trajectory.py b/gpudrive/datatypes/trajectory.py index e966ebd1c..75eb20b26 100644 --- a/gpudrive/datatypes/trajectory.py +++ b/gpudrive/datatypes/trajectory.py @@ -107,4 +107,6 @@ def restore_mean(self, mean_x, mean_y): def comp_reference_speed(self): """Returns the average speed of the trajectory.""" - return torch.sqrt(self.vel_xy[:, :, :, 0]**2 + self.vel_xy[:, :, :, 1]**2) \ No newline at end of file + return torch.sqrt( + self.vel_xy[:, :, :, 0] ** 2 + self.vel_xy[:, :, :, 1] ** 2 + ) diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index f402e211f..9a9fc6dc6 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -93,12 +93,16 @@ class EnvConfig: # Goal behavior settings goal_behavior: str = "remove" # Options: "stop", "ignore", "remove" - + # Reference points settings - add_reference_speed: bool = False # Include reference speed in observations - add_reference_path: bool = False - prob_reference_dropout: float = 0.0 # Probability of dropping reference points - min_reference_points: int = 1 # Minimum number of reference points + add_reference_speed: bool = ( + False # Include reference speed in observations + ) + add_reference_path: bool = False + prob_reference_dropout: float = ( + 0.0 # Probability of dropping reference points + ) + min_reference_points: int = 1 # Minimum number of reference points # Reward settings reward_type: str = "sparse_on_goal_achieved" diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 911971ea2..c3c51c967 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -19,51 +19,56 @@ from pufferlib.environment import PufferEnv from gpudrive import GPU_DRIVE_DATA_DIR -"""Metrics from +"""Metrics from https://github.com/waymo-research/waymo-open-dataset/blob/master/src/waymo_open_dataset/wdl_limited/sim_agents_metrics/trajectory_features.py implemented with numpy instead of tensorflow. """ + + def central_diff_np(t, pad_value): """NumPy version of central_diff function. - + Computes central difference along the last axis. """ # Check if input is at least length 3 (needed for central diff) if t.shape[-1] < 3: result = np.full_like(t, pad_value) return result - + # Create proper padding tensors pad_shape = t.shape[:-1] + (1,) pad_array = np.full(pad_shape, pad_value) - + # Compute central difference for middle elements diff_t = (t[..., 2:] - t[..., :-2]) / 2 - + return np.concatenate([pad_array, diff_t, pad_array], axis=-1) + def central_logical_and_np(t, pad_value): """NumPy version of central_logical_and function.""" # Check if input is at least length 3 if t.shape[-1] < 3: result = np.full_like(t, pad_value) return result - + pad_shape = t.shape[:-1] + (1,) pad_array = np.full(pad_shape, pad_value) diff_t = np.logical_and(t[..., :-2], t[..., 2:]) return np.concatenate([pad_array, diff_t, pad_array], axis=-1) + def wrap_angle_np(angle): """Wraps angles in the range [-pi, pi].""" return (angle + np.pi) % (2 * np.pi) - np.pi + def compute_kinematic_features_np(x, y, heading, seconds_per_step): """NumPy version of compute_kinematic_features function, for x,y only.""" # Compute positions and displacement batch_shape = x.shape[:-1] time_steps = x.shape[-1] - + # For very short trajectories, just return placeholders if time_steps < 3: placeholder = np.full(x.shape, np.nan) @@ -72,25 +77,32 @@ def compute_kinematic_features_np(x, y, heading, seconds_per_step): # Linear speed - compute displacement first then magnitude dx = central_diff_np(x, pad_value=np.nan) dy = central_diff_np(y, pad_value=np.nan) - + # Calculate displacement norm directly (avoid reshaping issues) displacements = np.sqrt(dx**2 + dy**2) linear_speed = displacements / seconds_per_step - + # Linear acceleration (scalar) - linear_accel = central_diff_np(linear_speed, pad_value=np.nan) / seconds_per_step - + linear_accel = ( + central_diff_np(linear_speed, pad_value=np.nan) / seconds_per_step + ) + # Angular speed and acceleration dh_step = wrap_angle_np(central_diff_np(heading, pad_value=np.nan)) angular_speed = dh_step / seconds_per_step - angular_accel = central_diff_np(angular_speed, pad_value=np.nan) / seconds_per_step - + angular_accel = ( + central_diff_np(angular_speed, pad_value=np.nan) / seconds_per_step + ) + return linear_speed, linear_accel, angular_speed, angular_accel + def compute_kinematic_validity_np(valid): """NumPy version of compute_kinematic_validity function.""" speed_validity = central_logical_and_np(valid, pad_value=False) - acceleration_validity = central_logical_and_np(speed_validity, pad_value=False) + acceleration_validity = central_logical_and_np( + speed_validity, pad_value=False + ) return speed_validity, acceleration_validity @@ -748,38 +760,52 @@ def compute_realism_metrics(self, done_worlds): # Step duration in seconds seconds_per_step = 0.1 # Assuming 10Hz sampling rate - + # Compute the metrics for agent trajectories - agent_linear_speed, agent_linear_accel, agent_angular_speed, agent_angular_accel = compute_kinematic_features_np( + ( + agent_linear_speed, + agent_linear_accel, + agent_angular_speed, + agent_angular_accel, + ) = compute_kinematic_features_np( agent_x_np, agent_y_np, agent_headings_np, seconds_per_step ) - + # Compute the metrics for reference trajectories - ref_linear_speed, ref_linear_accel, ref_angular_speed, ref_angular_accel = compute_kinematic_features_np( + ( + ref_linear_speed, + ref_linear_accel, + ref_angular_speed, + ref_angular_accel, + ) = compute_kinematic_features_np( ref_x_np, ref_y_np, ref_headings_np, seconds_per_step ) - + # Check which time steps are valid speed_valid, accel_valid = compute_kinematic_validity_np(valid_mask) - + # Calculate absolute diffs between agent and reference trajectories linear_speed_error = np.abs(agent_linear_speed - ref_linear_speed) linear_accel_error = np.abs(agent_linear_accel - ref_linear_accel) angular_speed_error = np.abs(agent_angular_speed - ref_angular_speed) angular_accel_error = np.abs(agent_angular_accel - ref_angular_accel) - + # Apply validity masks masked_speed_error = np.ma.array(linear_speed_error, mask=~speed_valid) masked_accel_error = np.ma.array(linear_accel_error, mask=~accel_valid) - masked_angular_speed_error = np.ma.array(angular_speed_error, mask=~speed_valid) - masked_angular_accel_error = np.ma.array(angular_accel_error, mask=~accel_valid) - + masked_angular_speed_error = np.ma.array( + angular_speed_error, mask=~speed_valid + ) + masked_angular_accel_error = np.ma.array( + angular_accel_error, mask=~accel_valid + ) + # Compute MAEs mean_linear_speed_error = masked_speed_error.mean() mean_linear_accel_error = masked_accel_error.mean() mean_angular_speed_error = masked_angular_speed_error.mean() mean_angular_accel_error = masked_angular_accel_error.mean() - + if self.wandb_obj is not None: self.wandb_obj.log( { @@ -787,11 +813,18 @@ def compute_realism_metrics(self, done_worlds): "realism/kinematic_linear_accel_mae": mean_linear_accel_error, "realism/kinematic_angular_speed_mae": mean_angular_speed_error, "realism/kinematic_angular_accel_mae": mean_angular_accel_error, - "realism/kinematic_ref_linear_speed_dist": wandb.Histogram(ref_linear_speed[speed_valid]), - "realism/kinematic_ref_linear_accel_dist": wandb.Histogram(ref_linear_accel[accel_valid]), - "realism/kinematic_agent_linear_speed_dist": wandb.Histogram(agent_linear_speed[speed_valid]), - "realism/kinematic_agent_linear_accel_dist": wandb.Histogram(agent_linear_speed[accel_valid]), - + "realism/kinematic_ref_linear_speed_dist": wandb.Histogram( + ref_linear_speed[speed_valid] + ), + "realism/kinematic_ref_linear_accel_dist": wandb.Histogram( + ref_linear_accel[accel_valid] + ), + "realism/kinematic_agent_linear_speed_dist": wandb.Histogram( + agent_linear_speed[speed_valid] + ), + "realism/kinematic_agent_linear_accel_dist": wandb.Histogram( + agent_linear_speed[accel_valid] + ), }, step=self.global_step, - ) \ No newline at end of file + ) diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 7b33d5874..9841ba8a7 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -446,22 +446,37 @@ def reset( def get_dones(self, world_time_steps=None): """ Returns tensor indicating which agents have terminated. - + Args: world_time_steps: Optional tensor [num_worlds] with current timestep per world. - + Returns: torch.Tensor: Boolean tensor [num_worlds, num_agents] where True indicates done. """ - terminal = self.sim.done_tensor().to_torch().clone().squeeze(dim=2).to(torch.float) - - if world_time_steps is not None and self.config.reward_type == "follow_waypoints": + terminal = ( + self.sim.done_tensor() + .to_torch() + .clone() + .squeeze(dim=2) + .to(torch.float) + ) + + if ( + world_time_steps is not None + and self.config.reward_type == "follow_waypoints" + ): # Find last valid timestep for each agent, this is the ground-truth episode length - agent_episode_length = 90 - torch.argmax(self.log_trajectory.valids.squeeze(-1).flip(2), dim=2) - - expanded_time_steps = world_time_steps.unsqueeze(1).expand_as(agent_episode_length) - return terminal.bool() & (expanded_time_steps >= agent_episode_length) - + agent_episode_length = 90 - torch.argmax( + self.log_trajectory.valids.squeeze(-1).flip(2), dim=2 + ) + + expanded_time_steps = world_time_steps.unsqueeze(1).expand_as( + agent_episode_length + ) + return terminal.bool() & ( + expanded_time_steps >= agent_episode_length + ) + else: return terminal.bool() @@ -787,8 +802,7 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: if self.config.norm_obs: ego_state.normalize() - - + base_fields = [ ego_state.speed.unsqueeze(-1), ego_state.vehicle_length.unsqueeze(-1), @@ -799,9 +813,12 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: ] if mask is None: - + if self.config.add_reference_speed: - avg_ref_speed = self.log_trajectory.ref_speed.mean(axis=-1) / constants.MAX_SPEED + avg_ref_speed = ( + self.log_trajectory.ref_speed.mean(axis=-1) + / constants.MAX_SPEED + ) base_fields.append(avg_ref_speed.unsqueeze(-1)) if self.config.add_reference_path: @@ -885,11 +902,14 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: else: return torch.cat(base_fields, dim=-1) else: - + if self.config.add_reference_speed: - avg_ref_speed = self.log_trajectory.ref_speed[mask].mean(axis=-1) / constants.MAX_SPEED + avg_ref_speed = ( + self.log_trajectory.ref_speed[mask].mean(axis=-1) + / constants.MAX_SPEED + ) base_fields.append(avg_ref_speed.unsqueeze(-1)) - + if self.config.add_reference_path: # Shape: [batch, 91, 2] diff --git a/gpudrive/networks/agents.py b/gpudrive/networks/agents.py index c34edd498..f0fcd0c94 100644 --- a/gpudrive/networks/agents.py +++ b/gpudrive/networks/agents.py @@ -30,7 +30,7 @@ def __init__( action_dim, act_func="tanh", dropout=0.00, - top_k=3, # Max pooling features to keep + top_k=3, # Max pooling features to keep ): super().__init__() @@ -51,7 +51,7 @@ def __init__( ]: # Every agent receives a reference path self.ego_state_idx += 91 * 2 - if self.config["add_reference_speed"]: + if self.config["add_reference_speed"]: self.ego_state_idx += 1 self.max_controlled_agents = madrona_gpudrive.kMaxAgentCount self.max_observable_agents = self.max_controlled_agents - 1 @@ -86,7 +86,7 @@ def __init__( # Critic network self.critic = nn.Sequential( - layer_init(nn.Linear((2*top_k + 1) * embed_dim, 32)), + layer_init(nn.Linear((2 * top_k + 1) * embed_dim, 32)), nn.LayerNorm(32), self.act_func, layer_init(nn.Linear(32, 1), std=1.0), @@ -94,7 +94,7 @@ def __init__( # Actor network self.actor = nn.Sequential( - layer_init(nn.Linear((2*top_k + 1) * embed_dim, 64)), + layer_init(nn.Linear((2 * top_k + 1) * embed_dim, 64)), nn.LayerNorm(64), self.act_func, layer_init(nn.Linear(64, action_dim), std=0.01), @@ -116,8 +116,14 @@ def forward(self, x, action=None): road_embed = self.road_map_embed(road_graph) # Take top k features from partner and road embeddings - partner_max_pool = torch.topk(partner_embed, k=self.top_k, dim=1)[0].flatten(start_dim=1) #partner_embed.max(dim=1) - road_max_pool = torch.topk(road_embed, k=self.top_k, dim=1)[0].flatten(start_dim=1) + partner_max_pool = torch.topk(partner_embed, k=self.top_k, dim=1)[ + 0 + ].flatten( + start_dim=1 + ) # partner_embed.max(dim=1) + road_max_pool = torch.topk(road_embed, k=self.top_k, dim=1)[0].flatten( + start_dim=1 + ) # Concatenate the embeddings z = torch.cat([ego_embed, partner_max_pool, road_max_pool], dim=-1) diff --git a/gpudrive/utils/wosac.py b/gpudrive/utils/wosac.py index ad29ef5e7..02373bd3b 100644 --- a/gpudrive/utils/wosac.py +++ b/gpudrive/utils/wosac.py @@ -6,7 +6,8 @@ compute_kinematic_features, compute_kinematic_validity, ) - + + def compute_realism_metrics(self, done_worlds): """Compute realism metrics. @@ -70,9 +71,7 @@ def compute_realism_metrics(self, done_worlds): agent_x = tf.convert_to_tensor(agent_x_np, dtype=tf.float32) agent_y = tf.convert_to_tensor(agent_y_np, dtype=tf.float32) agent_z = tf.convert_to_tensor(agent_z_np, dtype=tf.float32) - agent_heading = tf.convert_to_tensor( - agent_headings_np, dtype=tf.float32 - ) + agent_heading = tf.convert_to_tensor(agent_headings_np, dtype=tf.float32) valid_mask = tf.convert_to_tensor(valid_mask, dtype=tf.bool) @@ -194,14 +193,10 @@ def masked_mean_with_validity_no_inf(tensor, validity_mask): ).numpy() ), "ref_speed": float( - masked_mean_with_validity_no_inf( - ref_speed, speed_validity - ).numpy() + masked_mean_with_validity_no_inf(ref_speed, speed_validity).numpy() ), "ref_accel": float( - masked_mean_with_validity_no_inf( - ref_accel, accel_validity - ).numpy() + masked_mean_with_validity_no_inf(ref_accel, accel_validity).numpy() ), "ref_angular_speed": float( masked_mean_with_validity_no_inf( From d936deadcdb2daa88b42e1f9a912ca6b013a13d3 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 17 Apr 2025 12:06:48 -0400 Subject: [PATCH 49/81] Settings --- baselines/ppo/config/ppo_waypoint.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 3322447d1..fa8594d61 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -2,14 +2,14 @@ mode: "train" use_rnn: false eval_model_path: null baseline: false -data_dir: data/processed/training +data_dir: data/processed/examples continue_training: false model_cpt: null environment: # Overrides default environment configs (see pygpudrive/env/config.py) name: "gpudrive" num_worlds: 100 # Number of parallel environments - k_unique_scenes: 100 # Number of unique scenes to sample from + k_unique_scenes: 4 # Number of unique scenes to sample from max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp ego_state: true road_map_obs: true @@ -37,7 +37,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. # Planning guidance add_reference_path: false # If true, the goal state is added to the ego observation - add_reference_speed: true # If true, the reference speed is added to the ego observation + add_reference_speed: false # If true, the reference speed is added to the ego observation prob_reference_dropout: 0.0 # Value between 0 and 1, probability of a reference point to be zeroed out wandb: From caa953c886f25eacd72ae85a213e636ed86c890b Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 17 Apr 2025 14:33:38 -0400 Subject: [PATCH 50/81] Add average displacement error --- baselines/ppo/config/ppo_waypoint.yaml | 6 ++--- gpudrive/env/env_puffer.py | 32 +++++++++++++++++++++++++- gpudrive/env/env_torch.py | 3 +++ 3 files changed, 37 insertions(+), 4 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index fa8594d61..8a5253cdd 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -37,18 +37,18 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. # Planning guidance add_reference_path: false # If true, the goal state is added to the ego observation - add_reference_speed: false # If true, the reference speed is added to the ego observation + add_reference_speed: true # If true, the reference speed is added to the ego observation prob_reference_dropout: 0.0 # Value between 0 and 1, probability of a reference point to be zeroed out wandb: entity: "" project: "humanlike" - group: "minimal" + group: "tinyexps" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] train: - exp_id: waypoint # Set dynamically in the script if needed + exp_id: waypoint_rs # Set dynamically in the script if needed seed: 42 cpu_offload: false device: "cuda" # Dynamically set to cuda if available, else cpu diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index c3c51c967..4ce36f181 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -21,10 +21,34 @@ """Metrics from https://github.com/waymo-research/waymo-open-dataset/blob/master/src/waymo_open_dataset/wdl_limited/sim_agents_metrics/trajectory_features.py - implemented with numpy instead of tensorflow. + implemented using numpy instead of tensorflow. """ +def compute_displacement_error_np(pred_x, pred_y, ref_x, ref_y): + """NumPy version of compute_displacement_error function. + + Computes displacement error (in x,y) w.r.t. a reference trajectory. + + Args: + pred_x: The x-component of the predicted trajectories. + pred_y: The y-component of the predicted trajectories. + ref_x: The x-component of the reference trajectories. + ref_y: The y-component of the reference trajectories. + + Returns: + A float array with the same shape as all the arguments, containing + the 2D distance between the predicted trajectories and the reference + trajectories. + """ + # Stack coordinates along a new axis + pred_xy = np.stack([pred_x, pred_y], axis=-1) + ref_xy = np.stack([ref_x, ref_y], axis=-1) + + # Calculate Euclidean distance + return np.linalg.norm(pred_xy - ref_xy, ord=2, axis=-1) + + def central_diff_np(t, pad_value): """NumPy version of central_diff function. @@ -790,6 +814,11 @@ def compute_realism_metrics(self, done_worlds): angular_speed_error = np.abs(agent_angular_speed - ref_angular_speed) angular_accel_error = np.abs(agent_angular_accel - ref_angular_accel) + # Calculate displacement error + displacement_error = compute_displacement_error_np( + agent_x_np, agent_y_np, ref_x_np, ref_y_np + ) + # Apply validity masks masked_speed_error = np.ma.array(linear_speed_error, mask=~speed_valid) masked_accel_error = np.ma.array(linear_accel_error, mask=~accel_valid) @@ -813,6 +842,7 @@ def compute_realism_metrics(self, done_worlds): "realism/kinematic_linear_accel_mae": mean_linear_accel_error, "realism/kinematic_angular_speed_mae": mean_angular_speed_error, "realism/kinematic_angular_accel_mae": mean_angular_accel_error, + "realism/mean_displacement_error": displacement_error.mean(), "realism/kinematic_ref_linear_speed_dist": wandb.Histogram( ref_linear_speed[speed_valid] ), diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 9841ba8a7..e4823618c 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -598,6 +598,9 @@ def get_rewards( gt_agent_pos = self.log_trajectory.pos_xy[ batch_indices, :, world_time_steps, : ] + gt_agent_speed = self.log_trajectory.ref_speed[ + batch_indices, :, world_time_steps + ] # Get actual agent positions agent_state = GlobalEgoState.from_tensor( From cb0a26b797c51e0a8562a2d6f156ea9da6e5dce1 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 17 Apr 2025 14:40:04 -0400 Subject: [PATCH 51/81] Set reward for reaching the goal --- baselines/ppo/config/ppo_waypoint.yaml | 1 + gpudrive/env/env_torch.py | 6 ++++-- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 8a5253cdd..ceb965329 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -26,6 +26,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. action_space_steer_disc: 13 action_space_accel_disc: 7 init_steps: 0 # Warmup steps + goal_achieved_weight: 0.0 collision_weight: -0.2 off_road_weight: -0.2 diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index e4823618c..4824887e7 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -490,7 +490,7 @@ def get_infos(self): def get_rewards( self, collision_weight=-0.5, - goal_achieved_weight=0.5, + goal_achieved_weight=0.0, off_road_weight=-0.5, world_time_steps=None, ): @@ -590,7 +590,9 @@ def get_rewards( elif self.config.reward_type == "follow_waypoints": # Reward based on minimizing distance to time-aligned waypoints plus penalty for collision/off-road self.base_rewards = ( - collision_weight * collided + off_road_weight * off_road + goal_achieved_weight * goal_achieved + + collision_weight * collided + + off_road_weight * off_road ) # Extract waypoints (ground truth) at time t From 61486d0b4455c55f7ef9edab5b6708d199dfa7fb Mon Sep 17 00:00:00 2001 From: daphnecor Date: Thu, 17 Apr 2025 16:23:38 -0400 Subject: [PATCH 52/81] Minor --- baselines/ppo/config/ppo_waypoint.yaml | 4 +++- baselines/ppo/ppo_waypoint.py | 3 +++ gpudrive/env/config.py | 3 +++ gpudrive/env/env_puffer.py | 9 ++++++--- gpudrive/utils/generate_sbatch.py | 23 ++++++++++++----------- 5 files changed, 27 insertions(+), 15 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index ceb965329..19296e4f9 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -18,6 +18,8 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. collision_behavior: "ignore" goal_behavior: "stop" reward_type: "follow_waypoints" + waypoint_distance_scale: 0.05 + init_mode: all_non_trivial #womd_tracks_to_predict dynamics_model: "classic" polyline_reduction_threshold: 0.1 # Rate at which to sample points from the polyline (0 is use all closest points, 1 maximum sparsity), needs to be balanced with kMaxAgentMapObservationsCount @@ -49,7 +51,7 @@ wandb: tags: ["ppo", "ff"] train: - exp_id: waypoint_rs # Set dynamically in the script if needed + exp_id: machine_like # Set dynamically in the script if needed seed: 42 cpu_offload: false device: "cuda" # Dynamically set to cuda if available, else cpu diff --git a/baselines/ppo/ppo_waypoint.py b/baselines/ppo/ppo_waypoint.py index 9e4782277..9ec193fec 100644 --- a/baselines/ppo/ppo_waypoint.py +++ b/baselines/ppo/ppo_waypoint.py @@ -116,6 +116,7 @@ def run( collision_weight: Annotated[Optional[float], typer.Option(help="The weight for collision penalty")] = None, off_road_weight: Annotated[Optional[float], typer.Option(help="The weight for off-road penalty")] = None, goal_achieved_weight: Annotated[Optional[float], typer.Option(help="The weight for goal-achieved reward")] = None, + waypoint_distance_scale: Annotated[Optional[float], typer.Option(help="Scale for realism rewards")] = None, dist_to_goal_threshold: Annotated[Optional[float], typer.Option(help="The distance threshold for goal-achieved")] = None, randomize_rewards: Annotated[Optional[int], typer.Option(help="If reward_type == reward_conditioned, choose the condition_mode; 0 or 1")] = 0, sampling_seed: Annotated[Optional[int], typer.Option(help="The seed for sampling scenes")] = None, @@ -127,6 +128,7 @@ def run( vbd_trajectory_weight: Annotated[Optional[float], typer.Option(help="Weight for VBD trajectory deviation penalty")] = 0.1, vbd_in_obs: Annotated[Optional[bool], typer.Option(help="Include VBD predictions in the observation")] = False, init_steps: Annotated[Optional[int], typer.Option(help="Environment warmup steps")] = 0, + # Train options seed: Annotated[Optional[int], typer.Option(help="The seed for training")] = None, learning_rate: Annotated[Optional[float], typer.Option(help="The learning rate for training")] = None, @@ -171,6 +173,7 @@ def run( "collision_weight": collision_weight, "off_road_weight": off_road_weight, "goal_achieved_weight": goal_achieved_weight, + "waypoint_distance_scale": waypoint_distance_scale, "dist_to_goal_threshold": dist_to_goal_threshold, "sampling_seed": sampling_seed, "obs_radius": obs_radius, diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index 9a9fc6dc6..611f75202 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -113,6 +113,9 @@ class EnvConfig: waypoint_distance_scale: float = ( 0.05 # Importance of distance to waypoints ) + speed_distance_scale: float = ( + 0.05 + ) # If reward_type is "reward_conditioned", the following parameters are used # Weights for the reward components diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 4ce36f181..89208dc89 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -182,6 +182,7 @@ def __init__( add_reference_speed=False, prob_reference_dropout=0.0, reward_type="weighted_combination", + waypoint_distance_scale=0.05, condition_mode="random", collision_behavior="ignore", goal_behavior="remove", @@ -263,6 +264,7 @@ def __init__( road_map_obs=road_map_obs, partner_obs=partner_obs, reward_type=reward_type, + waypoint_distance_scale=waypoint_distance_scale, condition_mode=condition_mode, norm_obs=norm_obs, bev_obs=bev_obs, @@ -440,9 +442,10 @@ def step(self, action): self.live_agent_mask ] += self.env.base_rewards[self.live_agent_mask] - terminal = self.env.get_dones( - world_time_steps=self.episode_lengths[:, 0].long() - ) + terminal = self.env.get_dones() + # terminal = self.env.get_dones( + # world_time_steps=self.episode_lengths[:, 0].long() + # ) self.render_env() if self.render else None diff --git a/gpudrive/utils/generate_sbatch.py b/gpudrive/utils/generate_sbatch.py index e34f26d79..d4c61e975 100644 --- a/gpudrive/utils/generate_sbatch.py +++ b/gpudrive/utils/generate_sbatch.py @@ -243,29 +243,30 @@ def save_script(filename, file_path, fields, params, param_order=None): if __name__ == "__main__": - group = "separate_actor_critic" + group = "minimal_tiny" fields = { - "time_h": 24, # Max time per job (job will finish if run is done before) + "time_h": 6, # Max time per job (job will finish if run is done before) "num_gpus": 1, # GPUs per job "max_sim_jobs": 30, # Max jobs at the same time "memory": 70, "job_name": group, + "run_file": "baselines/ppo/ppo_waypoint.py", } hyperparams = { "group": [group], # Group name "num_worlds": [500], "resample_scenes": [0], - "k_unique_scenes": [500], - "resample_interval": [5_000_000], - "resample_dataset_size": [10_000], - "total_timesteps": [3_000_000_000], - "batch_size": [262144], - "minibatch_size": [16384], - "update_epochs": [4], - "ent_coef": [0.001, 0.003, 0.0001], - "randomize_rewards": [0, 1], + "k_unique_scenes": [4], + #"resample_interval": [5_000_000], + #"resample_dataset_size": [10_000], + #"total_timesteps": [3_000_000_000], + "batch_size": [262_144], + "minibatch_size": [16_384], + "waypoint_distance_scale": [0.0, 0.05, 0.1], + "ent_coef": [0.001], + "vf_coef": [0.5], "render": [0], } From b4b5de38b79973c6785daf96d8af301d84f4b1dc Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Thu, 17 Apr 2025 17:42:52 -0400 Subject: [PATCH 53/81] New defaults --- baselines/ppo/config/ppo_waypoint.yaml | 3 ++- gpudrive/env/env_puffer.py | 17 +++++++---------- gpudrive/env/env_torch.py | 9 +++++++++ 3 files changed, 18 insertions(+), 11 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 19296e4f9..60486d8d0 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -19,6 +19,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. goal_behavior: "stop" reward_type: "follow_waypoints" waypoint_distance_scale: 0.05 + speed_distance_scale: 0.0 init_mode: all_non_trivial #womd_tracks_to_predict dynamics_model: "classic" @@ -51,7 +52,7 @@ wandb: tags: ["ppo", "ff"] train: - exp_id: machine_like # Set dynamically in the script if needed + exp_id: waypoint_rs # Set dynamically in the script if needed seed: 42 cpu_offload: false device: "cuda" # Dynamically set to cuda if available, else cpu diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 89208dc89..86450f343 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -136,12 +136,8 @@ def get_state(env, num_worlds): backend=env.backend, device=env.device, ) - mean_xy = env.sim.world_means_tensor().to_torch()[:, :2] - # mean_x = mean_xy[:, 0].unsqueeze(1) - # mean_y = mean_xy[:, 1].unsqueeze(1) - - glob_ego_pos_x = ego_state.pos_x # +mean_x - glob_ego_pos_y = ego_state.pos_y # +mean_y + glob_ego_pos_x = ego_state.pos_x + glob_ego_pos_y = ego_state.pos_y return ( glob_ego_pos_x[:num_worlds, :], glob_ego_pos_y[:num_worlds, :], @@ -183,6 +179,7 @@ def __init__( prob_reference_dropout=0.0, reward_type="weighted_combination", waypoint_distance_scale=0.05, + speed_distance_scale=0.0, condition_mode="random", collision_behavior="ignore", goal_behavior="remove", @@ -265,6 +262,7 @@ def __init__( partner_obs=partner_obs, reward_type=reward_type, waypoint_distance_scale=waypoint_distance_scale, + speed_distance_scale=speed_distance_scale, condition_mode=condition_mode, norm_obs=norm_obs, bev_obs=bev_obs, @@ -442,10 +440,9 @@ def step(self, action): self.live_agent_mask ] += self.env.base_rewards[self.live_agent_mask] - terminal = self.env.get_dones() - # terminal = self.env.get_dones( - # world_time_steps=self.episode_lengths[:, 0].long() - # ) + terminal = self.env.get_dones( + world_time_steps=self.episode_lengths[:, 0].long() + ) self.render_env() if self.render else None diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 4824887e7..90cba793c 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -464,6 +464,7 @@ def get_dones(self, world_time_steps=None): if ( world_time_steps is not None and self.config.reward_type == "follow_waypoints" + and self.config.waypoint_distance_scale > 0.0 ): # Find last valid timestep for each agent, this is the ground-truth episode length agent_episode_length = 90 - torch.argmax( @@ -611,10 +612,16 @@ def get_rewards( self.device, ) + actual_agent_speed = self.sim.self_observation_tensor().to_torch()[ + :, :, 0 + ] + actual_agent_pos = torch.stack( [agent_state.pos_x, agent_state.pos_y], dim=-1 ) + speed_error = (gt_agent_speed - actual_agent_speed) ** 2 + # Compute euclidean distance between agent and waypoints dist_to_waypoints = torch.norm( gt_agent_pos - actual_agent_pos, dim=-1 @@ -623,6 +630,8 @@ def get_rewards( self.distance_penalty = ( -self.config.waypoint_distance_scale * torch.log(dist_to_waypoints + 1.0) + - self.config.speed_distance_scale + * torch.log(speed_error + 1.0) ) # Apply waypoint mask only if sampling interval is greater than 1 From 8ce9df0a89e7f7390aa28603a3769f2e7caa243a Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 18 Apr 2025 09:32:37 -0400 Subject: [PATCH 54/81] Bug fix: Zero-out the waypoint distance computations for time steps where the reference logs are invalid. --- gpudrive/env/env_torch.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 90cba793c..063c76b9c 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -604,6 +604,9 @@ def get_rewards( gt_agent_speed = self.log_trajectory.ref_speed[ batch_indices, :, world_time_steps ] + valid_mask = self.log_trajectory.valids[ + batch_indices, :, world_time_steps + ].squeeze(-1).bool() # Get actual agent positions agent_state = GlobalEgoState.from_tensor( @@ -633,6 +636,11 @@ def get_rewards( - self.config.speed_distance_scale * torch.log(speed_error + 1.0) ) + + # Zero-out distance penalty for invalid time steps, that is, + # The reference positions have not been observed at every time step + # if not observed, we set the distance penalty to 0 + self.distance_penalty[~valid_mask] = 0.0 # Apply waypoint mask only if sampling interval is greater than 1 if self.config.waypoint_sample_interval > 1: From 03e8d2bad7064819c3f73d43979858b7c8d20eca Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 18 Apr 2025 10:19:21 -0400 Subject: [PATCH 55/81] More stable realism metrics by averaging over larger batches --- baselines/ppo/config/ppo_waypoint.yaml | 4 +- gpudrive/env/env_puffer.py | 72 +++++++++++++------------- gpudrive/integrations/puffer/ppo.py | 6 +-- 3 files changed, 40 insertions(+), 42 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 60486d8d0..997059467 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -63,7 +63,7 @@ train: # # # Data sampling # # # resample_scenes: false resample_dataset_size: 10_000 # Number of unique scenes to sample from - resample_interval: 5_000_000 + resample_interval: 1_000_000 sample_with_replacement: true shuffle_dataset: false @@ -87,7 +87,7 @@ train: target_kl: null # # # Logging # # # - log_window: 1000 + log_window: 500 track_realism_metrics: true # Log human-like metrics track_n_worlds: 2 # Number of worlds to track diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 86450f343..6a420a396 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -500,7 +500,7 @@ def step(self, action): # Flatten terminal = terminal[self.controlled_agent_mask] - info_lst = [] + self.info_lst = [] if len(done_worlds) > 0: if self.render: @@ -558,19 +558,19 @@ def step(self, action): if num_finished_agents > 0: # fmt: off - info_lst.append( + self.info_lst.append( { - "num_completed_episodes": len(done_worlds), - "mean_episode_reward_per_agent": agent_episode_returns.mean().item(), - "perc_goal_achieved": goal_achieved_rate.item(), - "perc_off_road": off_road_rate.item(), - "perc_veh_collisions": collision_rate.item(), - "total_controlled_agents": self.num_agents, - "control_density": self.num_agents / self.controlled_agent_mask.numel(), - "episode_length": self.episode_lengths[done_worlds, :].mean().item(), - "perc_truncated": num_truncated / num_finished_agents, - "mean_waypoint_distance": human_like_values.mean().item(), - "mean_internal_reward": internal_reward_values.mean().item(), + "metrics/mean_episode_reward_per_agent": agent_episode_returns.mean().item(), + "metrics/mean_waypoint_distance": human_like_values.mean().item(), + "metrics/mean_internal_reward": internal_reward_values.mean().item(), + "metrics/perc_goal_achieved": goal_achieved_rate.item(), + "metrics/perc_off_road": off_road_rate.item(), + "metrics/perc_veh_collisions": collision_rate.item(), + "metrics/perc_truncated": num_truncated / num_finished_agents, + "train/num_completed_episodes": len(done_worlds), + "train/total_controlled_agents": self.num_agents, + "train/control_density": self.num_agents / self.controlled_agent_mask.numel(), + "train/episode_length": self.episode_lengths[done_worlds, :].mean().item(), } ) # fmt: on @@ -616,7 +616,7 @@ def step(self, action): self.rewards, self.terminals, self.truncations, - info_lst, + self.info_lst, ) def render_env(self): @@ -835,26 +835,24 @@ def compute_realism_metrics(self, done_worlds): mean_angular_speed_error = masked_angular_speed_error.mean() mean_angular_accel_error = masked_angular_accel_error.mean() - if self.wandb_obj is not None: - self.wandb_obj.log( - { - "realism/kinematic_linear_speed_mae": mean_linear_speed_error, - "realism/kinematic_linear_accel_mae": mean_linear_accel_error, - "realism/kinematic_angular_speed_mae": mean_angular_speed_error, - "realism/kinematic_angular_accel_mae": mean_angular_accel_error, - "realism/mean_displacement_error": displacement_error.mean(), - "realism/kinematic_ref_linear_speed_dist": wandb.Histogram( - ref_linear_speed[speed_valid] - ), - "realism/kinematic_ref_linear_accel_dist": wandb.Histogram( - ref_linear_accel[accel_valid] - ), - "realism/kinematic_agent_linear_speed_dist": wandb.Histogram( - agent_linear_speed[speed_valid] - ), - "realism/kinematic_agent_linear_accel_dist": wandb.Histogram( - agent_linear_speed[accel_valid] - ), - }, - step=self.global_step, - ) + self.info_lst.append( + { + "realism/kinematic_linear_speed_mae": mean_linear_speed_error, + "realism/kinematic_linear_accel_mae": mean_linear_accel_error, + "realism/kinematic_angular_speed_mae": mean_angular_speed_error, + "realism/kinematic_angular_accel_mae": mean_angular_accel_error, + "realism/mean_displacement_error": displacement_error.mean(), + # "realism/kinematic_ref_linear_speed_dist": wandb.Histogram( + # ref_linear_speed[speed_valid] + # ), + # "realism/kinematic_ref_linear_accel_dist": wandb.Histogram( + # ref_linear_accel[accel_valid] + # ), + # "realism/kinematic_agent_linear_speed_dist": wandb.Histogram( + # agent_linear_speed[speed_valid] + # ), + # "realism/kinematic_agent_linear_accel_dist": wandb.Histogram( + # agent_linear_speed[accel_valid] + # ), + }, + ) diff --git a/gpudrive/integrations/puffer/ppo.py b/gpudrive/integrations/puffer/ppo.py index 4de2a0caf..1e85ae6fe 100644 --- a/gpudrive/integrations/puffer/ppo.py +++ b/gpudrive/integrations/puffer/ppo.py @@ -208,10 +208,10 @@ def evaluate(data): # Store the average across K done worlds across last N rollouts # ensure we are logging an unbiased estimate of the performance - if sum(data.infos["num_completed_episodes"]) > data.config.log_window: + if sum(data.infos["train/num_completed_episodes"]) > data.config.log_window: for k, v in data.infos.items(): try: - if "num_completed_episodes" in k: + if "train/num_completed_episodes" in k: data.stats[k] = np.sum(v) else: data.stats[k] = np.mean(v) @@ -397,7 +397,7 @@ def train(data): "train/advantages": data.wandb.Histogram(advantages_np), "train/advantages_var": np.var(advantages_np), "train/advantages_mean": np.mean(advantages_np), - **{f"metrics/{k}": v for k, v in data.stats.items()}, + **{f"{k}": v for k, v in data.stats.items()}, **{f"train/{k}": v for k, v in data.losses.items()}, } ) From 8f785fbe279e966496027391c10561e3a849730f Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 18 Apr 2025 10:50:17 -0400 Subject: [PATCH 56/81] Controll all agent types by default --- gpudrive/env/env_puffer.py | 2 +- gpudrive/integrations/puffer/ppo.py | 7 +++++-- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 6a420a396..70cab9faf 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -189,7 +189,7 @@ def __init__( goal_achieved_weight=1, dist_to_goal_threshold=2.0, polyline_reduction_threshold=0.1, - remove_non_vehicles=True, + remove_non_vehicles=False, obs_radius=50.0, use_vbd=False, vbd_model_path=None, diff --git a/gpudrive/integrations/puffer/ppo.py b/gpudrive/integrations/puffer/ppo.py index 1e85ae6fe..138750228 100644 --- a/gpudrive/integrations/puffer/ppo.py +++ b/gpudrive/integrations/puffer/ppo.py @@ -208,7 +208,10 @@ def evaluate(data): # Store the average across K done worlds across last N rollouts # ensure we are logging an unbiased estimate of the performance - if sum(data.infos["train/num_completed_episodes"]) > data.config.log_window: + if ( + sum(data.infos["train/num_completed_episodes"]) + > data.config.log_window + ): for k, v in data.infos.items(): try: if "train/num_completed_episodes" in k: @@ -218,7 +221,7 @@ def evaluate(data): # Log variance for goal and collision metrics if "goal" in k: - data.stats[f"std_{k}"] = np.std(v) + data.stats[f"{k}_std"] = np.std(v) except: continue From 298fbdb8d8e97303519778a1b760b6eba5c9fbc0 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 18 Apr 2025 16:51:32 -0400 Subject: [PATCH 57/81] Add option for jerk penalties --- gpudrive/env/config.py | 6 +++++ gpudrive/env/env_torch.py | 48 ++++++++++++++++++++++++++++++++------- 2 files changed, 46 insertions(+), 8 deletions(-) diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index 611f75202..e4f8b3f17 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -116,6 +116,12 @@ class EnvConfig: speed_distance_scale: float = ( 0.05 ) + accel_smoothness_scale: float = ( + 0.002 + ) + steering_smoothness_scale: float = ( + 0.002 + ) # If reward_type is "reward_conditioned", the following parameters are used # Weights for the reward components diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 063c76b9c..7118b8eb8 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -88,7 +88,7 @@ def __init__( self.max_agent_count, backend=self.backend, ) - + # Now initialize reward weights tensor if using reward_conditioned reward type if ( hasattr(self.config, "reward_type") @@ -122,6 +122,7 @@ def __init__( self._setup_action_space(action_type) self.single_action_space = self.action_space + self.previous_action_value_tensor = torch.zeros((self.num_worlds, self.max_cont_agents, 3), device=self.device) self.num_agents = self.cont_agent_mask.sum().item() @@ -433,6 +434,16 @@ def reset( ) self.world_time_steps.zero_() + + # Reset smoothness tracking for reset environments + if env_idx_list is not None: + reset_mask = torch.zeros(self.num_worlds, dtype=torch.bool, device=self.device) + reset_mask[torch.tensor(env_idx_list, device=self.device)] = True + + # Zero out only the reset environments + self.previous_action_value_tensor[reset_mask] = 0.0 + else: + self.previous_action_value_tensor.zero_() # Advance the simulator with log playback if warmup steps are provided if self.init_steps > 0: @@ -629,18 +640,32 @@ def get_rewards( dist_to_waypoints = torch.norm( gt_agent_pos - actual_agent_pos, dim=-1 ) + + # Penalty for jerky movements + if hasattr(self, 'action_diff'): + acceleration_jerk = self.action_diff[:, :, 0]**2 # First action component is acceleration + steering_jerk = self.action_diff[:, :, 1]**2 # Second action component is steering + + self.smoothness_penalty = -( + self.config.accel_smoothness_scale * acceleration_jerk + + self.config.steering_smoothness_scale * steering_jerk + ) + else: + self.smoothness_penalty = torch.zeros_like(self.base_rewards) self.distance_penalty = ( -self.config.waypoint_distance_scale * torch.log(dist_to_waypoints + 1.0) - self.config.speed_distance_scale * torch.log(speed_error + 1.0) - ) + ) # Zero-out distance penalty for invalid time steps, that is, # The reference positions have not been observed at every time step # if not observed, we set the distance penalty to 0 self.distance_penalty[~valid_mask] = 0.0 + + self.distance_penalty += self.smoothness_penalty # Apply waypoint mask only if sampling interval is greater than 1 if self.config.waypoint_sample_interval > 1: @@ -681,22 +706,29 @@ def _apply_actions(self, actions): actions = ( torch.nan_to_num(actions, nan=0).long().to(self.device) ) - action_value_tensor = self.action_keys_tensor[actions] + self.action_value_tensor = self.action_keys_tensor[actions] elif actions.dim() == 3: if actions.shape[2] == 1: actions = actions.squeeze(dim=2).to(self.device) - action_value_tensor = self.action_keys_tensor[actions] + self.action_value_tensor = self.action_keys_tensor[actions] else: # Assuming we are given the actual action values - action_value_tensor = actions.to(self.device) + self.action_value_tensor = actions.to(self.device) else: raise ValueError(f"Invalid action shape: {actions.shape}") else: - action_value_tensor = actions.to(self.device) + self.action_value_tensor = actions.to(self.device) + + if not hasattr(self, 'previous_action_value_tensor'): + # Initialize with current actions on first call + self.previous_action_value_tensor = self.action_value_tensor.clone() + + # Calculate action differences (jerk) + self.action_diff = self.action_value_tensor - self.previous_action_value_tensor + self.previous_action_value_tensor = self.action_value_tensor.clone() - # Feed the action values to gpudrive - self._copy_actions_to_simulator(action_value_tensor) + self._copy_actions_to_simulator(self.action_value_tensor) def _copy_actions_to_simulator(self, actions): """Copy the provided actions to the simulator.""" From ccc3ded17c1c13a4e58fd629837b4e62f208b0ac Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 18 Apr 2025 16:51:48 -0400 Subject: [PATCH 58/81] Add option for jerk penalties --- gpudrive/env/config.py | 12 ++------ gpudrive/env/env_torch.py | 60 ++++++++++++++++++++++++--------------- 2 files changed, 40 insertions(+), 32 deletions(-) diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index e4f8b3f17..b451d498b 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -113,15 +113,9 @@ class EnvConfig: waypoint_distance_scale: float = ( 0.05 # Importance of distance to waypoints ) - speed_distance_scale: float = ( - 0.05 - ) - accel_smoothness_scale: float = ( - 0.002 - ) - steering_smoothness_scale: float = ( - 0.002 - ) + speed_distance_scale: float = 0.05 + accel_smoothness_scale: float = 0.002 + steering_smoothness_scale: float = 0.002 # If reward_type is "reward_conditioned", the following parameters are used # Weights for the reward components diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 7118b8eb8..87d8176b4 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -88,7 +88,7 @@ def __init__( self.max_agent_count, backend=self.backend, ) - + # Now initialize reward weights tensor if using reward_conditioned reward type if ( hasattr(self.config, "reward_type") @@ -122,7 +122,9 @@ def __init__( self._setup_action_space(action_type) self.single_action_space = self.action_space - self.previous_action_value_tensor = torch.zeros((self.num_worlds, self.max_cont_agents, 3), device=self.device) + self.previous_action_value_tensor = torch.zeros( + (self.num_worlds, self.max_cont_agents, 3), device=self.device + ) self.num_agents = self.cont_agent_mask.sum().item() @@ -434,12 +436,14 @@ def reset( ) self.world_time_steps.zero_() - + # Reset smoothness tracking for reset environments if env_idx_list is not None: - reset_mask = torch.zeros(self.num_worlds, dtype=torch.bool, device=self.device) + reset_mask = torch.zeros( + self.num_worlds, dtype=torch.bool, device=self.device + ) reset_mask[torch.tensor(env_idx_list, device=self.device)] = True - + # Zero out only the reset environments self.previous_action_value_tensor[reset_mask] = 0.0 else: @@ -615,9 +619,11 @@ def get_rewards( gt_agent_speed = self.log_trajectory.ref_speed[ batch_indices, :, world_time_steps ] - valid_mask = self.log_trajectory.valids[ - batch_indices, :, world_time_steps - ].squeeze(-1).bool() + valid_mask = ( + self.log_trajectory.valids[batch_indices, :, world_time_steps] + .squeeze(-1) + .bool() + ) # Get actual agent positions agent_state = GlobalEgoState.from_tensor( @@ -640,15 +646,19 @@ def get_rewards( dist_to_waypoints = torch.norm( gt_agent_pos - actual_agent_pos, dim=-1 ) - + # Penalty for jerky movements - if hasattr(self, 'action_diff'): - acceleration_jerk = self.action_diff[:, :, 0]**2 # First action component is acceleration - steering_jerk = self.action_diff[:, :, 1]**2 # Second action component is steering - + if hasattr(self, "action_diff"): + acceleration_jerk = ( + self.action_diff[:, :, 0] ** 2 + ) # First action component is acceleration + steering_jerk = ( + self.action_diff[:, :, 1] ** 2 + ) # Second action component is steering + self.smoothness_penalty = -( - self.config.accel_smoothness_scale * acceleration_jerk + - self.config.steering_smoothness_scale * steering_jerk + self.config.accel_smoothness_scale * acceleration_jerk + + self.config.steering_smoothness_scale * steering_jerk ) else: self.smoothness_penalty = torch.zeros_like(self.base_rewards) @@ -658,13 +668,13 @@ def get_rewards( * torch.log(dist_to_waypoints + 1.0) - self.config.speed_distance_scale * torch.log(speed_error + 1.0) - ) - - # Zero-out distance penalty for invalid time steps, that is, + ) + + # Zero-out distance penalty for invalid time steps, that is, # The reference positions have not been observed at every time step # if not observed, we set the distance penalty to 0 self.distance_penalty[~valid_mask] = 0.0 - + self.distance_penalty += self.smoothness_penalty # Apply waypoint mask only if sampling interval is greater than 1 @@ -720,12 +730,16 @@ def _apply_actions(self, actions): else: self.action_value_tensor = actions.to(self.device) - if not hasattr(self, 'previous_action_value_tensor'): + if not hasattr(self, "previous_action_value_tensor"): # Initialize with current actions on first call - self.previous_action_value_tensor = self.action_value_tensor.clone() - + self.previous_action_value_tensor = ( + self.action_value_tensor.clone() + ) + # Calculate action differences (jerk) - self.action_diff = self.action_value_tensor - self.previous_action_value_tensor + self.action_diff = ( + self.action_value_tensor - self.previous_action_value_tensor + ) self.previous_action_value_tensor = self.action_value_tensor.clone() self._copy_actions_to_simulator(self.action_value_tensor) From 951712681cd6dc312c56376513295971677cf572 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 18 Apr 2025 20:16:14 -0400 Subject: [PATCH 59/81] Change: Agents cannot be terminated before end of episode length --- src/sim.cpp | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/sim.cpp b/src/sim.cpp index 49f11f0b8..1ee5f9d1d 100755 --- a/src/sim.cpp +++ b/src/sim.cpp @@ -627,16 +627,16 @@ inline void doneSystem(Engine &ctx, done.v = 1; } - // An agent can be done early if it reaches the goal - if (done.v != 1 || info.reachedGoal != 1) - { - float dist = (position.xy() - goal.position).length(); - if (dist < ctx.data().params.rewardParams.distanceToGoalThreshold) - { - done.v = 1; - info.reachedGoal = 1; - } - } + // // An agent can be done early if it reaches the goal + // if (done.v != 1 || info.reachedGoal != 1) + // { + // float dist = (position.xy() - goal.position).length(); + // if (dist < ctx.data().params.rewardParams.distanceToGoalThreshold) + // { + // done.v = 1; + // info.reachedGoal = 1; + // } + // } } From eeecb2cf640c95bb9a271f5367c299309aee266f Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 18 Apr 2025 20:16:54 -0400 Subject: [PATCH 60/81] Remove distance to last expert position from ego state --- gpudrive/env/env_torch.py | 29 +++++++++++++++++++---------- 1 file changed, 19 insertions(+), 10 deletions(-) diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 87d8176b4..fd4612295 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -875,8 +875,6 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: ego_state.speed.unsqueeze(-1), ego_state.vehicle_length.unsqueeze(-1), ego_state.vehicle_width.unsqueeze(-1), - ego_state.rel_goal_x.unsqueeze(-1), - ego_state.rel_goal_y.unsqueeze(-1), ego_state.is_collided.unsqueeze(-1), ] @@ -917,8 +915,10 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: device=self.device, ) + self.local_reference_xy = local_reference_xy + # Normalize - local_reference_xy /= constants.MAX_REF_POINT + # local_reference_xy /= constants.MAX_REF_POINT batch_size = local_reference_xy.shape[0] num_points = local_reference_xy.shape[1] @@ -938,9 +938,9 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: ).bool() # Apply dropout mask - self.local_reference_xy = ( - local_reference_xy * point_dropout_mask - ) + # self.local_reference_xy = ( + # local_reference_xy * point_dropout_mask + # ) # Flatten the dimensions for stacking base_fields.append( @@ -1002,8 +1002,10 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: device=self.device, ) + self.local_reference_xy = local_reference_xy + # Normalize to [-1, 1] - local_reference_xy /= constants.MAX_REF_POINT + # local_reference_xy /= constants.MAX_REF_POINT point_dropout_mask = torch.bernoulli( torch.ones( @@ -1732,7 +1734,7 @@ def get_scenario_ids(self): config=env_config, data_loader=train_loader, max_cont_agents=64, # Number of agents to control - device="cuda", + device="cpu", ) control_mask = env.cont_agent_mask @@ -1747,7 +1749,7 @@ def get_scenario_ids(self): env_idx = 0 - for t in range(10): + for t in range(91): print(f"Step: {t}") # Step the environment @@ -1755,9 +1757,13 @@ def get_scenario_ids(self): env.step_dynamics(expert_actions[:, :, t, :]) highlight_agent = torch.where(env.cont_agent_mask[env_idx, :])[0][ - -1 + 0 ].item() + print( + f"is_valid: {env.log_trajectory.valids[env_idx, highlight_agent, t, :]}" + ) + # Make video sim_states = env.vis.plot_simulator_state( env_indices=[env_idx], @@ -1771,6 +1777,7 @@ def get_scenario_ids(self): env_idx=env_idx, agent_idx=highlight_agent, figsize=(10, 10), + trajectory=env.local_reference_xy[0, 0].to(env.device), ) sim_frames.append(img_from_fig(sim_states[0])) @@ -1788,6 +1795,8 @@ def get_scenario_ids(self): done = env.get_dones() info = env.get_infos() + print(done[env.cont_agent_mask]) + if done.all().bool(): break From 180fe76a80b6f3945fec11b7a538cc3f261394b9 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 18 Apr 2025 20:17:16 -0400 Subject: [PATCH 61/81] Update number of ego state constants accordingly --- gpudrive/env/constants.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gpudrive/env/constants.py b/gpudrive/env/constants.py index 3a509d3f5..c096ae89b 100644 --- a/gpudrive/env/constants.py +++ b/gpudrive/env/constants.py @@ -22,7 +22,7 @@ MAX_ROAD_SCALE = 100 # Feature shape constants -EGO_FEAT_DIM = 6 # Ego state base fields +EGO_FEAT_DIM = 4 # Ego state base fields PARTNER_FEAT_DIM = 6 ROAD_GRAPH_FEAT_DIM = 13 From 0da58ffd2c32200aa11a9467283ef5c42deb7011 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 18 Apr 2025 20:18:05 -0400 Subject: [PATCH 62/81] Update visualizer to match new conditions --- gpudrive/env/config.py | 6 ++-- gpudrive/visualize/core.py | 73 +++++++++++++++++++------------------- 2 files changed, 40 insertions(+), 39 deletions(-) diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index b451d498b..9dff05c5f 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -113,9 +113,9 @@ class EnvConfig: waypoint_distance_scale: float = ( 0.05 # Importance of distance to waypoints ) - speed_distance_scale: float = 0.05 - accel_smoothness_scale: float = 0.002 - steering_smoothness_scale: float = 0.002 + speed_distance_scale: float = 0.0 + accel_smoothness_scale: float = 0.00 + steering_smoothness_scale: float = 0.00 # If reward_type is "reward_conditioned", the following parameters are used # Weights for the reward components diff --git a/gpudrive/visualize/core.py b/gpudrive/visualize/core.py index 8bc11da83..2829c7ff7 100644 --- a/gpudrive/visualize/core.py +++ b/gpudrive/visualize/core.py @@ -1666,40 +1666,41 @@ def plot_agent_observation( 0, # Arrow points to the right, proportional to speed head_width=1.0, head_length=1.1, - fc=REL_OBS_OBJ_COLORS["ego"], - ec=REL_OBS_OBJ_COLORS["ego"], + fc="k", + ec="k", + zorder=1, ) - ax.scatter( - observation_ego.rel_goal_x[env_idx, agent_idx], - observation_ego.rel_goal_y[env_idx, agent_idx], - s=5, - linewidth=1.5, - c=ego_agent_color, - marker="x", - ) - - circle = Circle( - ( - observation_ego.rel_goal_x[env_idx, agent_idx], - observation_ego.rel_goal_y[env_idx, agent_idx], - ), - radius=self.goal_radius, - color=ego_agent_color, - fill=False, - linestyle="--", - ) - ax.add_patch(circle) - - observation_radius = Circle( - (0, 0), - radius=self.env_config.obs_radius, - color="#000000", - linewidth=0.8, - fill=False, - linestyle="-", - ) - ax.add_patch(observation_radius) + # ax.scatter( + # observation_ego.rel_goal_x[env_idx, agent_idx], + # observation_ego.rel_goal_y[env_idx, agent_idx], + # s=5, + # linewidth=1.5, + # c=ego_agent_color, + # marker="x", + # ) + + # circle = Circle( + # ( + # observation_ego.rel_goal_x[env_idx, agent_idx], + # observation_ego.rel_goal_y[env_idx, agent_idx], + # ), + # radius=self.goal_radius, + # color=ego_agent_color, + # fill=False, + # linestyle="--", + # ) + # ax.add_patch(circle) + + # observation_radius = Circle( + # (0, 0), + # radius=self.env_config.obs_radius, + # color="#000000", + # linewidth=0.8, + # fill=False, + # linestyle="-", + # ) + # ax.add_patch(observation_radius) plt.axis("off") if trajectory is not None and len(trajectory) > 0: @@ -1707,10 +1708,10 @@ def plot_agent_observation( ax.scatter( trajectory[:, 0], # x coordinates trajectory[:, 1], # y coordinates - color="lightgreen", - linewidth=0.35, - marker="o", # circular markers at each point - alpha=0.8, # slight transparency + color="g", + linewidth=0.3, + marker="o", + alpha=0.2, zorder=0, ) From 56032d28fb76b3f3141f645fe58fed97681675a3 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 18 Apr 2025 21:23:15 -0400 Subject: [PATCH 63/81] Batch global -> local reference frame transformation --- baselines/ppo/config/ppo_waypoint.yaml | 17 ++-- gpudrive/env/env_torch.py | 118 ++++++++++++++----------- gpudrive/networks/agents.py | 1 + 3 files changed, 76 insertions(+), 60 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 997059467..2a2a2af7f 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -2,19 +2,20 @@ mode: "train" use_rnn: false eval_model_path: null baseline: false -data_dir: data/processed/examples +data_dir: data/processed/training continue_training: false model_cpt: null environment: # Overrides default environment configs (see pygpudrive/env/config.py) name: "gpudrive" num_worlds: 100 # Number of parallel environments - k_unique_scenes: 4 # Number of unique scenes to sample from + k_unique_scenes: 100 # Number of unique scenes to sample from max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp ego_state: true road_map_obs: true partner_obs: true norm_obs: true + remove_non_vehicles: false collision_behavior: "ignore" goal_behavior: "stop" reward_type: "follow_waypoints" @@ -40,14 +41,14 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. vbd_in_obs: false # Planning guidance - add_reference_path: false # If true, the goal state is added to the ego observation + add_reference_path: true # If true, the goal state is added to the ego observation add_reference_speed: true # If true, the reference speed is added to the ego observation prob_reference_dropout: 0.0 # Value between 0 and 1, probability of a reference point to be zeroed out wandb: entity: "" - project: "humanlike" - group: "tinyexps" + project: "human_like" + group: "full_ref_path" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] @@ -65,7 +66,7 @@ train: resample_dataset_size: 10_000 # Number of unique scenes to sample from resample_interval: 1_000_000 sample_with_replacement: true - shuffle_dataset: false + shuffle_dataset: true # # # PPO # # # torch_deterministic: false @@ -105,8 +106,8 @@ train: # # # Rendering # # # render: false # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d - render_interval: 100 # Render every k iterations - render_k_scenarios: 2 # Number of scenarios to render + render_interval: 50 # Render every k iterations + render_k_scenarios: 1 # Number of scenarios to render render_format: "mp4" # Options: gif, mp4 render_fps: 20 # Frames per second zoom_radius: 100 diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index fd4612295..bfc7c6c8a 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -915,27 +915,27 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: device=self.device, ) - self.local_reference_xy = local_reference_xy + self.local_reference_xy = local_reference_xy.clone() # Normalize - # local_reference_xy /= constants.MAX_REF_POINT + local_reference_xy /= constants.MAX_REF_POINT - batch_size = local_reference_xy.shape[0] - num_points = local_reference_xy.shape[1] - time_steps = local_reference_xy.shape[2] + # batch_size = local_reference_xy.shape[0] + # num_points = local_reference_xy.shape[1] + # time_steps = local_reference_xy.shape[2] # Create dropout mask for the time dimension # Shape: [batch_size, num_points, time_steps, 1] - point_dropout_mask = torch.bernoulli( - torch.ones( - batch_size, - num_points, - time_steps, - 1, - device=local_reference_xy.device, - ) - * (1 - self.config.prob_reference_dropout) - ).bool() + # point_dropout_mask = torch.bernoulli( + # torch.ones( + # batch_size, + # num_points, + # time_steps, + # 1, + # device=local_reference_xy.device, + # ) + # * (1 - self.config.prob_reference_dropout) + # ).bool() # Apply dropout mask # self.local_reference_xy = ( @@ -943,9 +943,7 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: # ) # Flatten the dimensions for stacking - base_fields.append( - self.local_reference_xy.flatten(start_dim=2) - ) + base_fields.append(local_reference_xy.flatten(start_dim=2)) if self.config.reward_type == "reward_conditioned": @@ -979,51 +977,65 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: base_fields.append(avg_ref_speed.unsqueeze(-1)) if self.config.add_reference_path: - - # Shape: [batch, 91, 2] glob_ego_states = ( self.sim.absolute_self_observation_tensor() .to_torch() .clone()[mask] ) - glob_ego_pos_xy = glob_ego_states[:, :2] - glob_ego_yaw = glob_ego_states[:, 7] - glob_reference_xy = self.log_trajectory.pos_xy[mask] + glob_ego_pos_xy = glob_ego_states[:, :2] # Shape: [batch, 2] + glob_ego_yaw = glob_ego_states[:, 7] # Shape: [batch] + glob_reference_xy = self.log_trajectory.pos_xy[ + mask + ] # Shape: [batch, 91, 2] + batch_size = glob_ego_states.shape[0] + + # Translate all points at once by broadcasting subtraction + # Reshape ego positions for broadcasting: [batch, 1, 2] + ego_pos_expanded = glob_ego_pos_xy.unsqueeze(1) + translated = glob_reference_xy - ego_pos_expanded + + # Create rotation matrices for all agents at once + cos_yaw = torch.cos(glob_ego_yaw).to( + self.device + ) # Shape: [batch] + sin_yaw = torch.sin(glob_ego_yaw).to( + self.device + ) # Shape: [batch] - local_reference_xy = torch.empty_like(glob_reference_xy) - batch_size = local_reference_xy.shape[0] - num_points = local_reference_xy.shape[1] - - for agent_idx in range(batch_size): - local_reference_xy[agent_idx, :, :] = to_local_frame( - global_pos_xy=glob_reference_xy[agent_idx, :, :], - ego_pos=glob_ego_pos_xy[agent_idx], - ego_yaw=glob_ego_yaw[agent_idx], - device=self.device, - ) + # Create batch of rotation matrices: [batch, 2, 2] + rotation_matrices = torch.stack( + [ + torch.stack([cos_yaw, sin_yaw], dim=1), + torch.stack([-sin_yaw, cos_yaw], dim=1), + ], + dim=1, + ) # Shape: [batch, 2, 2] + + # Apply rotation to all points + local_reference_xy = torch.bmm( + rotation_matrices, translated.transpose(1, 2) + ).transpose(1, 2) - self.local_reference_xy = local_reference_xy + self.local_reference_xy = local_reference_xy.clone() # Normalize to [-1, 1] - # local_reference_xy /= constants.MAX_REF_POINT + local_reference_xy /= constants.MAX_REF_POINT - point_dropout_mask = torch.bernoulli( - torch.ones( - (batch_size, num_points), - device=local_reference_xy.device, - ) - * (1 - self.config.prob_reference_dropout) - ).bool() + # point_dropout_mask = torch.bernoulli( + # torch.ones( + # (batch_size, num_points), + # device=local_reference_xy.device, + # ) + # * (1 - self.config.prob_reference_dropout) + # ).bool() # Dropout fraction of points in the reference path - self.local_reference_xy = ( - local_reference_xy * point_dropout_mask.unsqueeze(2) - ) + # self.local_reference_xy = ( + # local_reference_xy * point_dropout_mask.unsqueeze(2) + # ) # Stack - base_fields.append( - self.local_reference_xy.view(batch_size, -1) - ) + base_fields.append(local_reference_xy.flatten(start_dim=1)) if self.config.reward_type == "reward_conditioned": # For masked agents, we need to extract agent indices from the mask @@ -1740,7 +1752,7 @@ def get_scenario_ids(self): control_mask = env.cont_agent_mask # Rollout - obs = env.reset() + obs = env.reset(control_mask) sim_frames = [] agent_obs_frames = [] @@ -1777,7 +1789,9 @@ def get_scenario_ids(self): env_idx=env_idx, agent_idx=highlight_agent, figsize=(10, 10), - trajectory=env.local_reference_xy[0, 0].to(env.device), + trajectory=env.local_reference_xy[highlight_agent, :, :].to( + env.device + ), ) sim_frames.append(img_from_fig(sim_states[0])) @@ -1787,7 +1801,7 @@ def get_scenario_ids(self): torch.Tensor([t]).repeat((1, env.num_worlds)).long().to(env.device) ) - obs = env.get_obs() + obs = env.get_obs(control_mask) reward = env.get_rewards(world_time_steps=world_time_steps) print(f"Reward: {reward[:, env_idx, highlight_agent]}") diff --git a/gpudrive/networks/agents.py b/gpudrive/networks/agents.py index f0fcd0c94..6fff80144 100644 --- a/gpudrive/networks/agents.py +++ b/gpudrive/networks/agents.py @@ -49,6 +49,7 @@ def __init__( if self.config[ "add_reference_path" ]: # Every agent receives a reference path + # NOTE: Hardcoded to 91 for now self.ego_state_idx += 91 * 2 if self.config["add_reference_speed"]: From 2eccb0ade604f8ea9cd814d8c04a1e0b9444229f Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Fri, 18 Apr 2025 21:38:41 -0400 Subject: [PATCH 64/81] typo --- gpudrive/integrations/puffer/ppo.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/gpudrive/integrations/puffer/ppo.py b/gpudrive/integrations/puffer/ppo.py index 138750228..9c4eb41f5 100644 --- a/gpudrive/integrations/puffer/ppo.py +++ b/gpudrive/integrations/puffer/ppo.py @@ -401,13 +401,13 @@ def train(data): "train/advantages_var": np.var(advantages_np), "train/advantages_mean": np.mean(advantages_np), **{f"{k}": v for k, v in data.stats.items()}, - **{f"train/{k}": v for k, v in data.losses.items()}, + **{f"{k}": v for k, v in data.losses.items()}, } ) if bool(data.stats): data.wandb.log({ - **{f"metrics/{k}": v for k, v in data.stats.items()}, + **{f"{k}": v for k, v in data.stats.items()}, }) # fmt: on From 1f0c2b9f672c633d881d05506ee8b1a5c3c369c5 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Sat, 19 Apr 2025 11:10:15 -0400 Subject: [PATCH 65/81] Minor logging fix --- gpudrive/integrations/puffer/ppo.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gpudrive/integrations/puffer/ppo.py b/gpudrive/integrations/puffer/ppo.py index 9c4eb41f5..fa5a961fd 100644 --- a/gpudrive/integrations/puffer/ppo.py +++ b/gpudrive/integrations/puffer/ppo.py @@ -401,7 +401,7 @@ def train(data): "train/advantages_var": np.var(advantages_np), "train/advantages_mean": np.mean(advantages_np), **{f"{k}": v for k, v in data.stats.items()}, - **{f"{k}": v for k, v in data.losses.items()}, + **{f"train/{k}": v for k, v in data.losses.items()}, } ) From 7266b5d1324228614c38a58d8f0ba9b190ed095d Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Sat, 19 Apr 2025 11:10:38 -0400 Subject: [PATCH 66/81] New defaults --- baselines/ppo/config/ppo_waypoint.yaml | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 2a2a2af7f..08caea939 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -20,15 +20,16 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. goal_behavior: "stop" reward_type: "follow_waypoints" waypoint_distance_scale: 0.05 - speed_distance_scale: 0.0 + speed_distance_scale: 0.01 + jerk_smoothness_scale: 0.01 init_mode: all_non_trivial #womd_tracks_to_predict dynamics_model: "classic" polyline_reduction_threshold: 0.1 # Rate at which to sample points from the polyline (0 is use all closest points, 1 maximum sparsity), needs to be balanced with kMaxAgentMapObservationsCount sampling_seed: 42 # If given, the set of scenes to sample from will be deterministic, if None, the set of scenes will be random obs_radius: 50.0 # Visibility radius of the agents - action_space_steer_disc: 13 - action_space_accel_disc: 7 + action_space_steer_disc: 15 + action_space_accel_disc: 11 init_steps: 0 # Warmup steps goal_achieved_weight: 0.0 collision_weight: -0.2 @@ -48,7 +49,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. wandb: entity: "" project: "human_like" - group: "full_ref_path" + group: "full_ref_path_and_avg_speed_mini" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] @@ -90,7 +91,7 @@ train: # # # Logging # # # log_window: 500 track_realism_metrics: true # Log human-like metrics - track_n_worlds: 2 # Number of worlds to track + track_n_worlds: 3 # Number of worlds to track # # # Network # # # network: @@ -106,7 +107,7 @@ train: # # # Rendering # # # render: false # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d - render_interval: 50 # Render every k iterations + render_interval: 100 # Render every k iterations render_k_scenarios: 1 # Number of scenarios to render render_format: "mp4" # Options: gif, mp4 render_fps: 20 # Frames per second From 325432d3c91a78bbfd167a071a2c46e16cd0efdc Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Sat, 19 Apr 2025 11:10:57 -0400 Subject: [PATCH 67/81] Replace jerk with single param --- gpudrive/env/config.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index 9dff05c5f..09b766d69 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -114,8 +114,7 @@ class EnvConfig: 0.05 # Importance of distance to waypoints ) speed_distance_scale: float = 0.0 - accel_smoothness_scale: float = 0.00 - steering_smoothness_scale: float = 0.00 + jerk_smoothness_scale: float = 0.0 # If reward_type is "reward_conditioned", the following parameters are used # Weights for the reward components From 012a547677d8ef05b7b87fed0c5b416f2bc8306d Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Sat, 19 Apr 2025 11:11:47 -0400 Subject: [PATCH 68/81] Condition on previous action if present --- gpudrive/env/constants.py | 5 ++++- gpudrive/env/env_puffer.py | 10 +++++++--- gpudrive/env/env_torch.py | 23 ++++++++++++++++------- 3 files changed, 27 insertions(+), 11 deletions(-) diff --git a/gpudrive/env/constants.py b/gpudrive/env/constants.py index c096ae89b..3934d1ff6 100644 --- a/gpudrive/env/constants.py +++ b/gpudrive/env/constants.py @@ -22,7 +22,7 @@ MAX_ROAD_SCALE = 100 # Feature shape constants -EGO_FEAT_DIM = 4 # Ego state base fields +EGO_FEAT_DIM = 6 # Ego state base fields PARTNER_FEAT_DIM = 6 ROAD_GRAPH_FEAT_DIM = 13 @@ -32,3 +32,6 @@ # BEV observation constants BEV_RASTERIZATION_RESOLUTION = 200 NUM_MADRONA_ENTITY_TYPES = 11 + +# Action values +MAX_ACTION_VALUE = 4.0 diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 70cab9faf..f50ae4964 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -180,6 +180,7 @@ def __init__( reward_type="weighted_combination", waypoint_distance_scale=0.05, speed_distance_scale=0.0, + jerk_smoothness_scale=0.0, condition_mode="random", collision_behavior="ignore", goal_behavior="remove", @@ -263,6 +264,7 @@ def __init__( reward_type=reward_type, waypoint_distance_scale=waypoint_distance_scale, speed_distance_scale=speed_distance_scale, + jerk_smoothness_scale=jerk_smoothness_scale, condition_mode=condition_mode, norm_obs=norm_obs, bev_obs=bev_obs, @@ -561,7 +563,7 @@ def step(self, action): self.info_lst.append( { "metrics/mean_episode_reward_per_agent": agent_episode_returns.mean().item(), - "metrics/mean_waypoint_distance": human_like_values.mean().item(), + "metrics/mean_imitation_distance": human_like_values.mean().item(), "metrics/mean_internal_reward": internal_reward_values.mean().item(), "metrics/perc_goal_achieved": goal_achieved_rate.item(), "metrics/perc_off_road": off_road_rate.item(), @@ -749,7 +751,7 @@ def compute_realism_metrics(self, done_worlds): .cpu() .numpy()[control_mask] .squeeze(-1) - ) + ).astype(bool) # Take human logs (ground-truth) # Shape: [worlds, max_cont_agents, time, 2] -> [batch, time, 2] @@ -841,7 +843,9 @@ def compute_realism_metrics(self, done_worlds): "realism/kinematic_linear_accel_mae": mean_linear_accel_error, "realism/kinematic_angular_speed_mae": mean_angular_speed_error, "realism/kinematic_angular_accel_mae": mean_angular_accel_error, - "realism/mean_displacement_error": displacement_error.mean(), + "realism/mean_displacement_error": displacement_error[ + valid_mask + ].mean(), # "realism/kinematic_ref_linear_speed_dist": wandb.Histogram( # ref_linear_speed[speed_valid] # ), diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index bfc7c6c8a..3dcfdaf66 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -101,6 +101,10 @@ def __init__( condition_mode=condition_mode, agent_type=self.agent_type ) + self.previous_action_value_tensor = torch.zeros( + (self.num_worlds, self.max_cont_agents, 3), device=self.device + ) + self.episode_len = self.config.episode_len # Initialize VBD model if used @@ -122,10 +126,6 @@ def __init__( self._setup_action_space(action_type) self.single_action_space = self.action_space - self.previous_action_value_tensor = torch.zeros( - (self.num_worlds, self.max_cont_agents, 3), device=self.device - ) - self.num_agents = self.cont_agent_mask.sum().item() # Rendering setup @@ -657,8 +657,8 @@ def get_rewards( ) # Second action component is steering self.smoothness_penalty = -( - self.config.accel_smoothness_scale * acceleration_jerk - + self.config.steering_smoothness_scale * steering_jerk + self.config.jerk_smoothness_scale * acceleration_jerk + + self.config.jerk_smoothness_scale * steering_jerk ) else: self.smoothness_penalty = torch.zeros_like(self.base_rewards) @@ -880,6 +880,11 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: if mask is None: + base_fields.append( + self.previous_action_value_tensor[:, :, :2] + / constants.MAX_ACTION_VALUE, # Previous accel, steering + ) + if self.config.add_reference_speed: avg_ref_speed = ( self.log_trajectory.ref_speed.mean(axis=-1) @@ -969,6 +974,11 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: return torch.cat(base_fields, dim=-1) else: + base_fields.append( + self.previous_action_value_tensor[mask][:, :2] + / constants.MAX_ACTION_VALUE, # Previous accel, steering + ) + if self.config.add_reference_speed: avg_ref_speed = ( self.log_trajectory.ref_speed[mask].mean(axis=-1) @@ -987,7 +997,6 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: glob_reference_xy = self.log_trajectory.pos_xy[ mask ] # Shape: [batch, 91, 2] - batch_size = glob_ego_states.shape[0] # Translate all points at once by broadcasting subtraction # Reshape ego positions for broadcasting: [batch, 1, 2] From 8bac16f5f2001efdf68e6cb33c16dbce2aff0753 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Sat, 19 Apr 2025 11:14:20 -0400 Subject: [PATCH 69/81] Name change --- baselines/ppo/config/ppo_waypoint.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 08caea939..4d243d65a 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -48,7 +48,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. wandb: entity: "" - project: "human_like" + project: "humanlike" group: "full_ref_path_and_avg_speed_mini" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] @@ -105,10 +105,10 @@ train: checkpoint_path: "./runs" # # # Rendering # # # - render: false # Determines whether to render the environment (note: will slow down training) + render: true # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d render_interval: 100 # Render every k iterations - render_k_scenarios: 1 # Number of scenarios to render + render_k_scenarios: 3 # Number of scenarios to render render_format: "mp4" # Options: gif, mp4 render_fps: 20 # Frames per second zoom_radius: 100 From 670d22198e5b4d22d5687a8ced2744889b9641e3 Mon Sep 17 00:00:00 2001 From: daphnecor Date: Sat, 19 Apr 2025 11:53:47 -0400 Subject: [PATCH 70/81] Faster resets --- baselines/ppo/ppo_waypoint.py | 4 ++++ gpudrive/env/env_puffer.py | 5 ++++- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/baselines/ppo/ppo_waypoint.py b/baselines/ppo/ppo_waypoint.py index 9ec193fec..046c45477 100644 --- a/baselines/ppo/ppo_waypoint.py +++ b/baselines/ppo/ppo_waypoint.py @@ -117,6 +117,8 @@ def run( off_road_weight: Annotated[Optional[float], typer.Option(help="The weight for off-road penalty")] = None, goal_achieved_weight: Annotated[Optional[float], typer.Option(help="The weight for goal-achieved reward")] = None, waypoint_distance_scale: Annotated[Optional[float], typer.Option(help="Scale for realism rewards")] = None, + speed_distance_scale: Annotated[Optional[float], typer.Option(help="Scale for realism rewards")] = None, + jerk_smoothness_scale: Annotated[Optional[float], typer.Option(help="Scale for realism rewards")] = None, dist_to_goal_threshold: Annotated[Optional[float], typer.Option(help="The distance threshold for goal-achieved")] = None, randomize_rewards: Annotated[Optional[int], typer.Option(help="If reward_type == reward_conditioned, choose the condition_mode; 0 or 1")] = 0, sampling_seed: Annotated[Optional[int], typer.Option(help="The seed for sampling scenes")] = None, @@ -174,6 +176,8 @@ def run( "off_road_weight": off_road_weight, "goal_achieved_weight": goal_achieved_weight, "waypoint_distance_scale": waypoint_distance_scale, + "jerk_smoothness_scale": jerk_smoothness_scale, + "speed_distance_scale": speed_distance_scale, "dist_to_goal_threshold": dist_to_goal_threshold, "sampling_seed": sampling_seed, "obs_radius": obs_radius, diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index f50ae4964..a53ca6985 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -581,7 +581,10 @@ def step(self, action): self.last_obs = self.env.get_obs(self.controlled_agent_mask) # Asynchronously reset the done worlds and empty storage - self.env.reset(env_idx_list=done_worlds_cpu) + self.env.reset( + env_idx_list=done_worlds_cpu, + mask=self.controlled_agent_mask + ) self.episode_returns[done_worlds] = 0 self.agent_episode_returns[done_worlds, :] = 0 self.episode_lengths[done_worlds, :] = 0 From da8a00196d487a8bf4b07e99c350dbe8602ef680 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Mon, 21 Apr 2025 11:50:47 -0400 Subject: [PATCH 71/81] Cleanup --- .gitignore | 2 ++ baselines/ppo/config/ppo_base_puffer.yaml | 6 +++--- baselines/ppo/config/ppo_waypoint.yaml | 19 ++++++++++--------- baselines/ppo/ppo_waypoint.py | 1 + .../experimental/config/model_config.yaml | 2 +- .../kshot/analyze_compatibility.py | 0 gpudrive/env/config.py | 2 +- gpudrive/env/env_puffer.py | 2 +- 8 files changed, 19 insertions(+), 15 deletions(-) delete mode 100644 examples/experimental/kshot/analyze_compatibility.py diff --git a/.gitignore b/.gitignore index 7052a3915..9643d59e8 100644 --- a/.gitignore +++ b/.gitignore @@ -30,6 +30,8 @@ data/processed/testing/* data/processed/pop_play/* data/processed/hand_designed/* analyze/figures/* +data/other/* +wosac/ # Logging /wandb diff --git a/baselines/ppo/config/ppo_base_puffer.yaml b/baselines/ppo/config/ppo_base_puffer.yaml index ab942aa55..a170646f9 100644 --- a/baselines/ppo/config/ppo_base_puffer.yaml +++ b/baselines/ppo/config/ppo_base_puffer.yaml @@ -15,7 +15,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. road_map_obs: true partner_obs: true norm_obs: true - add_reference_path: false # If true, the goal state is added to the ego observation + add_reference_path: false remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists) lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types reward_type: "reward_conditioned" # Options: "weighted_combination", "reward_conditioned" @@ -51,8 +51,8 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. wandb: entity: "" - project: "kshotagents" - group: "reward_conditioned" + project: "gpudrive" + group: "" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 4d243d65a..1fe3c5675 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -2,7 +2,7 @@ mode: "train" use_rnn: false eval_model_path: null baseline: false -data_dir: data/processed/training +data_dir: data/processed/wosac/validation_json_100 continue_training: false model_cpt: null @@ -19,7 +19,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. collision_behavior: "ignore" goal_behavior: "stop" reward_type: "follow_waypoints" - waypoint_distance_scale: 0.05 + waypoint_distance_scale: 0.01 speed_distance_scale: 0.01 jerk_smoothness_scale: 0.01 @@ -42,14 +42,14 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. vbd_in_obs: false # Planning guidance - add_reference_path: true # If true, the goal state is added to the ego observation - add_reference_speed: true # If true, the reference speed is added to the ego observation + add_reference_path: true # If true, a reference path is added to the ego observation + add_reference_speed: true # If true, the reference speed (scalar) is added to the ego observation prob_reference_dropout: 0.0 # Value between 0 and 1, probability of a reference point to be zeroed out wandb: entity: "" project: "humanlike" - group: "full_ref_path_and_avg_speed_mini" + group: "wosac_test_mini" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] @@ -64,10 +64,11 @@ train: # # # Data sampling # # # resample_scenes: false - resample_dataset_size: 10_000 # Number of unique scenes to sample from - resample_interval: 1_000_000 + resample_dataset_size: 500 # Number of unique scenes to sample from + resample_interval: 2_000_000 sample_with_replacement: true shuffle_dataset: true + file_prefix: "" # # # PPO # # # torch_deterministic: false @@ -101,14 +102,14 @@ train: num_parameters: 0 # Total trainable parameters, to be filled at runtime # # # Checkpointing # # # - checkpoint_interval: 250 # Save policy every k iterations + checkpoint_interval: 500 # Save policy every k iterations checkpoint_path: "./runs" # # # Rendering # # # render: true # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d render_interval: 100 # Render every k iterations - render_k_scenarios: 3 # Number of scenarios to render + render_k_scenarios: 2 # Number of scenarios to render render_format: "mp4" # Options: gif, mp4 render_fps: 20 # Frames per second zoom_radius: 100 diff --git a/baselines/ppo/ppo_waypoint.py b/baselines/ppo/ppo_waypoint.py index 046c45477..621055635 100644 --- a/baselines/ppo/ppo_waypoint.py +++ b/baselines/ppo/ppo_waypoint.py @@ -256,6 +256,7 @@ def run( else config.environment.k_unique_scenes, sample_with_replacement=config.train.sample_with_replacement, shuffle=config.train.shuffle_dataset, + file_prefix=config.train.file_prefix, ) # Make environment diff --git a/examples/experimental/config/model_config.yaml b/examples/experimental/config/model_config.yaml index e8241b570..0f23a2432 100644 --- a/examples/experimental/config/model_config.yaml +++ b/examples/experimental/config/model_config.yaml @@ -2,6 +2,6 @@ models_path: examples/experimental/models models: - name: model_PPO____R_10000__02_27_09_19_10_626_003200 - train_dataset_size: 10000 + train_dataset_size: 10_000 wandb: null trained_on: null \ No newline at end of file diff --git a/examples/experimental/kshot/analyze_compatibility.py b/examples/experimental/kshot/analyze_compatibility.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index 09b766d69..a645292df 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -111,7 +111,7 @@ class EnvConfig: # If reward_type is "follow_waypoints", the following parameters are used waypoint_sample_interval: int = 1 # Interval for sampling waypoints waypoint_distance_scale: float = ( - 0.05 # Importance of distance to waypoints + 0.01 # Importance of distance to waypoints ) speed_distance_scale: float = 0.0 jerk_smoothness_scale: float = 0.0 diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index a53ca6985..d2f37b0c8 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -567,7 +567,7 @@ def step(self, action): "metrics/mean_internal_reward": internal_reward_values.mean().item(), "metrics/perc_goal_achieved": goal_achieved_rate.item(), "metrics/perc_off_road": off_road_rate.item(), - "metrics/perc_veh_collisions": collision_rate.item(), + "metrics/perc_collisions": collision_rate.item(), "metrics/perc_truncated": num_truncated / num_finished_agents, "train/num_completed_episodes": len(done_worlds), "train/total_controlled_agents": self.num_agents, From 685d95f314732ce4b3fc8ab70a3da56cf8e043d5 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Mon, 21 Apr 2025 12:49:25 -0400 Subject: [PATCH 72/81] Integrate fb --- baselines/ppo/config/ppo_base_puffer.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/baselines/ppo/config/ppo_base_puffer.yaml b/baselines/ppo/config/ppo_base_puffer.yaml index a170646f9..638346d93 100644 --- a/baselines/ppo/config/ppo_base_puffer.yaml +++ b/baselines/ppo/config/ppo_base_puffer.yaml @@ -15,10 +15,10 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. road_map_obs: true partner_obs: true norm_obs: true - add_reference_path: false + add_reference_path: false remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists) lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types - reward_type: "reward_conditioned" # Options: "weighted_combination", "reward_conditioned" + reward_type: "weighted_combination" # Options: "weighted_combination", "reward_conditioned" collision_weight: -0.75 off_road_weight: -0.75 goal_achieved_weight: 1.0 From 0960be80fab797195a6f678712d6d32241818ff1 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Tue, 22 Apr 2025 15:04:21 -0400 Subject: [PATCH 73/81] Fix all reference-path-related bugs --- baselines/ppo/config/ppo_waypoint.yaml | 8 +- gpudrive/datatypes/observation.py | 1 + gpudrive/env/config.py | 2 +- gpudrive/env/constants.py | 3 + gpudrive/env/env_puffer.py | 7 +- gpudrive/env/env_torch.py | 198 +++++++++++++------------ gpudrive/networks/agents.py | 2 +- gpudrive/visualize/core.py | 30 ++++ src/consts.hpp | 2 +- 9 files changed, 146 insertions(+), 107 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 1fe3c5675..18e03618a 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -17,7 +17,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. norm_obs: true remove_non_vehicles: false collision_behavior: "ignore" - goal_behavior: "stop" + goal_behavior: "ignore" reward_type: "follow_waypoints" waypoint_distance_scale: 0.01 speed_distance_scale: 0.01 @@ -106,10 +106,10 @@ train: checkpoint_path: "./runs" # # # Rendering # # # - render: true # Determines whether to render the environment (note: will slow down training) + render: false # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d - render_interval: 100 # Render every k iterations - render_k_scenarios: 2 # Number of scenarios to render + render_interval: 10 # Render every k iterations + render_k_scenarios: 3 # Number of scenarios to render render_format: "mp4" # Options: gif, mp4 render_fps: 20 # Frames per second zoom_radius: 100 diff --git a/gpudrive/datatypes/observation.py b/gpudrive/datatypes/observation.py index fefc0bff5..8f4208307 100644 --- a/gpudrive/datatypes/observation.py +++ b/gpudrive/datatypes/observation.py @@ -118,6 +118,7 @@ def __init__(self, abs_self_obs_tensor: torch.Tensor): self.pos_x = abs_self_obs_tensor[:, :, 0] self.pos_y = abs_self_obs_tensor[:, :, 1] self.pos_z = abs_self_obs_tensor[:, :, 2] + self.pos_xy = abs_self_obs_tensor[:, :, :2] self.rotation_as_quaternion = abs_self_obs_tensor[:, :, 3:7] self.rotation_angle = abs_self_obs_tensor[:, :, 7] self.goal_x = abs_self_obs_tensor[:, :, 8] diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index a645292df..dfb9c84e3 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -92,7 +92,7 @@ class EnvConfig: init_steps: int = 0 # Goal behavior settings - goal_behavior: str = "remove" # Options: "stop", "ignore", "remove" + goal_behavior: str = "ignore" # Options: "stop", "ignore", "remove" # Reference points settings add_reference_speed: bool = ( diff --git a/gpudrive/env/constants.py b/gpudrive/env/constants.py index 3934d1ff6..af4f7fc2a 100644 --- a/gpudrive/env/constants.py +++ b/gpudrive/env/constants.py @@ -35,3 +35,6 @@ # Action values MAX_ACTION_VALUE = 4.0 + +# Invalid points +INVALID_ID = -1.0 \ No newline at end of file diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index d2f37b0c8..b3805587b 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -427,9 +427,8 @@ def step(self, action): collision_weight=self.collision_weight, off_road_weight=self.off_road_weight, goal_achieved_weight=self.goal_achieved_weight, - world_time_steps=self.episode_lengths[:, 0].long(), ) - + # Flatten rewards; only keep rewards for controlled agents reward_controlled = reward[self.controlled_agent_mask] @@ -442,9 +441,7 @@ def step(self, action): self.live_agent_mask ] += self.env.base_rewards[self.live_agent_mask] - terminal = self.env.get_dones( - world_time_steps=self.episode_lengths[:, 0].long() - ) + terminal = self.env.get_dones() self.render_env() if self.render else None diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 3dcfdaf66..96d517e5d 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -56,6 +56,7 @@ def __init__( self.render_config = render_config self.backend = backend self.max_num_agents_in_scene = self.config.max_num_agents_in_scene + self.world_time_steps = torch.zeros( self.num_worlds, dtype=torch.short, device=self.device ) @@ -88,6 +89,9 @@ def __init__( self.max_agent_count, backend=self.backend, ) + self.episode_len = self.config.episode_len + self.reference_path_length = self.log_trajectory.pos_xy.shape[2] - self.config.init_steps + self.step_in_world = self.episode_len - self.sim.steps_remaining_tensor().to_torch() # Now initialize reward weights tensor if using reward_conditioned reward type if ( @@ -105,8 +109,6 @@ def __init__( (self.num_worlds, self.max_cont_agents, 3), device=self.device ) - self.episode_len = self.config.episode_len - # Initialize VBD model if used self._initialize_vbd() @@ -508,7 +510,6 @@ def get_rewards( collision_weight=-0.5, goal_achieved_weight=0.0, off_road_weight=-0.5, - world_time_steps=None, ): """Obtain the rewards for the current step.""" @@ -612,15 +613,17 @@ def get_rewards( ) # Extract waypoints (ground truth) at time t - batch_indices = torch.arange(world_time_steps.shape[0]) + step_in_world = self.step_in_world[:, 0, :].squeeze(-1) + batch_indices = torch.arange(step_in_world.shape[0]) gt_agent_pos = self.log_trajectory.pos_xy[ - batch_indices, :, world_time_steps, : + batch_indices, :, step_in_world, : ] + gt_agent_speed = self.log_trajectory.ref_speed[ - batch_indices, :, world_time_steps + batch_indices, :, step_in_world ] valid_mask = ( - self.log_trajectory.valids[batch_indices, :, world_time_steps] + self.log_trajectory.valids[batch_indices, :, step_in_world] .squeeze(-1) .bool() ) @@ -681,7 +684,7 @@ def get_rewards( if self.config.waypoint_sample_interval > 1: waypoint_mask = ( ( - world_time_steps % self.config.waypoint_sample_interval + step_in_world % self.config.waypoint_sample_interval == 0 ) .float() @@ -698,6 +701,10 @@ def step_dynamics(self, actions): if actions is not None: self._apply_actions(actions) self.sim.step() + + # Update time in worlds + self.step_in_world = self.episode_len - self.sim.steps_remaining_tensor().to_torch() + not_done_worlds = ~self.get_dones().any( dim=1 ) # Check if any agent in world is done @@ -886,25 +893,21 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: ) if self.config.add_reference_speed: - avg_ref_speed = ( - self.log_trajectory.ref_speed.mean(axis=-1) - / constants.MAX_SPEED - ) + + avg_ref_speed = self.log_trajectory.clone().ref_speed.mean(axis=-1) / constants.MAX_SPEED + base_fields.append(avg_ref_speed.unsqueeze(-1)) if self.config.add_reference_path: - # Shape: [batch, 91, 2] - glob_ego_states = ( - self.sim.absolute_self_observation_tensor() - .to_torch() - .clone() - ) - glob_ego_pos_xy = glob_ego_states[:, :, :2] - glob_ego_yaw = glob_ego_states[:, :, 7] + state = self.sim.absolute_self_observation_tensor().to_torch().clone() + global_ego_pos_xy = state[:, :, :2] + global_ego_yaw = state[:, :, 7] glob_reference_xy = self.log_trajectory.pos_xy - + agent_indices = torch.arange(self.max_cont_agents) local_reference_xy = torch.empty_like(glob_reference_xy) + valid_timesteps_mask = self.log_trajectory.valids.bool() + # Transform reference path to be relative to current # agent positions and heading for world_idx in range(self.num_worlds): @@ -915,15 +918,31 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: global_pos_xy=glob_reference_xy[ world_idx, agent_idx, :, : ], - ego_pos=glob_ego_pos_xy[world_idx, agent_idx], - ego_yaw=glob_ego_yaw[world_idx, agent_idx], + ego_pos=global_ego_pos_xy[world_idx, agent_idx], + ego_yaw=global_ego_yaw[world_idx, agent_idx], device=self.device, ) - - self.local_reference_xy = local_reference_xy.clone() - + + local_ref_xy_orig = local_reference_xy.clone() + # Normalize local_reference_xy /= constants.MAX_REF_POINT + + # Set invalid steps to -1.0 + local_reference_xy[~valid_timesteps_mask.expand_as(local_reference_xy)] = constants.INVALID_ID + + # Provide agent with index to pay attention to through one-hot encoding + next_step_in_world = torch.clamp(self.step_in_world[:, 0, :].squeeze(-1) + 1, min=0, max=self.episode_len) + time_one_hot = torch.zeros((self.num_worlds, self.max_agent_count, self.reference_path_length, 1), device=self.device) + time_one_hot[:, :, next_step_in_world, :] = 1.0 + + # Make unnormalized reference path available for plotting + self.reference_path = torch.cat((local_ref_xy_orig, time_one_hot), dim=-1) + + reference_path = torch.cat((local_reference_xy, time_one_hot), dim=-1) + + # Flatten the dimensions for stacking + base_fields.append(reference_path.flatten(start_dim=2)) # batch_size = local_reference_xy.shape[0] # num_points = local_reference_xy.shape[1] @@ -946,10 +965,7 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: # self.local_reference_xy = ( # local_reference_xy * point_dropout_mask # ) - - # Flatten the dimensions for stacking - base_fields.append(local_reference_xy.flatten(start_dim=2)) - + if self.config.reward_type == "reward_conditioned": # Create expanded weights for all environments @@ -981,36 +997,29 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: if self.config.add_reference_speed: avg_ref_speed = ( - self.log_trajectory.ref_speed[mask].mean(axis=-1) + self.log_trajectory.ref_speed[mask].clone().mean(axis=-1) / constants.MAX_SPEED ) base_fields.append(avg_ref_speed.unsqueeze(-1)) if self.config.add_reference_path: - glob_ego_states = ( - self.sim.absolute_self_observation_tensor() - .to_torch() - .clone()[mask] - ) - glob_ego_pos_xy = glob_ego_states[:, :2] # Shape: [batch, 2] - glob_ego_yaw = glob_ego_states[:, 7] # Shape: [batch] - glob_reference_xy = self.log_trajectory.pos_xy[ - mask - ] # Shape: [batch, 91, 2] - - # Translate all points at once by broadcasting subtraction - # Reshape ego positions for broadcasting: [batch, 1, 2] - ego_pos_expanded = glob_ego_pos_xy.unsqueeze(1) - translated = glob_reference_xy - ego_pos_expanded + + # State information + state = (self.sim.absolute_self_observation_tensor().to_torch().clone()[mask]).to(self.device) + global_ego_pos_xy = state[:, :2] # Shape: [batch, 2] + global_ego_yaw = state[:, 7] # Shape: [batch] + global_reference_xy = self.log_trajectory.pos_xy.clone()[mask] + valid_timesteps_mask = self.log_trajectory.valids.bool()[mask] + batch_size = global_reference_xy.shape[0] + batch_indices = torch.arange(batch_size) + + # Translate all points to a local coordinate frame + translated = global_reference_xy - global_ego_pos_xy.unsqueeze(1) # Create rotation matrices for all agents at once - cos_yaw = torch.cos(glob_ego_yaw).to( - self.device - ) # Shape: [batch] - sin_yaw = torch.sin(glob_ego_yaw).to( - self.device - ) # Shape: [batch] - + cos_yaw = torch.cos(global_ego_yaw) + sin_yaw = torch.sin(global_ego_yaw) + # Create batch of rotation matrices: [batch, 2, 2] rotation_matrices = torch.stack( [ @@ -1024,27 +1033,27 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: local_reference_xy = torch.bmm( rotation_matrices, translated.transpose(1, 2) ).transpose(1, 2) - - self.local_reference_xy = local_reference_xy.clone() - + + local_reference_xy_orig = local_reference_xy.clone() + # Normalize to [-1, 1] local_reference_xy /= constants.MAX_REF_POINT - - # point_dropout_mask = torch.bernoulli( - # torch.ones( - # (batch_size, num_points), - # device=local_reference_xy.device, - # ) - # * (1 - self.config.prob_reference_dropout) - # ).bool() - - # Dropout fraction of points in the reference path - # self.local_reference_xy = ( - # local_reference_xy * point_dropout_mask.unsqueeze(2) - # ) - + + # Set invalid timesteps to -1 + local_reference_xy[~valid_timesteps_mask.expand_as(local_reference_xy)] = constants.INVALID_ID + + # Provide agent with index to pay attention to through one-hot encoding + next_step_in_world = torch.clamp(self.step_in_world[mask] + 1, min=0, max=self.episode_len) + time_one_hot = torch.zeros((batch_size, self.reference_path_length, 1), device=self.device) + time_one_hot[batch_indices, next_step_in_world] = 1.0 + + # Stack + reference_path = torch.cat((local_reference_xy, time_one_hot), dim=2) + + self.reference_path = torch.cat((local_reference_xy_orig, time_one_hot), dim=2) + # Stack - base_fields.append(local_reference_xy.flatten(start_dim=1)) + base_fields.append(reference_path.flatten(start_dim=1)) if self.config.reward_type == "reward_conditioned": # For masked agents, we need to extract agent indices from the mask @@ -1734,10 +1743,9 @@ def get_scenario_ids(self): if __name__ == "__main__": env_config = EnvConfig( - dynamics_model="delta_local", + dynamics_model="classic", reward_type="follow_waypoints", add_reference_path=True, - prob_reference_dropout=0.8, ) render_config = RenderConfig() @@ -1761,7 +1769,7 @@ def get_scenario_ids(self): control_mask = env.cont_agent_mask # Rollout - obs = env.reset(control_mask) + obs = env.reset() sim_frames = [] agent_obs_frames = [] @@ -1769,21 +1777,18 @@ def get_scenario_ids(self): expert_actions, _, _, _ = env.get_expert_actions() env_idx = 0 - - for t in range(91): - print(f"Step: {t}") - + highlight_agent = torch.where(env.cont_agent_mask[env_idx, :])[0][ + 0 + ].item() + + print(highlight_agent) + + for t in range(10): + print(f"Step: {t+1}") + # Step the environment expert_actions, _, _, _ = env.get_expert_actions() - env.step_dynamics(expert_actions[:, :, t, :]) - - highlight_agent = torch.where(env.cont_agent_mask[env_idx, :])[0][ - 0 - ].item() - - print( - f"is_valid: {env.log_trajectory.valids[env_idx, highlight_agent, t, :]}" - ) + env.step_dynamics(expert_actions[:, :, t-1, :]) # Make video sim_states = env.vis.plot_simulator_state( @@ -1793,12 +1798,12 @@ def get_scenario_ids(self): center_agent_indices=[highlight_agent], plot_waypoints=True, ) - + agent_obs = env.vis.plot_agent_observation( env_idx=env_idx, agent_idx=highlight_agent, figsize=(10, 10), - trajectory=env.local_reference_xy[highlight_agent, :, :].to( + trajectory=env.reference_path[highlight_agent, :, :].to( env.device ), ) @@ -1811,23 +1816,26 @@ def get_scenario_ids(self): ) obs = env.get_obs(control_mask) - reward = env.get_rewards(world_time_steps=world_time_steps) + reward = env.get_rewards() - print(f"Reward: {reward[:, env_idx, highlight_agent]}") + print(f"A_t: {expert_actions[env_idx, highlight_agent, t, :]}") + print(f"R_t+1: {reward[env_idx, highlight_agent]}") done = env.get_dones() info = env.get_infos() print(done[env.cont_agent_mask]) - if done.all().bool(): - break - + # if done.all().bool(): + # # Check resetting behavior + # _ = env.reset(control_mask) + # env.step_dynamics(expert_actions[:, :, 0, :]) + env.close() media.write_video( "sim_video.gif", np.array(sim_frames), fps=10, codec="gif" ) media.write_video( - "obs_video.gif", np.array(agent_obs_frames), fps=10, codec="gif" + f"obs_video_env_{env_idx}_agent_{highlight_agent}.gif", np.array(agent_obs_frames), fps=10, codec="gif" ) diff --git a/gpudrive/networks/agents.py b/gpudrive/networks/agents.py index 6fff80144..23f5ba88d 100644 --- a/gpudrive/networks/agents.py +++ b/gpudrive/networks/agents.py @@ -50,7 +50,7 @@ def __init__( "add_reference_path" ]: # Every agent receives a reference path # NOTE: Hardcoded to 91 for now - self.ego_state_idx += 91 * 2 + self.ego_state_idx += 91 * 3 if self.config["add_reference_speed"]: self.ego_state_idx += 1 diff --git a/gpudrive/visualize/core.py b/gpudrive/visualize/core.py index 2829c7ff7..2d466165f 100644 --- a/gpudrive/visualize/core.py +++ b/gpudrive/visualize/core.py @@ -1702,6 +1702,22 @@ def plot_agent_observation( # ) # ax.add_patch(observation_radius) plt.axis("off") + + time_step = (self.env_config.episode_len - self.sim_object.steps_remaining_tensor().to_torch()[env_idx, agent_idx]).item() + + # Add time step text to the figure + ax.text( + 0.05, # x position in axes coordinates (5% from left) + 0.95, # y position in axes coordinates (95% from bottom) + f"t = {time_step}", + transform=ax.transAxes, # Use axes coordinates + fontsize=15, + color='black', + ha='left', + va='top' + ) + + attn_reference_idx = torch.where(trajectory[:, 2] == 1)[0] if trajectory is not None and len(trajectory) > 0: # Plot the trajectory as a line @@ -1714,6 +1730,20 @@ def plot_agent_observation( alpha=0.2, zorder=0, ) + # Add a purple star above the reference position + if len(attn_reference_idx) > 0: + ref_idx = attn_reference_idx[0] + ref_x = trajectory[ref_idx, 0] + ref_y = trajectory[ref_idx, 1] + + ax.scatter( + ref_x, + ref_y, + color="#9D00FF", + marker="*", + s=120, + zorder=10, + ) ax.set_xlim((-self.env_config.obs_radius, self.env_config.obs_radius)) ax.set_ylim((-self.env_config.obs_radius, self.env_config.obs_radius)) diff --git a/src/consts.hpp b/src/consts.hpp index 0768e9cd0..d5e76b834 100644 --- a/src/consts.hpp +++ b/src/consts.hpp @@ -31,7 +31,7 @@ inline constexpr float rewardPerDist = 0.05f; inline constexpr float slackReward = -0.005f; // Steps per episode -inline constexpr int32_t episodeLen = 91; +inline constexpr int32_t episodeLen = 90; // Number of lidar samples, arranged in circle around agent inline constexpr madrona::CountT numLidarSamples = 50; From 1c682949cba28948c69a751b95aaa59fd67bd442 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Tue, 22 Apr 2025 15:04:47 -0400 Subject: [PATCH 74/81] Formatting --- gpudrive/env/constants.py | 2 +- gpudrive/env/env_puffer.py | 5 +- gpudrive/env/env_torch.py | 154 ++++++++++++++++++++++++------------- gpudrive/visualize/core.py | 33 ++++---- 4 files changed, 122 insertions(+), 72 deletions(-) diff --git a/gpudrive/env/constants.py b/gpudrive/env/constants.py index af4f7fc2a..f457cf223 100644 --- a/gpudrive/env/constants.py +++ b/gpudrive/env/constants.py @@ -37,4 +37,4 @@ MAX_ACTION_VALUE = 4.0 # Invalid points -INVALID_ID = -1.0 \ No newline at end of file +INVALID_ID = -1.0 diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index b3805587b..7ba994741 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -428,7 +428,7 @@ def step(self, action): off_road_weight=self.off_road_weight, goal_achieved_weight=self.goal_achieved_weight, ) - + # Flatten rewards; only keep rewards for controlled agents reward_controlled = reward[self.controlled_agent_mask] @@ -579,8 +579,7 @@ def step(self, action): # Asynchronously reset the done worlds and empty storage self.env.reset( - env_idx_list=done_worlds_cpu, - mask=self.controlled_agent_mask + env_idx_list=done_worlds_cpu, mask=self.controlled_agent_mask ) self.episode_returns[done_worlds] = 0 self.agent_episode_returns[done_worlds, :] = 0 diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 96d517e5d..c11a59743 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -56,7 +56,7 @@ def __init__( self.render_config = render_config self.backend = backend self.max_num_agents_in_scene = self.config.max_num_agents_in_scene - + self.world_time_steps = torch.zeros( self.num_worlds, dtype=torch.short, device=self.device ) @@ -90,8 +90,12 @@ def __init__( backend=self.backend, ) self.episode_len = self.config.episode_len - self.reference_path_length = self.log_trajectory.pos_xy.shape[2] - self.config.init_steps - self.step_in_world = self.episode_len - self.sim.steps_remaining_tensor().to_torch() + self.reference_path_length = ( + self.log_trajectory.pos_xy.shape[2] - self.config.init_steps + ) + self.step_in_world = ( + self.episode_len - self.sim.steps_remaining_tensor().to_torch() + ) # Now initialize reward weights tensor if using reward_conditioned reward type if ( @@ -618,7 +622,7 @@ def get_rewards( gt_agent_pos = self.log_trajectory.pos_xy[ batch_indices, :, step_in_world, : ] - + gt_agent_speed = self.log_trajectory.ref_speed[ batch_indices, :, step_in_world ] @@ -683,10 +687,7 @@ def get_rewards( # Apply waypoint mask only if sampling interval is greater than 1 if self.config.waypoint_sample_interval > 1: waypoint_mask = ( - ( - step_in_world % self.config.waypoint_sample_interval - == 0 - ) + (step_in_world % self.config.waypoint_sample_interval == 0) .float() .unsqueeze(1) ) @@ -701,9 +702,11 @@ def step_dynamics(self, actions): if actions is not None: self._apply_actions(actions) self.sim.step() - + # Update time in worlds - self.step_in_world = self.episode_len - self.sim.steps_remaining_tensor().to_torch() + self.step_in_world = ( + self.episode_len - self.sim.steps_remaining_tensor().to_torch() + ) not_done_worlds = ~self.get_dones().any( dim=1 @@ -893,14 +896,21 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: ) if self.config.add_reference_speed: - - avg_ref_speed = self.log_trajectory.clone().ref_speed.mean(axis=-1) / constants.MAX_SPEED - + + avg_ref_speed = ( + self.log_trajectory.clone().ref_speed.mean(axis=-1) + / constants.MAX_SPEED + ) + base_fields.append(avg_ref_speed.unsqueeze(-1)) if self.config.add_reference_path: - state = self.sim.absolute_self_observation_tensor().to_torch().clone() + state = ( + self.sim.absolute_self_observation_tensor() + .to_torch() + .clone() + ) global_ego_pos_xy = state[:, :, :2] global_ego_yaw = state[:, :, 7] glob_reference_xy = self.log_trajectory.pos_xy @@ -922,25 +932,43 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: ego_yaw=global_ego_yaw[world_idx, agent_idx], device=self.device, ) - + local_ref_xy_orig = local_reference_xy.clone() - + # Normalize local_reference_xy /= constants.MAX_REF_POINT - + # Set invalid steps to -1.0 - local_reference_xy[~valid_timesteps_mask.expand_as(local_reference_xy)] = constants.INVALID_ID - + local_reference_xy[ + ~valid_timesteps_mask.expand_as(local_reference_xy) + ] = constants.INVALID_ID + # Provide agent with index to pay attention to through one-hot encoding - next_step_in_world = torch.clamp(self.step_in_world[:, 0, :].squeeze(-1) + 1, min=0, max=self.episode_len) - time_one_hot = torch.zeros((self.num_worlds, self.max_agent_count, self.reference_path_length, 1), device=self.device) + next_step_in_world = torch.clamp( + self.step_in_world[:, 0, :].squeeze(-1) + 1, + min=0, + max=self.episode_len, + ) + time_one_hot = torch.zeros( + ( + self.num_worlds, + self.max_agent_count, + self.reference_path_length, + 1, + ), + device=self.device, + ) time_one_hot[:, :, next_step_in_world, :] = 1.0 - + # Make unnormalized reference path available for plotting - self.reference_path = torch.cat((local_ref_xy_orig, time_one_hot), dim=-1) - - reference_path = torch.cat((local_reference_xy, time_one_hot), dim=-1) - + self.reference_path = torch.cat( + (local_ref_xy_orig, time_one_hot), dim=-1 + ) + + reference_path = torch.cat( + (local_reference_xy, time_one_hot), dim=-1 + ) + # Flatten the dimensions for stacking base_fields.append(reference_path.flatten(start_dim=2)) @@ -965,7 +993,7 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: # self.local_reference_xy = ( # local_reference_xy * point_dropout_mask # ) - + if self.config.reward_type == "reward_conditioned": # Create expanded weights for all environments @@ -1003,23 +1031,29 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: base_fields.append(avg_ref_speed.unsqueeze(-1)) if self.config.add_reference_path: - + # State information - state = (self.sim.absolute_self_observation_tensor().to_torch().clone()[mask]).to(self.device) + state = ( + self.sim.absolute_self_observation_tensor() + .to_torch() + .clone()[mask] + ).to(self.device) global_ego_pos_xy = state[:, :2] # Shape: [batch, 2] global_ego_yaw = state[:, 7] # Shape: [batch] - global_reference_xy = self.log_trajectory.pos_xy.clone()[mask] + global_reference_xy = self.log_trajectory.pos_xy.clone()[mask] valid_timesteps_mask = self.log_trajectory.valids.bool()[mask] batch_size = global_reference_xy.shape[0] batch_indices = torch.arange(batch_size) # Translate all points to a local coordinate frame - translated = global_reference_xy - global_ego_pos_xy.unsqueeze(1) + translated = global_reference_xy - global_ego_pos_xy.unsqueeze( + 1 + ) # Create rotation matrices for all agents at once cos_yaw = torch.cos(global_ego_yaw) sin_yaw = torch.sin(global_ego_yaw) - + # Create batch of rotation matrices: [batch, 2, 2] rotation_matrices = torch.stack( [ @@ -1033,25 +1067,36 @@ def _get_ego_state(self, mask=None) -> torch.Tensor: local_reference_xy = torch.bmm( rotation_matrices, translated.transpose(1, 2) ).transpose(1, 2) - + local_reference_xy_orig = local_reference_xy.clone() - + # Normalize to [-1, 1] local_reference_xy /= constants.MAX_REF_POINT - + # Set invalid timesteps to -1 - local_reference_xy[~valid_timesteps_mask.expand_as(local_reference_xy)] = constants.INVALID_ID - + local_reference_xy[ + ~valid_timesteps_mask.expand_as(local_reference_xy) + ] = constants.INVALID_ID + # Provide agent with index to pay attention to through one-hot encoding - next_step_in_world = torch.clamp(self.step_in_world[mask] + 1, min=0, max=self.episode_len) - time_one_hot = torch.zeros((batch_size, self.reference_path_length, 1), device=self.device) + next_step_in_world = torch.clamp( + self.step_in_world[mask] + 1, min=0, max=self.episode_len + ) + time_one_hot = torch.zeros( + (batch_size, self.reference_path_length, 1), + device=self.device, + ) time_one_hot[batch_indices, next_step_in_world] = 1.0 - + # Stack - reference_path = torch.cat((local_reference_xy, time_one_hot), dim=2) - - self.reference_path = torch.cat((local_reference_xy_orig, time_one_hot), dim=2) - + reference_path = torch.cat( + (local_reference_xy, time_one_hot), dim=2 + ) + + self.reference_path = torch.cat( + (local_reference_xy_orig, time_one_hot), dim=2 + ) + # Stack base_fields.append(reference_path.flatten(start_dim=1)) @@ -1777,18 +1822,16 @@ def get_scenario_ids(self): expert_actions, _, _, _ = env.get_expert_actions() env_idx = 0 - highlight_agent = torch.where(env.cont_agent_mask[env_idx, :])[0][ - 0 - ].item() - + highlight_agent = torch.where(env.cont_agent_mask[env_idx, :])[0][0].item() + print(highlight_agent) - + for t in range(10): print(f"Step: {t+1}") - + # Step the environment expert_actions, _, _, _ = env.get_expert_actions() - env.step_dynamics(expert_actions[:, :, t-1, :]) + env.step_dynamics(expert_actions[:, :, t - 1, :]) # Make video sim_states = env.vis.plot_simulator_state( @@ -1798,7 +1841,7 @@ def get_scenario_ids(self): center_agent_indices=[highlight_agent], plot_waypoints=True, ) - + agent_obs = env.vis.plot_agent_observation( env_idx=env_idx, agent_idx=highlight_agent, @@ -1830,12 +1873,15 @@ def get_scenario_ids(self): # # Check resetting behavior # _ = env.reset(control_mask) # env.step_dynamics(expert_actions[:, :, 0, :]) - + env.close() media.write_video( "sim_video.gif", np.array(sim_frames), fps=10, codec="gif" ) media.write_video( - f"obs_video_env_{env_idx}_agent_{highlight_agent}.gif", np.array(agent_obs_frames), fps=10, codec="gif" + f"obs_video_env_{env_idx}_agent_{highlight_agent}.gif", + np.array(agent_obs_frames), + fps=10, + codec="gif", ) diff --git a/gpudrive/visualize/core.py b/gpudrive/visualize/core.py index 2d466165f..30af87d1d 100644 --- a/gpudrive/visualize/core.py +++ b/gpudrive/visualize/core.py @@ -1702,9 +1702,14 @@ def plot_agent_observation( # ) # ax.add_patch(observation_radius) plt.axis("off") - - time_step = (self.env_config.episode_len - self.sim_object.steps_remaining_tensor().to_torch()[env_idx, agent_idx]).item() - + + time_step = ( + self.env_config.episode_len + - self.sim_object.steps_remaining_tensor().to_torch()[ + env_idx, agent_idx + ] + ).item() + # Add time step text to the figure ax.text( 0.05, # x position in axes coordinates (5% from left) @@ -1712,11 +1717,11 @@ def plot_agent_observation( f"t = {time_step}", transform=ax.transAxes, # Use axes coordinates fontsize=15, - color='black', - ha='left', - va='top' - ) - + color="black", + ha="left", + va="top", + ) + attn_reference_idx = torch.where(trajectory[:, 2] == 1)[0] if trajectory is not None and len(trajectory) > 0: @@ -1732,17 +1737,17 @@ def plot_agent_observation( ) # Add a purple star above the reference position if len(attn_reference_idx) > 0: - ref_idx = attn_reference_idx[0] + ref_idx = attn_reference_idx[0] ref_x = trajectory[ref_idx, 0] ref_y = trajectory[ref_idx, 1] - + ax.scatter( - ref_x, - ref_y, + ref_x, + ref_y, color="#9D00FF", marker="*", - s=120, - zorder=10, + s=120, + zorder=10, ) ax.set_xlim((-self.env_config.obs_radius, self.env_config.obs_radius)) From f0f33141c29ad0786091d92b635b3909c8c825a0 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Tue, 22 Apr 2025 15:12:11 -0400 Subject: [PATCH 75/81] Useful debug notebook --- examples/experimental/notebooks/debug.ipynb | 903 ++++++++++++++++++++ 1 file changed, 903 insertions(+) create mode 100644 examples/experimental/notebooks/debug.ipynb diff --git a/examples/experimental/notebooks/debug.ipynb b/examples/experimental/notebooks/debug.ipynb new file mode 100644 index 000000000..2be729d0a --- /dev/null +++ b/examples/experimental/notebooks/debug.ipynb @@ -0,0 +1,903 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# reload magic\n", + "import importlib\n", + "import gpudrive\n", + "importlib.reload(gpudrive)\n", + "from gpudrive.env.env_torch import GPUDriveTorchEnv\n", + "from gpudrive.env.config import EnvConfig, RenderConfig\n", + "from gpudrive.env.dataset import SceneDataLoader\n", + "\n", + "from gpudrive.visualize.utils import img_from_fig\n", + "\n", + "import torch\n", + "from PIL import Image\n", + "\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Make environment" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "env_config = EnvConfig(\n", + " dynamics_model=\"classic\",\n", + " reward_type=\"follow_waypoints\",\n", + " add_reference_path=True,\n", + ")\n", + "render_config = RenderConfig()\n", + "\n", + "train_loader = SceneDataLoader(\n", + " root=\"data/processed/examples\",\n", + " batch_size=2,\n", + " dataset_size=100,\n", + " sample_with_replacement=True,\n", + " shuffle=False,\n", + ")\n", + "\n", + "env = GPUDriveTorchEnv(\n", + " config=env_config,\n", + " data_loader=train_loader,\n", + " max_cont_agents=64, \n", + " device=\"cpu\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Controllable agents: tensor([ 0, 1, 2, 4, 12])\n", + "Controlling agent 2 in env 0.\n" + ] + } + ], + "source": [ + "env_i = 0\n", + "agent_j = 2\n", + "\n", + "control_mask = env.cont_agent_mask\n", + "\n", + "print(f'Controllable agents: {torch.where(env.cont_agent_mask[env_i, :])[0]}')\n", + "\n", + "print(f'Controlling agent {agent_j} in env {env_i}.')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Verify indexing" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "obs = env.reset(control_mask)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "obs = env.reset(control_mask)\n", + "\n", + "expert_actions, _, _, _ = env.get_expert_actions()\n", + "\n", + "for t in range(5):\n", + " env.step_dynamics(expert_actions[:, :, t, :])\n", + " obs = env.get_obs(control_mask)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([91, 3])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "traj_masked = env.reference_path[2, :, :]\n", + "\n", + "traj_masked.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "valid: tensor([True, True, True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True])\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "traj_masked = env.reference_path[2, :, :]\n", + "\n", + "agent_obs_masked = env.vis.plot_agent_observation(\n", + " env_idx=env_i,\n", + " agent_idx=agent_j,\n", + " figsize=(7, 7),\n", + " trajectory=traj_masked,\n", + ")\n", + "\n", + "Image.fromarray(img_from_fig(agent_obs_masked))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[-2.8176e+00, 1.6540e-06, 0.0000e+00],\n", + " [-2.2567e+00, -5.4991e-02, 0.0000e+00],\n", + " [-1.6712e+00, -1.1899e-01, 0.0000e+00],\n", + " [-1.1435e+00, -2.1718e-01, 0.0000e+00],\n", + " [-5.8799e-01, -3.4425e-01, 0.0000e+00],\n", + " [-4.9307e-02, -4.9633e-01, 0.0000e+00],\n", + " [ 4.9877e-01, -6.5314e-01, 1.0000e+00],\n", + " [ 1.0278e+00, -8.2594e-01, 0.0000e+00],\n", + " [ 1.5701e+00, -1.0161e+00, 0.0000e+00],\n", + " [ 2.0863e+00, -1.2118e+00, 0.0000e+00],\n", + " [ 2.6098e+00, -1.4267e+00, 0.0000e+00],\n", + " [ 3.1191e+00, -1.6454e+00, 0.0000e+00],\n", + " [ 3.6540e+00, -1.8755e+00, 0.0000e+00],\n", + " [ 4.1953e+00, -2.1215e+00, 0.0000e+00],\n", + " [ 4.7675e+00, -2.3735e+00, 0.0000e+00],\n", + " [ 5.3208e+00, -2.6513e+00, 0.0000e+00],\n", + " [ 5.8825e+00, -2.8995e+00, 0.0000e+00],\n", + " [ 6.4127e+00, -3.1944e+00, 0.0000e+00],\n", + " [ 6.9735e+00, -3.4876e+00, 0.0000e+00],\n", + " [ 7.5203e+00, -3.8051e+00, 0.0000e+00],\n", + " [ 8.0950e+00, -4.1299e+00, 0.0000e+00],\n", + " [ 8.6821e+00, -4.4582e+00, 0.0000e+00],\n", + " [ 9.2876e+00, -4.8013e+00, 0.0000e+00],\n", + " [ 9.9100e+00, -5.1523e+00, 0.0000e+00],\n", + " [ 1.0536e+01, -5.5163e+00, 0.0000e+00],\n", + " [ 1.1209e+01, -5.8927e+00, 0.0000e+00],\n", + " [ 1.1828e+01, -6.2615e+00, 0.0000e+00],\n", + " [ 1.2506e+01, -6.6497e+00, 0.0000e+00],\n", + " [ 1.3193e+01, -7.0484e+00, 0.0000e+00],\n", + " [ 1.3869e+01, -7.4457e+00, 0.0000e+00],\n", + " [ 1.4562e+01, -7.8596e+00, 0.0000e+00],\n", + " [ 1.5258e+01, -8.2762e+00, 0.0000e+00],\n", + " [ 1.5968e+01, -8.6956e+00, 0.0000e+00],\n", + " [ 1.6693e+01, -9.1250e+00, 0.0000e+00],\n", + " [ 1.7441e+01, -9.5761e+00, 0.0000e+00],\n", + " [ 1.8156e+01, -9.9870e+00, 0.0000e+00],\n", + " [ 1.8938e+01, -1.0467e+01, 0.0000e+00],\n", + " [ 1.9656e+01, -1.0894e+01, 0.0000e+00],\n", + " [ 2.0452e+01, -1.1372e+01, 0.0000e+00],\n", + " [ 2.1205e+01, -1.1824e+01, 0.0000e+00],\n", + " [ 2.1998e+01, -1.2283e+01, 0.0000e+00],\n", + " [ 2.2798e+01, -1.2767e+01, 0.0000e+00],\n", + " [ 2.3605e+01, -1.3238e+01, 0.0000e+00],\n", + " [ 2.4404e+01, -1.3717e+01, 0.0000e+00],\n", + " [ 2.5225e+01, -1.4205e+01, 0.0000e+00],\n", + " [ 2.6044e+01, -1.4694e+01, 0.0000e+00],\n", + " [ 2.6874e+01, -1.5197e+01, 0.0000e+00],\n", + " [ 2.7730e+01, -1.5706e+01, 0.0000e+00],\n", + " [ 2.8580e+01, -1.6209e+01, 0.0000e+00],\n", + " [ 2.9454e+01, -1.6734e+01, 0.0000e+00],\n", + " [ 3.0307e+01, -1.7237e+01, 0.0000e+00],\n", + " [ 3.1191e+01, -1.7769e+01, 0.0000e+00],\n", + " [ 3.2098e+01, -1.8292e+01, 0.0000e+00],\n", + " [ 3.2996e+01, -1.8836e+01, 0.0000e+00],\n", + " [ 3.3914e+01, -1.9388e+01, 0.0000e+00],\n", + " [ 3.4817e+01, -1.9921e+01, 0.0000e+00],\n", + " [ 3.5705e+01, -2.0455e+01, 0.0000e+00],\n", + " [ 3.6645e+01, -2.0996e+01, 0.0000e+00],\n", + " [ 3.7594e+01, -2.1556e+01, 0.0000e+00],\n", + " [ 3.8527e+01, -2.2106e+01, 0.0000e+00],\n", + " [ 3.9451e+01, -2.2661e+01, 0.0000e+00],\n", + " [ 4.0428e+01, -2.3217e+01, 0.0000e+00],\n", + " [ 4.1375e+01, -2.3780e+01, 0.0000e+00],\n", + " [ 4.2307e+01, -2.4312e+01, 0.0000e+00],\n", + " [ 4.3282e+01, -2.4874e+01, 0.0000e+00],\n", + " [ 4.4235e+01, -2.5452e+01, 0.0000e+00],\n", + " [ 4.5213e+01, -2.6012e+01, 0.0000e+00],\n", + " [ 4.6172e+01, -2.6576e+01, 0.0000e+00],\n", + " [ 4.7116e+01, -2.7120e+01, 0.0000e+00],\n", + " [ 4.8107e+01, -2.7662e+01, 0.0000e+00],\n", + " [ 4.9131e+01, -2.8236e+01, 0.0000e+00],\n", + " [ 5.0127e+01, -2.8802e+01, 0.0000e+00],\n", + " [ 5.1111e+01, -2.9381e+01, 0.0000e+00],\n", + " [ 5.2130e+01, -2.9930e+01, 0.0000e+00],\n", + " [ 5.3149e+01, -3.0526e+01, 0.0000e+00],\n", + " [ 5.4187e+01, -3.1101e+01, 0.0000e+00],\n", + " [ 5.5308e+01, -3.1733e+01, 0.0000e+00],\n", + " [ 5.6316e+01, -3.2302e+01, 0.0000e+00],\n", + " [ 5.7350e+01, -3.2853e+01, 0.0000e+00],\n", + " [ 5.8433e+01, -3.3481e+01, 0.0000e+00],\n", + " [ 5.9471e+01, -3.4043e+01, 0.0000e+00],\n", + " [ 6.0508e+01, -3.4615e+01, 0.0000e+00],\n", + " [ 6.1611e+01, -3.5201e+01, 0.0000e+00],\n", + " [ 6.2707e+01, -3.5811e+01, 0.0000e+00],\n", + " [ 6.3779e+01, -3.6378e+01, 0.0000e+00],\n", + " [ 6.4890e+01, -3.7002e+01, 0.0000e+00],\n", + " [ 6.5991e+01, -3.7572e+01, 0.0000e+00],\n", + " [-2.3981e+01, 1.1701e+01, 0.0000e+00],\n", + " [-2.3981e+01, 1.1701e+01, 0.0000e+00],\n", + " [-2.3981e+01, 1.1701e+01, 0.0000e+00],\n", + " [-2.3981e+01, 1.1701e+01, 0.0000e+00]])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "traj_masked" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([10, 91, 1])" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "env.log_trajectory.valids.bool()[control_mask].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "#env.log_trajectory.pos_xy[env_i, agent_j]" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "\n", + "#plt.scatter(traj[:, 0], traj[:, 1], label=\"trajectory\", alpha=0.3)\n", + "plt.scatter(traj_masked[:, 0], traj_masked[:, 1], label=\"trajectory\", alpha=0.3)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ -4.6843, -0.0000],\n", + " [ -3.7478, 0.0228],\n", + " [ -2.6972, 0.0244],\n", + " [ -1.6492, 0.0099],\n", + " [ -0.5689, -0.0026],\n", + " [ 0.5339, -0.0228],\n", + " [ 1.6032, -0.0322],\n", + " [ 2.7434, -0.0402],\n", + " [ 3.8651, -0.0452],\n", + " [ 5.0059, -0.0523],\n", + " [ 6.1329, -0.0523],\n", + " [ 7.3169, -0.0725],\n", + " [ 8.4740, -0.0730],\n", + " [ 9.6554, -0.0751],\n", + " [ 10.8401, -0.0971],\n", + " [ 12.0179, -0.1008],\n", + " [ 13.1972, -0.1081],\n", + " [ 14.4008, -0.1100],\n", + " [ 15.6533, -0.1187],\n", + " [ 16.8722, -0.1357],\n", + " [ 18.1067, -0.1230],\n", + " [ 19.3222, -0.1372],\n", + " [ 20.5441, -0.1466],\n", + " [ 21.8482, -0.1608],\n", + " [ 23.0581, -0.1674],\n", + " [ 24.3297, -0.1660],\n", + " [ 25.6302, -0.1674],\n", + " [ 26.8703, -0.1745],\n", + " [ 28.1802, -0.1851],\n", + " [ 29.4575, -0.1919],\n", + " [ 30.7170, -0.1969],\n", + " [ 32.0253, -0.1917],\n", + " [ 33.3079, -0.2276],\n", + " [ 34.6077, -0.2223],\n", + " [ 35.9107, -0.2487],\n", + " [ 37.1519, -0.2415],\n", + " [ 38.4949, -0.2594],\n", + " [ 39.8145, -0.2651],\n", + " [ 41.1175, -0.2745],\n", + " [ 42.5277, -0.2947],\n", + " [ 43.9141, -0.3020],\n", + " [ 45.6483, -0.3042],\n", + " [ 46.7122, -0.3789],\n", + " [ 47.9882, -0.3708],\n", + " [ 49.2079, -0.4041],\n", + " [ 50.4362, -0.4111],\n", + " [ 51.7675, -0.3951],\n", + " [ 53.1219, -0.4074],\n", + " [ 54.4872, -0.3983],\n", + " [ 55.8000, -0.4567],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000],\n", + " [ -0.0000, -0.0000]])" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Set print options to suppress scientific notation\n", + "torch.set_printoptions(sci_mode=False)\n", + "\n", + "traj_masked" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([91, 2])" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "traj_masked.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot agent observation with other traj" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "obs = env.reset()\n", + "\n", + "traj = env.local_reference_xy[env_i, agent_j, :]\n", + "\n", + "agent_obs = env.vis.plot_agent_observation(\n", + " env_idx=env_i,\n", + " agent_idx=agent_j,\n", + " figsize=(7, 7),\n", + " trajectory=traj,\n", + ")\n", + "Image.fromarray(img_from_fig(agent_obs))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([91, 2])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "traj.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([91, 2])" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "traj_masked.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "\n", + "plt.scatter(traj[:, 0], traj[:, 1], label=\"trajectory\", alpha=0.3)\n", + "#plt.scatter(traj_masked[:, 0], traj_masked[:, 1], label=\"masked trajectory\", alpha=0.3)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "shapes: torch.Size([1, 64, 2]), torch.Size([1, 64]), torch.Size([1, 64, 91, 2])\n" + ] + } + ], + "source": [ + "from gpudrive.datatypes.trajectory import LogTrajectory, to_local_frame\n", + "\n", + "global_ego_states = (\n", + " env.sim.absolute_self_observation_tensor()\n", + " .to_torch()\n", + " .clone()\n", + ")\n", + "\n", + "X_global = global_ego_states[:, :, :2]\n", + "theta_global = global_ego_states[:, :, 7]\n", + "Y_global = env.log_trajectory.pos_xy\n", + "\n", + "print(f\"shapes: {X_global.shape}, {theta_global.shape}, {Y_global.shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ground-truth" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([91, 2])\n", + "tensor([[ 0.0000, 0.0000],\n", + " [-0.2891, 0.1440],\n", + " [-0.6191, 0.2827],\n", + " [-0.9414, 0.4409],\n", + " [-1.3057, 0.6079],\n", + " [-1.6631, 0.7720],\n", + " [-2.0215, 0.9507],\n", + " [-2.4121, 1.1333],\n", + " [-2.8125, 1.3320],\n", + " [-3.2266, 1.5381]])\n", + " \n", + " R = torch.Size([2, 2]) =\n", + "tensor([[-0.9079, 0.4191],\n", + " [-0.4191, -0.9079]])\n", + " \n", + " Y_local = torch.Size([91, 2]) =\n", + "tensor([[ 0.0000, 0.0000],\n", + " [ 0.3228, -0.0096],\n", + " [ 0.6806, 0.0028],\n", + " [ 1.0395, -0.0057],\n", + " [ 1.4402, -0.0047]])\n" + ] + } + ], + "source": [ + "# 1) Translate\n", + "Y_bar = Y_global[env_i, agent_j, :] - X_global[env_i, agent_j, :]\n", + "\n", + "print(Y_bar.shape)\n", + "print(Y_bar[:10])\n", + "print(\" \")\n", + "\n", + "# 2) Rotate\n", + "cos_yaw = torch.cos(theta_global[env_i, agent_j])\n", + "sin_yaw = torch.sin(theta_global[env_i, agent_j])\n", + "rotation_matrix = torch.tensor(\n", + " [[cos_yaw, sin_yaw], [-sin_yaw, cos_yaw]]\n", + ")\n", + "\n", + "print(f' R = {rotation_matrix.shape} =')\n", + "print(rotation_matrix)\n", + "\n", + "# 3) Transform\n", + "Y_local = torch.matmul(Y_bar, rotation_matrix.T)\n", + "\n", + "print(\" \")\n", + "print(f' Y_local = {Y_local.shape} =')\n", + "print(\n", + " Y_local[:5]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Batched" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([91, 2])\n", + "tensor([-1.3057, 0.6079])\n", + " \n", + " R = torch.Size([64, 2, 2]) =\n", + "tensor([[-0.9079, 0.4191],\n", + " [-0.4191, -0.9079]])\n", + " \n", + " Y_local = torch.Size([64, 91, 2]) =\n", + "tensor([[ 0.0000e+00, 0.0000e+00],\n", + " [ 3.2282e-01, -9.6245e-03],\n", + " [ 6.8063e-01, 2.8185e-03],\n", + " [ 1.0395e+00, -5.7459e-03],\n", + " [ 1.4402e+00, -4.6898e-03],\n", + " [ 1.8335e+00, -3.8388e-03],\n", + " [ 2.2338e+00, -1.5878e-02],\n", + " [ 2.6650e+00, -1.7957e-02],\n", + " [ 3.1118e+00, -3.0572e-02],\n", + " [ 3.5741e+00, -4.4107e-02]])\n" + ] + } + ], + "source": [ + "# 1) Translate\n", + "Y_bar_batched = Y_global[env_i] - X_global[env_i].unsqueeze(1)\n", + "\n", + "print(Y_bar.shape)\n", + "print(Y_bar[agent_j, :10])\n", + "\n", + "# 2) Rotate\n", + "cos_yaw = torch.cos(theta_global[env_i])\n", + "sin_yaw = torch.sin(theta_global[env_i])\n", + "R_batched = torch.stack(\n", + " [\n", + " torch.stack([cos_yaw, sin_yaw], dim=1),\n", + " torch.stack([-sin_yaw, cos_yaw], dim=1),\n", + " ],\n", + " dim=1,\n", + ") \n", + "\n", + "print(f' ')\n", + "print(f' R = {R_batched.shape} =')\n", + "print(R_batched[agent_j, :, :])\n", + "\n", + "# 3) Transform\n", + "Y_local_batched = torch.bmm(\n", + " Y_bar_batched, R_batched.transpose(1, 2)\n", + ")\n", + "\n", + "print(\" \")\n", + "print(f' Y_local = {Y_local_batched.shape} =')\n", + "print(\n", + " Y_local_batched[agent_j, :10]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.equal(\n", + " Y_local_batched[agent_j, :], Y_local[:]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "agent_obs = env.vis.plot_agent_observation(\n", + " env_idx=env_idx,\n", + " agent_idx=highlight_agent,\n", + " figsize=(10, 10),\n", + " trajectory=Y_local,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Image.fromarray(img_from_fig(agent_obs))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agent_obs = env.vis.plot_agent_observation(\n", + " env_idx=env_idx,\n", + " agent_idx=highlight_agent,\n", + " figsize=(10, 10),\n", + " trajectory=Y_local_batched[agent_j, :]\n", + ")\n", + "\n", + "Image.fromarray(img_from_fig(agent_obs))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gpudrive", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 2af59ae5a6ad0d70391d0d8c8904f78dca282a36 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Tue, 22 Apr 2025 15:14:36 -0400 Subject: [PATCH 76/81] Better default --- baselines/ppo/config/ppo_waypoint.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 18e03618a..35cca0ae0 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -21,7 +21,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. reward_type: "follow_waypoints" waypoint_distance_scale: 0.01 speed_distance_scale: 0.01 - jerk_smoothness_scale: 0.01 + jerk_smoothness_scale: 0.001 init_mode: all_non_trivial #womd_tracks_to_predict dynamics_model: "classic" From 8fe1c0e2ac2afd3a6d049fe43b432a31af8586a8 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Tue, 22 Apr 2025 16:04:39 -0400 Subject: [PATCH 77/81] Decrease steering angle ub from pi to pi/3 --- gpudrive/env/config.py | 2 +- gpudrive/env/env_puffer.py | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index dfb9c84e3..2ea35e038 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -55,7 +55,7 @@ class EnvConfig: # Action space settings (if discretized) # Classic or Invertible Bicycle dynamics model steer_actions: torch.Tensor = torch.round( - torch.linspace(-torch.pi, torch.pi, 13), decimals=3 + torch.linspace(-torch.pi / 3, torch.pi / 3, 13), decimals=3 ) accel_actions: torch.Tensor = torch.round( torch.linspace(-4.0, 4.0, 7), decimals=3 diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 7ba994741..1c8880df3 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -282,7 +282,9 @@ def __init__( disable_classic_obs=True if lidar_obs else False, obs_radius=obs_radius, steer_actions=torch.round( - torch.linspace(-torch.pi, torch.pi, action_space_steer_disc), + torch.linspace( + -torch.pi / 3, torch.pi / 3, action_space_steer_disc + ), decimals=3, ), accel_actions=torch.round( From 641cfee799f612f02e951dfb2b4bedf35b2678d7 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Wed, 23 Apr 2025 09:19:30 -0400 Subject: [PATCH 78/81] Add agent obs to logging --- gpudrive/env/env_puffer.py | 36 ++++++++++++++++++++++++++++++++++++ gpudrive/visualize/core.py | 2 +- 2 files changed, 37 insertions(+), 1 deletion(-) diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index 1c8880df3..068204695 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -336,7 +336,9 @@ def __init__( self.was_rendered_in_rollout = { env_idx: True for env_idx in range(render_k_scenarios) } + self.agent_was_rendered_in_rollout = False self.frames = {env_idx: [] for env_idx in range(render_k_scenarios)} + self.agent_frames = [] self.global_step = 0 self.iters = 0 @@ -507,6 +509,8 @@ def step(self, action): if self.render: for render_env_idx in range(self.render_k_scenarios): self.log_video_to_wandb(render_env_idx, done_worlds) + + self.log_agent_obs_to_wandb() # Log episode statistics controlled_mask = self.controlled_agent_mask[ @@ -650,6 +654,18 @@ def render_env(self): zoom_radius=self.zoom_radius, plot_waypoints=self.plot_waypoints, ) + + agent_obs = self.env.vis.plot_agent_observation( + env_idx=0, + agent_idx=0, + figsize=(10, 10), + trajectory=self.env.reference_path[0, :, :].to( + "cpu" + ), + ) + self.agent_frames.append( + img_from_fig(agent_obs) + ) for idx, render_env_idx in enumerate(envs_to_render): self.frames[render_env_idx].append( @@ -678,8 +694,28 @@ def clear_render_storage(self): """Clear rendering storage.""" for env_idx in range(self.render_k_scenarios): self.frames[env_idx] = [] + self.agent_frames = [] self.rendering_in_progress[env_idx] = False self.was_rendered_in_rollout[env_idx] = False + self.agent_was_rendered_in_rollout = False + + def log_agent_obs_to_wandb(self): + """Log agent observation to wandb.""" + + frames_array = np.array(self.agent_frames) + if frames_array.shape[0] > 10: + self.wandb_obj.log( + { + f"vis/agent_obs/env_0": wandb.Video( + np.moveaxis(frames_array, -1, 1), + fps=self.render_fps, + format=self.render_format, + caption=f"global step: {self.global_step:,}", + ) + } + ) + self.agent_frames = [] + self.agent_was_rendered_in_rollout = True def log_video_to_wandb(self, render_env_idx, done_worlds): """Log arrays as videos to wandb.""" diff --git a/gpudrive/visualize/core.py b/gpudrive/visualize/core.py index 30af87d1d..71c4ee2d8 100644 --- a/gpudrive/visualize/core.py +++ b/gpudrive/visualize/core.py @@ -1638,7 +1638,7 @@ def plot_agent_observation( if observation_ego is not None: ego_agent_color = ( - "darkred" + "r" if observation_ego.is_collided[env_idx, agent_idx] else REL_OBS_OBJ_COLORS["ego"] ) From 53697ba478aade67fbf8f8698d51a3eadc9aa486 Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Wed, 23 Apr 2025 09:59:48 -0400 Subject: [PATCH 79/81] Linting --- baselines/ppo/ppo_pufferlib.py | 1 + gpudrive/datatypes/trajectory.py | 14 +++++++------- gpudrive/env/config.py | 4 +--- gpudrive/env/env_puffer.py | 18 +++++++----------- gpudrive/env/env_torch.py | 27 +++++++++++++++------------ gpudrive/visualize/core.py | 6 +++--- 6 files changed, 34 insertions(+), 36 deletions(-) diff --git a/baselines/ppo/ppo_pufferlib.py b/baselines/ppo/ppo_pufferlib.py index 36b29701a..b92467459 100644 --- a/baselines/ppo/ppo_pufferlib.py +++ b/baselines/ppo/ppo_pufferlib.py @@ -79,6 +79,7 @@ def make_agent(env, config): config=config.environment, ) + def train(args, vecenv): """Main training loop for the PPO agent.""" policy = make_agent(env=vecenv.driver_env, config=args).to( diff --git a/gpudrive/datatypes/trajectory.py b/gpudrive/datatypes/trajectory.py index dec791b66..92541571b 100644 --- a/gpudrive/datatypes/trajectory.py +++ b/gpudrive/datatypes/trajectory.py @@ -91,7 +91,9 @@ def from_tensor( """Creates an LogTrajectory from a tensor.""" if backend == "torch": return cls( - expert_traj_tensor.to_torch().clone().to(device), num_worlds, max_agents + expert_traj_tensor.to_torch().clone().to(device), + num_worlds, + max_agents, ) # Pass the entire tensor elif backend == "jax": raise NotImplementedError("JAX backend not implemented yet.") @@ -124,16 +126,14 @@ class VBDTrajectory: position (x, y), heading (yaw), and velocity (vx, vy) for each timestep. """ - def __init__( - self, vbd_traj_tensor: torch.Tensor - ): + def __init__(self, vbd_traj_tensor: torch.Tensor): """Initializes the VBD trajectory with a tensor.""" self.pos_x = vbd_traj_tensor[:, :, :, 0] self.pos_y = vbd_traj_tensor[:, :, :, 1] self.pos_xy = torch.stack([self.pos_x, self.pos_y], dim=3) self.yaw = vbd_traj_tensor[:, :, :, 2] self.vel_x = vbd_traj_tensor[:, :, :, 3] - self.vel_y = vbd_traj_tensor[:, :, :, 4] + self.vel_y = vbd_traj_tensor[:, :, :, 4] @classmethod def from_tensor( @@ -153,7 +153,7 @@ def from_tensor( # # Reshape for broadcasting # mean_x_reshaped = mean_x.view(-1, 1, 1) # mean_y_reshaped = mean_y.view(-1, 1, 1) - + # # Apply to x and y coordinates # self.trajectories[..., 0] += mean_x_reshaped - # self.trajectories[..., 1] += mean_y_reshaped \ No newline at end of file + # self.trajectories[..., 1] += mean_y_reshaped diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py index f193c3193..186aca52c 100755 --- a/gpudrive/env/config.py +++ b/gpudrive/env/config.py @@ -159,9 +159,7 @@ class EnvConfig: agent_size_scale: float = madrona_gpudrive.vehicleScale # Initialization mode - init_mode: str = ( - "all_non_trivial" # Options: all_non_trivial, all_objects, all_valid, womd_tracks_to_predict - ) + init_mode: str = "all_non_trivial" # Options: all_non_trivial, all_objects, all_valid, womd_tracks_to_predict # VBD model settings use_vbd: bool = False diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py index f8fe30dec..630b26b19 100644 --- a/gpudrive/env/env_puffer.py +++ b/gpudrive/env/env_puffer.py @@ -245,7 +245,7 @@ def __init__( # VBD self.vbd_trajectory_weight = vbd_trajectory_weight self.use_vbd = use_vbd - + # Total number of agents across envs, including padding self.total_agents = self.max_cont_agents_per_env * self.num_worlds @@ -505,7 +505,7 @@ def step(self, action): if self.render: for render_env_idx in range(self.render_k_scenarios): self.log_video_to_wandb(render_env_idx, done_worlds) - + self.log_agent_obs_to_wandb() # Log episode statistics @@ -650,18 +650,14 @@ def render_env(self): zoom_radius=self.zoom_radius, plot_waypoints=self.plot_waypoints, ) - + agent_obs = self.env.vis.plot_agent_observation( env_idx=0, agent_idx=0, figsize=(10, 10), - trajectory=self.env.reference_path[0, :, :].to( - "cpu" - ), - ) - self.agent_frames.append( - img_from_fig(agent_obs) + trajectory=self.env.reference_path[0, :, :].to("cpu"), ) + self.agent_frames.append(img_from_fig(agent_obs)) for idx, render_env_idx in enumerate(envs_to_render): self.frames[render_env_idx].append( @@ -694,10 +690,10 @@ def clear_render_storage(self): self.rendering_in_progress[env_idx] = False self.was_rendered_in_rollout[env_idx] = False self.agent_was_rendered_in_rollout = False - + def log_agent_obs_to_wandb(self): """Log agent observation to wandb.""" - + frames_array = np.array(self.agent_frames) if frames_array.shape[0] > 10: self.wandb_obj.log( diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py index 083079ad3..f57b378f7 100755 --- a/gpudrive/env/env_torch.py +++ b/gpudrive/env/env_torch.py @@ -10,7 +10,11 @@ from gpudrive.env import constants from gpudrive.env.config import EnvConfig, RenderConfig from gpudrive.env.base_env import GPUDriveGymEnv -from gpudrive.datatypes.trajectory import LogTrajectory, to_local_frame, VBDTrajectory +from gpudrive.datatypes.trajectory import ( + LogTrajectory, + to_local_frame, + VBDTrajectory, +) from gpudrive.datatypes.roadgraph import ( LocalRoadGraphPoints, GlobalRoadGraphPoints, @@ -178,7 +182,7 @@ def _generate_sample_batch(self, init_steps=10): self.num_worlds, self.max_agent_count, backend=self.backend, - device=self.device + device=self.device, ) log_trajectory.restore_mean( mean_x=means_xy[:, 0], mean_y=means_xy[:, 1] @@ -207,7 +211,7 @@ def _generate_sample_batch(self, init_steps=10): metadata = Metadata.from_tensor( metadata_tensor=self.sim.metadata_tensor(), backend=self.backend, - device=self.device + device=self.device, ) sample_batch = process_scenario_data( max_controlled_agents=self.max_cont_agents, @@ -1381,7 +1385,7 @@ def _get_vbd_obs(self, mask=None): ) return ego_vbd_trajectories - + def _normalize_vbd_obs(self, trajectories_flat, traj_len): """ Normalize flattened VBD trajectory values to be between -1 and 1, with clipping. @@ -1447,10 +1451,7 @@ def get_obs(self, mask=None): partner_observations = self._get_partner_obs(mask) road_map_observations = self._get_road_map_obs(mask) - if ( - self.use_vbd - and self.config.vbd_in_obs - ): + if self.use_vbd and self.config.vbd_in_obs: # Add ego-centric VBD trajectories vbd_observations = self._get_vbd_obs(mask) @@ -1603,17 +1604,19 @@ def _load_vbd_trajectories(self): """Load VBD trajectories directly from the simulator.""" if not self.use_vbd: return - + # Get VBD trajectories from the simulator vbd_traj = VBDTrajectory.from_tensor( self.sim.vbd_trajectory_tensor(), backend=self.backend, device=self.device, ) - - means_xy = self.sim.world_means_tensor().to_torch()[:, :2].to(self.device) + + means_xy = ( + self.sim.world_means_tensor().to_torch()[:, :2].to(self.device) + ) vbd_traj.restore_mean(mean_x=means_xy[:, 0], mean_y=means_xy[:, 1]) - + self.vbd_trajectories = vbd_traj.trajectories def get_expert_actions(self): diff --git a/gpudrive/visualize/core.py b/gpudrive/visualize/core.py index 359c56589..02545c92f 100644 --- a/gpudrive/visualize/core.py +++ b/gpudrive/visualize/core.py @@ -316,7 +316,7 @@ def plot_simulator_state( log_trajectory=self.log_trajectory, line_width_scale=line_width_scale, ) - + if plot_vbd_trajectory: self._plot_vbd_trajectory( ax=ax, @@ -711,7 +711,7 @@ def _plot_waypoints( alpha=0.35, zorder=0, ) - + def _plot_vbd_trajectory( self, ax: matplotlib.axes.Axes, @@ -793,7 +793,7 @@ def _plot_vbd_trajectory( alpha=0.35, zorder=0, ) - + def _plot_vbd_trajectory( self, ax: matplotlib.axes.Axes, From 99bc10b7771a224134f464f97366f7dab4572c2b Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Wed, 23 Apr 2025 10:03:10 -0400 Subject: [PATCH 80/81] Set group --- baselines/ppo/config/ppo_waypoint.yaml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 35cca0ae0..50bfe3ef6 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -49,7 +49,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. wandb: entity: "" project: "humanlike" - group: "wosac_test_mini" + group: " " mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] @@ -106,10 +106,10 @@ train: checkpoint_path: "./runs" # # # Rendering # # # - render: false # Determines whether to render the environment (note: will slow down training) + render: true # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d - render_interval: 10 # Render every k iterations - render_k_scenarios: 3 # Number of scenarios to render + render_interval: 150 # Render every k iterations + render_k_scenarios: 2 # Number of scenarios to render render_format: "mp4" # Options: gif, mp4 render_fps: 20 # Frames per second zoom_radius: 100 From 0b03ae7d33e4d8781a81d306e611f7904339868a Mon Sep 17 00:00:00 2001 From: Daphne Cornelisse Date: Wed, 23 Apr 2025 10:09:57 -0400 Subject: [PATCH 81/81] Fix config --- baselines/ppo/config/ppo_waypoint.yaml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml index 50bfe3ef6..7f44980b9 100644 --- a/baselines/ppo/config/ppo_waypoint.yaml +++ b/baselines/ppo/config/ppo_waypoint.yaml @@ -35,9 +35,9 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. collision_weight: -0.2 off_road_weight: -0.2 - # Versatile Behavior Diffusion (VBD): This will slow down training + # Versatile Behavior Diffusion (VBD) use_vbd: false - vbd_model_path: "gpudrive/integrations/vbd/weights/epoch=18.ckpt" + init_steps: 0 vbd_trajectory_weight: 0.1 # Importance of distance to the vbd trajectories in the reward function vbd_in_obs: false @@ -49,7 +49,7 @@ environment: # Overrides default environment configs (see pygpudrive/env/config. wandb: entity: "" project: "humanlike" - group: " " + group: "debug" mode: "online" # Options: online, offline, disabled tags: ["ppo", "ff"] @@ -106,7 +106,7 @@ train: checkpoint_path: "./runs" # # # Rendering # # # - render: true # Determines whether to render the environment (note: will slow down training) + render: false # Determines whether to render the environment (note: will slow down training) render_3d: false # Render simulator state in 3d or 2d render_interval: 150 # Render every k iterations render_k_scenarios: 2 # Number of scenarios to render