PolicyGradient/policygradient_discrete_exercise.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Metadrive Intro\n",
    "\n",
    "We now introduce the environment we will be using for this notebook: [Metadrive](https://github.com/metadriverse/metadrive)\n",
    "\n",
    "Check out the notebook [here](../quickstart.ipynb) for a quick introduction to Metadrive as well as how to install it."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's get started by doing a bunch of imports."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "import typing\n",
    "import numpy as np\n",
    "import numpy.typing as npt\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from dataclasses import dataclass"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're going to be using MetaDrive's top-down view for this notebook, so we'll import that and register it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/fidgetsinner/venvs/metadrive/lib/python3.11/site-packages/gymnasium/envs/registration.py:693: UserWarning: WARN: Overriding environment MetaDrive-topdown already in registry.\n",
      "  logger.warn(f\"Overriding environment {new_spec.id} already in registry.\")\n"
     ]
    }
   ],
   "source": [
    "from metadrive.envs.top_down_env import TopDownMetaDrive\n",
    "gym.register(id=\"MetaDrive-topdown\", entry_point=TopDownMetaDrive, kwargs=dict(config={}))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's test out the environment by creating an instance of it and taking a random action at each timestep."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Known pipe types:\n",
      "  glxGraphicsPipe\n",
      "(1 aux display modules not yet loaded.)\n",
      ":task(warning): Creating implicit AsyncTaskChain default for AsyncTaskManager TaskManager\n",
      "INFO:/home/fidgetsinner/myworkspace/metadrive/metadrive/envs/base_env.py:Episode ended! Index: 0 Reason: max step \n"
     ]
    }
   ],
   "source": [
    "# horizon represents the number of steps in an episode before truncation\n",
    "env = gym.make(\"MetaDrive-topdown\", config={\"use_render\": True, \"horizon\": 100})\n",
    "env.reset()\n",
    "while True:\n",
    "    obs, reward, terminated, truncated, info = env.step(env.action_space.sample())\n",
    "    if terminated or truncated:\n",
    "        break\n",
    "env.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gymnasium Environment"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metadrive uses the [Farama Gymnasium](https://gymnasium.farama.org/), which has a standard API for interacting with environments. There are a couple of functions and properties that are good to know about:\n",
    "1. `reset()`: Resets the environment to its initial state and returns the initial observation.\n",
    "    * Documentation: https://gymnasium.farama.org/api/env/#gymnasium.Env.reset\n",
    "2. `step(action)`: Takes an action and returns the next observation, the reward for taking the action, whether the episode is terminated, whether the episode is truncated (ran out of time), and any additional information.\n",
    "    * Documentation: https://gymnasium.farama.org/api/env/#gymnasium.Env.step\n",
    "3. `close()`: Closes the environment.\n",
    "    * Documentation: https://gymnasium.farama.org/api/env/#g1ymnasium.Env.close\n",
    "4. `action_space`: The action space of the environment, which tells us the shape and bounds of the action space.\n",
    "    * Documentation: https://gymnasium.farama.org/api/env/#gymnasium.Env.action_space\n",
    "5. `observation_space`: The observation space of the environment, which tells us the shape and bounds of the observation space.\n",
    "    * Documentation: https://gymnasium.farama.org/api/env/#gymnasium.Env.observation_space"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a closer look at what our observation and action spaces are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Observation Space: Box(-0.0, 1.0, (84, 84, 5), float32)\n",
      "Action Space: Box(-1.0, 1.0, (2,), float32)\n"
     ]
    }
   ],
   "source": [
    "env = gym.make(\"MetaDrive-topdown\", config={\"use_render\": False, \"horizon\": 100})\n",
    "print(\"Observation Space:\", env.observation_space)\n",
    "print(\"Action Space:\", env.action_space)\n",
    "env.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Box spaces represent a continuous space. As the documentation states, a Box represents the Cartesian product of $n$ closed intervals.\n",
    "\n",
    "For our observation space, we have a 84 by 84 pixel image with 5 channels, where each element is in the range $[0.0, 1.0]$.\n",
    "* Documentation: https://metadrive-simulator.readthedocs.io/en/latest/observation.html\n",
    "\n",
    "For the action space, we have a 2 dimensional vector, where each element is in the range $[-1.0, 1.0]$. The first element represents the steering angle, and the second element represents the throttle.\n",
    "* Documentation: https://metadrive-simulator.readthedocs.io/en/latest/action_and_dynamics.html\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementation\n",
    "\n",
    "Now that we've seen what the environment looks like, let's implement REINFORCE.\n",
    "\n",
    "The REINFORCE algorithm is as follows:\n",
    "1. Initialize the policy parameters $\\theta$.\n",
    "2. Create an initially empty set of trajectories $D$.\n",
    "3. Create a trajectory $\\tau = (s_1, a_1, r_1, \\ldots, s_T, a_T, r_T)$ by running the policy $\\pi_\\theta$ in the environment and append it to $D$.\n",
    "4. Compute the return $\\hat{R}_t$ for each timestep $t$ in the trajectory.\n",
    "5. Repeat steps 2-4 until $|D| = N$.\n",
    "6. Compute the policy gradient estimate $\\hat{g} = \\frac{1}{N} \\sum_{i=1}^N \\sum_{t=1}^{T_i} \\nabla_\\theta \\log \\pi_\\theta(a_{i,t} | s_{i,t}) \\hat{R}_t$.\n",
    "7. Update the policy parameters $\\theta \\leftarrow \\theta + \\alpha \\hat{g}$.\n",
    "8. Repeat steps 2-7 until the policy converges.\n",
    "\n",
    "All things considered, this is a pretty simple algorithm. Let's implement it!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Discretization"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's one problem you might see here: we previously stated that we were focusing on the discrete case. This means our policy will produce discrete actions. However, our action space seems to be continuous.\n",
    "\n",
    "How can we solve this problem?\n",
    "\n",
    "Our solution is going to be to **discretize** our action space. This means that we will provide a finite number of actions, and each action corresponds to a fixed vector of real numbers.\n",
    "\n",
    "We will discretize the steering angle into 2 bins, and the throttle into 2 bins. This will give us a total of 4 actions. We'll write a function to convert our discrete action into a continuous action, which we can provide to the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_ACTIONS = 5\n",
    "\n",
    "def discrete2continuous(action:int) -> npt.NDArray[np.float32]:\n",
    "    \"\"\"\n",
    "    Convert discrete action to continuous action\n",
    "    \"\"\"\n",
    "    assert 0 <= action < NUM_ACTIONS\n",
    "    throttle_magnitude = 1.0\n",
    "    brake_magnitude = 1.0\n",
    "    steering_magnitude = 1.0\n",
    "    match action:\n",
    "        case 0:\n",
    "            return np.array([steering_magnitude, 0.0])\n",
    "        case 1:\n",
    "            return np.array([0.0, throttle_magnitude])\n",
    "        case 2:\n",
    "            return np.array([0.0, -brake_magnitude])\n",
    "        case 3:\n",
    "            return np.array([-steering_magnitude, 0.0])\n",
    "        case 4:\n",
    "            return np.array([0.0, 0.0])\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Collecting Trajectories"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this discretization function, we can write a function to collect a trajectory given a policy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def collect_trajectory(env:gym.Env, policy:typing.Callable[[npt.NDArray], int]) -> tuple[list[npt.NDArray], list[int], list[float]]:\n",
    "    \"\"\"\n",
    "    Collect a trajectory from the environment using the given policy\n",
    "    \"\"\"\n",
    "    observations = []\n",
    "    actions = []\n",
    "    rewards = []\n",
    "    obs, info = env.reset()\n",
    "    \n",
    "    while True:\n",
    "        observations.append(obs)\n",
    "        action = policy(obs)\n",
    "        actions.append(action)\n",
    "        obs, reward, terminated, truncated, info = env.step(discrete2continuous(action))\n",
    "        rewards.append(reward)\n",
    "        if terminated or truncated:\n",
    "            break\n",
    "\n",
    "    return observations, actions, rewards"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we define a policy as any function that takes in an observation and returns an action. This means that we can be more general than just using a neural net as a policy.\n",
    "For example, let's first test out our `collect_trajectory` function with a random policy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      ":task(warning): Creating implicit AsyncTaskChain default for AsyncTaskManager TaskManager\n",
      "INFO:/home/fidgetsinner/myworkspace/metadrive/metadrive/envs/base_env.py:Episode ended! Index: 0 Reason: max step \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actions: [1, 0, 1, 0, 2, 0, 4, 3, 1, 1]\n",
      "Rewards: [0.0002485517263412476, 0.003777462642728572, 0.013420774176964221, 0.02909287183133027, 0.006593909463546951, -0.010728848998074313, -0.009734169748365605, -0.005691646270093323, 0.00582868244940761, 0.033758088482578406]\n"
     ]
    }
   ],
   "source": [
    "env = gym.make(\"MetaDrive-topdown\", config={\"use_render\": False, \"horizon\": 100})\n",
    "# horizon is the max number of steps in a trajectory\n",
    "def random_policy(obs:npt.NDArray) -> int:\n",
    "    \"\"\"\n",
    "    A random policy that returns a random action\n",
    "    \"\"\"\n",
    "    return np.random.randint(0, NUM_ACTIONS)\n",
    "\n",
    "obs, actions, rewards = collect_trajectory(env, random_policy)\n",
    "\n",
    "# print the first 10 actions and rewards\n",
    "print(\"Actions:\", actions[:10])\n",
    "print(\"Rewards:\", rewards[:10])\n",
    "env.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reward-to-go (Contains Exercise)\n",
    "\n",
    "Our `collect_trajectory` function allows us to gather rewards from the trajectory. However, recall that what we'll actually train the network on is the reward-to-go. Let's now create the function `reward_to_go` to compute the reward-to-go for each timestep in the trajectory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rewards_to_go(trajectory_rewards: list[float], gamma) -> list[float]:\n",
    "    \"\"\"\n",
    "    Computes the gamma discounted reward-to-go for each state in the trajectory.\n",
    "    \"\"\"\n",
    "    # TODO: Implement this function\n",
    "    raise NotImplementedError()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Policy Network (Contains Exercise)\n",
    "\n",
    "So, now that we have a function that lets us go from policies to trajectories, we should work on creating a neural network based policy. The network should take in an observation, and return a probability for each number between 0 and 9.\n",
    "\n",
    "We're going to keep the network fairly small for now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PolicyNetwork(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        #########################################################################################\n",
    "        # TODO: Implement a Policy Network\n",
    "        # Architecture:\n",
    "        # Layer 1 - Convolutional Layer, kernel size 8, stride 4, output channels 16\n",
    "        # Layer 2 - Convolutional Layer, kernel size 4, stride 2, output channels 32\n",
    "        # Layer 3 - Fully Connected Layer, output size 256\n",
    "        # Layer 4 - Fully Connected Layer, output size NUM_ACTIONS\n",
    "\n",
    "        raise NotImplementedError()\n",
    "\n",
    "        #########################################################################################\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.distributions.Categorical:\n",
    "        #########################################################################################\n",
    "        # TODO: Implement the forward pass of the Policy Network\n",
    "        # Hint: Use logits when constructing the Categorical distribution\n",
    "\n",
    "        raise NotImplementedError()\n",
    "    \n",
    "        #########################################################################################"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's one minor issue we have to resolve before we can use this network though: [PyTorch's Conv2d module](https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html) expects the input to be of shape $(N, C_{in}, H_{in}, W_{in})$, where $N$ is the batch size, $C_{in}$ is the number of channels, $H_{in}$ is the height, and $W_{in}$ is the width. However, our observation is of shape $(H_{in}, W_{in}, C_{in})$. We can fix this by adding a batch dimension and then using the [Permute](https://pytorch.org/docs/stable/generated/torch.permute.html) module. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def obs_batch_to_tensor(obs: list[npt.NDArray[np.float32]], device: torch.device) -> torch.Tensor:\n",
    "    \"\"\"\n",
    "    Reshape the image observation from (B, H, W, C) to (B, C, H, W) and convert it to a tensor\n",
    "    \"\"\"\n",
    "    return torch.tensor(np.stack(obs), dtype=torch.float32, device=device).permute(0, 3, 1, 2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define a policy function that allows us to sample an action:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def deviceof(m: nn.Module) -> torch.device:\n",
    "    \"\"\"\n",
    "    Get the device of the given module\n",
    "    \"\"\"\n",
    "    return next(m.parameters()).device\n",
    "\n",
    "class NNPolicy:\n",
    "    \"\"\"\n",
    "    A policy based on a neural network \n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, net:PolicyNetwork):\n",
    "        self.net = net\n",
    "\n",
    "    def __call__(self, obs:npt.NDArray) -> int:\n",
    "        # convert observation to a tensor\n",
    "        obs_tensor = obs_batch_to_tensor([obs], deviceof(self.net))\n",
    "        # sample an action from the policy network\n",
    "        with torch.no_grad():\n",
    "            return self.net(obs_tensor).sample().item()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's test it out (untrained)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = gym.make(\"MetaDrive-topdown\", config={\"use_render\": False, \"horizon\": 100})\n",
    "\n",
    "# create a policy network\n",
    "policy_network = PolicyNetwork()\n",
    "\n",
    "# create a policy that samples from the policy network\n",
    "policy = NNPolicy(policy_network)\n",
    "\n",
    "# collect a trajectory using our untrained network\n",
    "obs, actions, rewards = collect_trajectory(env, policy)\n",
    "\n",
    "# print the first 10 actions and rewards\n",
    "print(\"Actions:\", actions[:10])\n",
    "print(\"Rewards:\", rewards[:10])\n",
    "\n",
    "env.close()\n",
    "\n",
    "# free up memory\n",
    "del policy\n",
    "del policy_network"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, it performs basically random actions, since it hasn't been trained yet."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computing the Policy Gradient (Contains Exercise)\n",
    "\n",
    "Let's now work on the meat of the problem: computing the policy gradient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class PolicyGradientConfig:\n",
    "    entropy_bonus: float\n",
    "\n",
    "def compute_policy_gradient_loss(\n",
    "    # Current policy network's probability of choosing an action\n",
    "    # inner shape = (Batch, Action)\n",
    "    pi_theta_given_st: torch.distributions.Categorical,\n",
    "    # Which action was chosen\n",
    "    # in (Batch,)\n",
    "    a_t: torch.Tensor,\n",
    "    # Rewards To Go for the chosen action\n",
    "    # in (Batch,)\n",
    "    R_t: torch.Tensor,\n",
    "    # config\n",
    "    config: PolicyGradientConfig,\n",
    ") -> torch.Tensor:\n",
    "    r\"\"\"\n",
    "    Computes the policy gradient loss for a vector of examples, and reduces with mean.\n",
    "\n",
    "    The standard policy gradient is given by the expected value over trajectories of:\n",
    "\n",
    "    :math:`\\sum_{t=0}^{T} \\nabla_{\\theta} (\\log \\pi_{\\theta}(a_t|s_t))R_t`\n",
    "    \n",
    "    where:\n",
    "    * :math:`\\pi_{\\theta}(a_t|s_t)` is the current policy's probability to perform action :math:`a_t` given :math:`s_t`\n",
    "    * :math:`R_t` is the rewards-to-go from the state at time t to the end of the episode from which it came.\n",
    "    \"\"\"\n",
    "\n",
    "    ################################################################################################\n",
    "    # TODO: Implement the policy gradient loss\n",
    "    # Hint: Recall that the policy gradient for a single transition (state-action pair) is given by:\n",
    "    # $\\nabla_{\\theta} \\log \\pi_{\\theta}(a_t|s_t)R_t$\n",
    "    # However, it's easier to work with losses, rather than raw gradients.\n",
    "    # Therefore we construct a loss, that when differentiated, gives us the policy gradient.\n",
    "    # this loss is given by: $-\\log \\pi_{\\theta}(a_t|s_t)R_t$\n",
    "    # Hint: use the log_prob method of the Categorical distribution to get the log probability of the chosen action\n",
    "\n",
    "    raise NotImplementedError()\n",
    "\n",
    "    ################################################################################################\n",
    "\n",
    "\n",
    "def train_policygradient(\n",
    "    policy_network: PolicyNetwork,\n",
    "    policy_optimizer: torch.optim.Optimizer,\n",
    "    observation_batch: list[npt.NDArray],\n",
    "    action_batch: list[int],\n",
    "    rtg_batch: list[float],\n",
    "    config: PolicyGradientConfig,\n",
    ") -> float:\n",
    "    # assert that the batch_lengths are the same\n",
    "    assert len(observation_batch) == len(action_batch)\n",
    "    assert len(observation_batch) == len(rtg_batch)\n",
    "\n",
    "    # get device\n",
    "    device = deviceof(policy_network)\n",
    "\n",
    "    # convert data to tensors on correct device\n",
    "\n",
    "    # in (Batch, C, H, W)\n",
    "    observation_batch_tensor = obs_batch_to_tensor(observation_batch, device)\n",
    "\n",
    "    # in (Batch,)\n",
    "    rtg_batch_tensor = torch.tensor(\n",
    "        rtg_batch, dtype=torch.float32, device=device\n",
    "    )\n",
    "\n",
    "    # in (Batch,)\n",
    "    chosen_action_tensor = torch.tensor(action_batch, dtype=torch.long, device=device)\n",
    "\n",
    "    # train policy network\n",
    "    policy_optimizer.zero_grad()\n",
    "    action_probs = policy_network.forward(observation_batch_tensor)\n",
    "    policy_loss = compute_policy_gradient_loss(\n",
    "        action_probs, chosen_action_tensor, rtg_batch_tensor, config\n",
    "    )\n",
    "    policy_loss.backward()\n",
    "    policy_optimizer.step()\n",
    "\n",
    "    # return the respective losses\n",
    "    return policy_loss.item()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training the Policy Network\n",
    "\n",
    "With that, we're done. Let's train!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# disable logging from metadrive\n",
    "import logging\n",
    "import inspect\n",
    "import metadrive.envs.top_down_env\n",
    "logging.getLogger(inspect.getfile(metadrive.envs.base_env)).setLevel(logging.WARNING)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_lr(optimizer: torch.optim.Optimizer, lr: float) -> None:\n",
    "    for param_group in optimizer.param_groups:\n",
    "        param_group['lr'] = lr\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "policy_network = PolicyNetwork().to(device)\n",
    "\n",
    "policy_optimizer = torch.optim.Adam(policy_network.parameters())\n",
    "\n",
    "policy = NNPolicy(policy_network)\n",
    "\n",
    "step = 0\n",
    "returns = []\n",
    "losses = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = gym.make(\"MetaDrive-topdown\", config={\"use_render\": False, \"horizon\": 100, \"num_scenarios\": 100})"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code takes a long time to run, but the low learning rate and high batch sizes are a necessity for training REINFORCE. You should leave this code running for about an hour. Don't be surprised if it takes a long time for rewards to creep over 3.0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      ":task(warning): Creating implicit AsyncTaskChain default for AsyncTaskManager TaskManager\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 0, Avg. Returns: 1.274 +/- 0.431, Median: 1.193, Policy Loss: -0.081\n",
      "Step 1, Avg. Returns: 1.418 +/- 0.740, Median: 1.391, Policy Loss: -0.072\n",
      "Step 2, Avg. Returns: 1.184 +/- 0.617, Median: 1.121, Policy Loss: -0.087\n",
      "Step 3, Avg. Returns: 1.462 +/- 0.444, Median: 1.426, Policy Loss: -0.070\n",
      "Step 4, Avg. Returns: 1.539 +/- 0.496, Median: 1.514, Policy Loss: -0.065\n",
      "Step 5, Avg. Returns: 1.679 +/- 0.584, Median: 1.498, Policy Loss: -0.056\n",
      "Step 6, Avg. Returns: 1.482 +/- 0.586, Median: 1.483, Policy Loss: -0.069\n",
      "Step 7, Avg. Returns: 1.762 +/- 0.663, Median: 1.619, Policy Loss: -0.051\n",
      "Step 8, Avg. Returns: 1.547 +/- 0.585, Median: 1.480, Policy Loss: -0.065\n",
      "Step 9, Avg. Returns: 1.496 +/- 1.080, Median: 1.286, Policy Loss: -0.068\n",
      "Step 10, Avg. Returns: 1.877 +/- 0.736, Median: 1.840, Policy Loss: -0.046\n",
      "Step 11, Avg. Returns: 2.077 +/- 0.799, Median: 2.036, Policy Loss: -0.033\n",
      "Step 12, Avg. Returns: 1.701 +/- 0.605, Median: 1.477, Policy Loss: -0.057\n",
      "Step 13, Avg. Returns: 2.028 +/- 0.686, Median: 1.921, Policy Loss: -0.037\n",
      "Step 14, Avg. Returns: 1.988 +/- 0.772, Median: 1.856, Policy Loss: -0.040\n",
      "Step 15, Avg. Returns: 2.443 +/- 0.948, Median: 2.274, Policy Loss: -0.013\n",
      "Step 16, Avg. Returns: 2.431 +/- 0.888, Median: 2.422, Policy Loss: -0.014\n",
      "Step 17, Avg. Returns: 2.223 +/- 0.862, Median: 2.005, Policy Loss: -0.026\n",
      "Step 18, Avg. Returns: 2.563 +/- 0.829, Median: 2.479, Policy Loss: -0.007\n",
      "Step 19, Avg. Returns: 2.784 +/- 0.821, Median: 2.803, Policy Loss: 0.006\n",
      "Step 20, Avg. Returns: 2.482 +/- 0.979, Median: 2.399, Policy Loss: -0.012\n",
      "Step 21, Avg. Returns: 3.360 +/- 0.995, Median: 3.217, Policy Loss: 0.038\n",
      "Step 22, Avg. Returns: 3.364 +/- 1.652, Median: 3.246, Policy Loss: 0.038\n",
      "Step 23, Avg. Returns: 2.739 +/- 1.052, Median: 2.895, Policy Loss: 0.002\n",
      "Step 24, Avg. Returns: 3.455 +/- 1.606, Median: 2.995, Policy Loss: 0.039\n",
      "Step 25, Avg. Returns: 4.098 +/- 1.178, Median: 3.908, Policy Loss: 0.078\n",
      "Step 26, Avg. Returns: 3.943 +/- 1.875, Median: 3.945, Policy Loss: 0.066\n",
      "Step 27, Avg. Returns: 4.104 +/- 1.618, Median: 4.035, Policy Loss: 0.081\n",
      "Step 28, Avg. Returns: 4.137 +/- 2.323, Median: 4.390, Policy Loss: 0.084\n",
      "Step 29, Avg. Returns: 5.769 +/- 2.802, Median: 4.616, Policy Loss: 0.163\n",
      "Step 30, Avg. Returns: 5.004 +/- 2.364, Median: 4.800, Policy Loss: 0.125\n",
      "Step 31, Avg. Returns: 5.959 +/- 3.192, Median: 5.456, Policy Loss: 0.173\n",
      "Step 32, Avg. Returns: 7.089 +/- 4.420, Median: 6.375, Policy Loss: 0.237\n",
      "Step 33, Avg. Returns: 6.883 +/- 4.442, Median: 6.606, Policy Loss: 0.223\n",
      "Step 34, Avg. Returns: 7.172 +/- 3.898, Median: 7.117, Policy Loss: 0.248\n",
      "Step 35, Avg. Returns: 9.872 +/- 6.697, Median: 8.495, Policy Loss: 0.368\n",
      "Step 36, Avg. Returns: 9.365 +/- 6.328, Median: 6.355, Policy Loss: 0.364\n",
      "Step 37, Avg. Returns: 11.503 +/- 7.568, Median: 10.363, Policy Loss: 0.471\n",
      "Step 38, Avg. Returns: 13.342 +/- 10.145, Median: 9.631, Policy Loss: 0.552\n",
      "Step 39, Avg. Returns: 15.600 +/- 9.769, Median: 15.264, Policy Loss: 0.695\n",
      "Step 40, Avg. Returns: 17.876 +/- 13.929, Median: 14.179, Policy Loss: 0.757\n",
      "Step 41, Avg. Returns: 21.780 +/- 8.328, Median: 20.517, Policy Loss: 0.952\n",
      "Step 42, Avg. Returns: 19.974 +/- 13.416, Median: 19.793, Policy Loss: 0.914\n",
      "Step 43, Avg. Returns: 25.590 +/- 16.930, Median: 26.594, Policy Loss: 1.261\n",
      "Step 44, Avg. Returns: 24.644 +/- 21.342, Median: 20.927, Policy Loss: 1.222\n",
      "Step 45, Avg. Returns: 31.430 +/- 20.134, Median: 23.211, Policy Loss: 1.305\n",
      "Step 46, Avg. Returns: 40.744 +/- 21.024, Median: 40.887, Policy Loss: 1.755\n",
      "Step 47, Avg. Returns: 31.127 +/- 18.163, Median: 36.269, Policy Loss: 1.491\n",
      "Step 48, Avg. Returns: 35.278 +/- 22.462, Median: 34.464, Policy Loss: 1.551\n",
      "Step 49, Avg. Returns: 38.453 +/- 21.445, Median: 44.948, Policy Loss: 1.690\n",
      "Step 50, Avg. Returns: 40.475 +/- 15.372, Median: 41.799, Policy Loss: 1.655\n",
      "Step 51, Avg. Returns: 44.388 +/- 21.288, Median: 45.028, Policy Loss: 1.896\n",
      "Step 52, Avg. Returns: 40.492 +/- 23.513, Median: 39.880, Policy Loss: 1.675\n",
      "Step 53, Avg. Returns: 42.698 +/- 20.051, Median: 42.882, Policy Loss: 1.797\n",
      "Step 54, Avg. Returns: 34.564 +/- 24.046, Median: 30.773, Policy Loss: 1.531\n",
      "Step 55, Avg. Returns: 41.550 +/- 24.842, Median: 44.489, Policy Loss: 1.794\n",
      "Step 56, Avg. Returns: 38.080 +/- 23.562, Median: 43.898, Policy Loss: 1.671\n",
      "Step 57, Avg. Returns: 41.090 +/- 20.807, Median: 46.652, Policy Loss: 1.805\n",
      "Step 58, Avg. Returns: 40.658 +/- 24.589, Median: 47.941, Policy Loss: 1.756\n",
      "Step 59, Avg. Returns: 33.801 +/- 22.075, Median: 32.490, Policy Loss: 1.520\n",
      "Step 60, Avg. Returns: 38.396 +/- 23.918, Median: 37.815, Policy Loss: 1.689\n",
      "Step 61, Avg. Returns: 41.510 +/- 22.456, Median: 40.166, Policy Loss: 1.811\n",
      "Step 62, Avg. Returns: 38.710 +/- 24.514, Median: 43.231, Policy Loss: 1.756\n",
      "Step 63, Avg. Returns: 42.905 +/- 20.037, Median: 43.185, Policy Loss: 1.791\n",
      "Step 64, Avg. Returns: 44.599 +/- 19.113, Median: 44.548, Policy Loss: 1.929\n",
      "Step 65, Avg. Returns: 33.804 +/- 24.228, Median: 32.531, Policy Loss: 1.565\n",
      "Step 66, Avg. Returns: 35.785 +/- 16.549, Median: 34.335, Policy Loss: 1.600\n",
      "Step 67, Avg. Returns: 36.588 +/- 18.930, Median: 38.185, Policy Loss: 1.632\n",
      "Step 68, Avg. Returns: 39.163 +/- 16.489, Median: 37.851, Policy Loss: 1.638\n",
      "Step 69, Avg. Returns: 28.758 +/- 18.307, Median: 27.975, Policy Loss: 1.300\n",
      "Step 70, Avg. Returns: 25.102 +/- 19.317, Median: 24.037, Policy Loss: 1.166\n",
      "Step 71, Avg. Returns: 39.308 +/- 15.617, Median: 42.213, Policy Loss: 1.625\n",
      "Step 72, Avg. Returns: 32.841 +/- 17.382, Median: 31.667, Policy Loss: 1.398\n",
      "Step 73, Avg. Returns: 32.254 +/- 13.167, Median: 30.596, Policy Loss: 1.417\n",
      "Step 74, Avg. Returns: 28.901 +/- 17.013, Median: 29.566, Policy Loss: 1.320\n",
      "Step 75, Avg. Returns: 29.223 +/- 17.697, Median: 28.195, Policy Loss: 1.381\n",
      "Step 76, Avg. Returns: 30.945 +/- 19.306, Median: 26.168, Policy Loss: 1.388\n",
      "Step 77, Avg. Returns: 29.982 +/- 15.930, Median: 30.767, Policy Loss: 1.348\n",
      "Step 78, Avg. Returns: 25.127 +/- 14.430, Median: 25.418, Policy Loss: 1.131\n",
      "Step 79, Avg. Returns: 22.729 +/- 14.906, Median: 23.302, Policy Loss: 1.101\n",
      "Step 80, Avg. Returns: 34.997 +/- 19.200, Median: 35.014, Policy Loss: 1.506\n",
      "Step 81, Avg. Returns: 31.390 +/- 16.450, Median: 32.382, Policy Loss: 1.447\n",
      "Step 82, Avg. Returns: 27.398 +/- 15.176, Median: 25.308, Policy Loss: 1.215\n",
      "Step 83, Avg. Returns: 31.284 +/- 18.013, Median: 28.280, Policy Loss: 1.385\n",
      "Step 84, Avg. Returns: 30.838 +/- 12.782, Median: 29.096, Policy Loss: 1.369\n",
      "Step 85, Avg. Returns: 37.331 +/- 22.449, Median: 32.706, Policy Loss: 1.634\n",
      "Step 86, Avg. Returns: 27.267 +/- 15.902, Median: 25.506, Policy Loss: 1.224\n",
      "Step 87, Avg. Returns: 30.224 +/- 16.364, Median: 28.656, Policy Loss: 1.354\n",
      "Step 88, Avg. Returns: 35.631 +/- 19.394, Median: 33.702, Policy Loss: 1.591\n",
      "Step 89, Avg. Returns: 30.842 +/- 16.543, Median: 28.302, Policy Loss: 1.406\n",
      "Step 90, Avg. Returns: 35.077 +/- 19.824, Median: 36.831, Policy Loss: 1.567\n",
      "Step 91, Avg. Returns: 36.725 +/- 14.552, Median: 37.507, Policy Loss: 1.555\n",
      "Step 92, Avg. Returns: 33.265 +/- 18.976, Median: 31.205, Policy Loss: 1.504\n",
      "Step 93, Avg. Returns: 36.231 +/- 15.764, Median: 36.953, Policy Loss: 1.548\n",
      "Step 94, Avg. Returns: 32.623 +/- 18.059, Median: 34.471, Policy Loss: 1.504\n",
      "Step 95, Avg. Returns: 33.945 +/- 19.663, Median: 31.947, Policy Loss: 1.576\n",
      "Step 96, Avg. Returns: 36.691 +/- 19.986, Median: 41.280, Policy Loss: 1.625\n",
      "Step 97, Avg. Returns: 36.029 +/- 18.946, Median: 36.444, Policy Loss: 1.590\n",
      "Step 98, Avg. Returns: 32.283 +/- 19.662, Median: 29.623, Policy Loss: 1.451\n",
      "Step 99, Avg. Returns: 41.676 +/- 18.888, Median: 42.003, Policy Loss: 1.824\n"
     ]
    }
   ],
   "source": [
    "set_lr(policy_optimizer, 1e-4)\n",
    "TRAIN_EPOCHS = 100\n",
    "EPISODES_PER_BATCH = 32\n",
    "GAMMA = 0.75\n",
    "CONFIG = PolicyGradientConfig(entropy_bonus=0.10)\n",
    "\n",
    "# Train\n",
    "while step < TRAIN_EPOCHS:\n",
    "    obs_batch:list[npt.NDArray[np.float32]] = []\n",
    "    act_batch:list[int] = []\n",
    "    rtg_batch:list[float] = []\n",
    "    \n",
    "    trajectory_returns = []\n",
    "\n",
    "    for _ in range(EPISODES_PER_BATCH):\n",
    "        # Collect trajectory\n",
    "        obs_traj, act_traj, rew_traj = collect_trajectory(env, policy)\n",
    "        rtg_traj = rewards_to_go(rew_traj, GAMMA)\n",
    "\n",
    "        # Update batch\n",
    "        obs_batch.extend(obs_traj)\n",
    "        act_batch.extend(act_traj)\n",
    "        rtg_batch.extend(rtg_traj)\n",
    "\n",
    "        # Update trajectory returns\n",
    "        trajectory_returns.append(sum(rew_traj))\n",
    "\n",
    "    loss = train_policygradient(\n",
    "        policy_network,\n",
    "        policy_optimizer,\n",
    "        obs_batch,\n",
    "        act_batch,\n",
    "        rtg_batch,\n",
    "        CONFIG,\n",
    "    )\n",
    "\n",
    "    # collect statistics\n",
    "    returns.append(trajectory_returns)\n",
    "    losses.append(loss)\n",
    "\n",
    "    print(f\"Step {step}, Avg. Returns: {np.mean(trajectory_returns):.3f} +/- {np.std(trajectory_returns):.3f}, Median: {np.median(trajectory_returns):.3f}, Policy Loss: {losses[-1]:.3f}\")\n",
    "\n",
    "    step += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's visualize how the policy drives:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Known pipe types:\n",
      "  glxGraphicsPipe\n",
      "(1 aux display modules not yet loaded.)\n",
      ":task(warning): Creating implicit AsyncTaskChain default for AsyncTaskManager TaskManager\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reward: 11.85472863635404\n"
     ]
    }
   ],
   "source": [
    "env = gym.make(\"MetaDrive-topdown\", config={\"use_render\": True, \"horizon\": 500, \"num_scenarios\": 100})\n",
    "obs, act, rew = collect_trajectory(env, policy)\n",
    "env.close()\n",
    "\n",
    "print(\"Reward:\", sum(rew))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For us, we got returns of around 40-50 after training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "return_medians = [np.median(returns[i]) for i in range(len(returns))]\n",
    "return_means = [np.mean(returns[i]) for i in range(len(returns))]\n",
    "return_stds = [np.std(returns[i]) for i in range(len(returns))]\n",
    "plt.plot(return_medians, label=\"Median\")\n",
    "plt.plot(return_means, label=\"Mean\")\n",
    "plt.fill_between(range(len(return_means)), np.array(return_means) - np.array(return_stds), np.array(return_means) + np.array(return_stds), alpha=0.3)\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Average Return\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "metadrive",
   "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.3"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}