Main.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Controls Challenge Submission"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Importing Required Libraries**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import numpy as np\n",
    "import copy\n",
    "from tinyphysics_modified import TinyPhysicsModel_Modified, TinyPhysicsSimulator_Modified, CONTROL_START_IDX\n",
    "from controllers import SimpleController, BaseController\n",
    "import io\n",
    "from tinyphysics_modified_2 import TinyPhysicsModel, TinyPhysicsSimulator\n",
    "import seaborn as sns\n",
    "from matplotlib import pyplot as plt\n",
    "from IPython.display import clear_output\n",
    "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Actor Class**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Actor(nn.Module):\n",
    "    \n",
    "    def __init__(self, max_action=2):\n",
    "        super(Actor, self).__init__()\n",
    "        self.max_action = max_action\n",
    "        self.l1 = nn.Linear(7, 300)\n",
    "        self.l2 = nn.Linear(300,200)\n",
    "        self.l3 = nn.Linear(200,200)\n",
    "        self.l4 = nn.Linear(200, 1)\n",
    "\n",
    "    def forward(self, s):\n",
    "        s = F.relu(self.l1(s))\n",
    "        s = F.relu(self.l2(s))\n",
    "        s = F.relu(self.l3(s))\n",
    "        a = self.max_action * torch.tanh(self.l4(s))  # [-max,max]\n",
    "        return a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Critic Class**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Critic(nn.Module):  \n",
    "    def __init__(self):\n",
    "        super(Critic, self).__init__()\n",
    "        self.l1 = nn.Linear(8, 300)\n",
    "        self.l2 = nn.Linear(300,200)\n",
    "        self.l3 = nn.Linear(200,200)\n",
    "        self.l4 = nn.Linear(200, 1)\n",
    "\n",
    "    def forward(self, s, a):\n",
    "        q = F.relu(self.l1(torch.cat([s, a], 1)))\n",
    "        q = F.relu(self.l2(q))\n",
    "        q = F.relu(self.l3(q))\n",
    "        q = self.l4(q)\n",
    "        return q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Replay Buffer**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer(object):\n",
    "    def __init__(self, state_dim, action_dim):\n",
    "        self.max_size = int(200000)\n",
    "        self.count = 0\n",
    "        self.size = 0\n",
    "        self.s = np.zeros((self.max_size, state_dim))\n",
    "        self.a = np.zeros((self.max_size, action_dim))\n",
    "        self.r = np.zeros((self.max_size, 1))\n",
    "        self.s_ = np.zeros((self.max_size, state_dim))\n",
    "        self.dw = np.zeros((self.max_size, 1))\n",
    "\n",
    "    def store(self, s, a, r, s_, dw):\n",
    "        self.s[self.count] = s\n",
    "        self.a[self.count] = a\n",
    "        self.r[self.count] = r\n",
    "        self.s_[self.count] = s_\n",
    "        self.dw[self.count] = dw\n",
    "        self.count = (self.count + 1) % self.max_size  # When the 'count' reaches max_size, it will be reset to 0.\n",
    "        self.size = min(self.size + 1, self.max_size)  # Record the number of  transitions\n",
    "\n",
    "    def sample(self, batch_size):\n",
    "        index = np.random.choice(self.size, size=batch_size)  # Randomly sampling\n",
    "        batch_s = torch.tensor(self.s[index], dtype=torch.float)\n",
    "        batch_a = torch.tensor(self.a[index], dtype=torch.float)\n",
    "        batch_r = torch.tensor(self.r[index], dtype=torch.float)\n",
    "        batch_s_ = torch.tensor(self.s_[index], dtype=torch.float)\n",
    "        batch_dw = torch.tensor(self.dw[index], dtype=torch.float)\n",
    "\n",
    "        return batch_s, batch_a, batch_r, batch_s_, batch_dw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**DDPG Agent Class**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DDPG(object):\n",
    "    def __init__(self, state_dim, action_dim):\n",
    "        \n",
    "        self.hidden_width = 256\n",
    "        self.batch_size = 128\n",
    "        self.GAMMA = 0.99\n",
    "        self.TAU = 0.001\n",
    "        self.lr = 0.001\n",
    "\n",
    "        self.actor = Actor().to(DEVICE)\n",
    "        self.actor_target = copy.deepcopy(self.actor).to(DEVICE)\n",
    "        self.critic = Critic().to(DEVICE)\n",
    "        self.critic_target = copy.deepcopy(self.critic).to(DEVICE)\n",
    "\n",
    "        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=0.0001)\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=0.001)\n",
    "\n",
    "        self.MseLoss = nn.MSELoss().to(DEVICE)\n",
    "\n",
    "    def save_checkpoint(self, i):\n",
    "        actor_path = \"checkpoints/actor_checkpoint_\" + str(i) + \".pth\"\n",
    "        critic_path =  \"checkpoints/critic_checkpoint_\" + str(i) + \".pth\"\n",
    "        torch.save(self.actor.state_dict(), actor_path)\n",
    "        torch.save(self.critic.state_dict(), critic_path)\n",
    "        print(f\"Saved checkpoints to {actor_path} and {critic_path}\")\n",
    "\n",
    "    def load_checkpoint(self, actor_path, critic_path):\n",
    "        self.actor.load_state_dict(torch.load(actor_path))\n",
    "        self.critic.load_state_dict(torch.load(critic_path))\n",
    "        self.actor_target = copy.deepcopy(self.actor).to(DEVICE)\n",
    "        self.critic_target = copy.deepcopy(self.critic).to(DEVICE)\n",
    "        print(f\"Loaded checkpoints from {actor_path} and {critic_path}\")\n",
    "\n",
    "    def choose_action(self, s):\n",
    "        s = torch.unsqueeze(s.clone().detach().float(), 0).to(DEVICE)\n",
    "        a = self.actor(s).data.cpu().numpy().flatten()\n",
    "        return a\n",
    "\n",
    "    def decrease_learning_rate(self):\n",
    "        # Reduce learning rate by 10%\n",
    "        self.lr  = self.lr / 10\n",
    "        for param_group in self.actor_optimizer.param_groups:\n",
    "            param_group['lr'] = self.lr\n",
    "        for param_group in self.critic_optimizer.param_groups:\n",
    "            param_group['lr'] = self.lr\n",
    "\n",
    "        print(f\"Updated learning rate to {self.lr}\")\n",
    "\n",
    "    def learn(self, relay_buffer):\n",
    "\n",
    "        batch_s, batch_a, batch_r, batch_s_, batch_dw = relay_buffer.sample(self.batch_size)  \n",
    "        batch_s = batch_s.to(DEVICE)\n",
    "        batch_r = batch_r.to(DEVICE)\n",
    "        batch_s_ = batch_s_.to(DEVICE)\n",
    "        batch_dw = batch_dw.to(DEVICE)\n",
    "        batch_a = batch_a.to(DEVICE)\n",
    "\n",
    "        with torch.no_grad(): \n",
    "            Q_ = self.critic_target(batch_s_, self.actor_target(batch_s_)).to(DEVICE)\n",
    "            target_Q = batch_r + self.GAMMA * (1 - batch_dw) * Q_\n",
    "\n",
    "        current_Q = self.critic(batch_s, batch_a)\n",
    "        critic_loss = F.mse_loss(current_Q,target_Q)\n",
    "\n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        self.critic_optimizer.step()\n",
    "\n",
    "        for params in self.critic.parameters():\n",
    "            params.requires_grad = False\n",
    "\n",
    "        actor_loss = -self.critic(batch_s, self.actor(batch_s)).mean()\n",
    "        self.actor_optimizer.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "\n",
    "        for params in self.critic.parameters():\n",
    "            params.requires_grad = True\n",
    "\n",
    "        for param, target_param in zip(self.critic.parameters(), self.critic_target.parameters()):\n",
    "            target_param.data.copy_(self.TAU * param.data + (1 - self.TAU) * target_param.data)\n",
    "\n",
    "        for param, target_param in zip(self.actor.parameters(), self.actor_target.parameters()):\n",
    "            target_param.data.copy_(self.TAU * param.data + (1 - self.TAU) * target_param.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Policy Evaluation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_policy(agent):\n",
    "    \n",
    "    sns.set_theme()\n",
    "    class MyController(BaseController):\n",
    "      last_road = -99\n",
    "      def update(self, target_lataccel, current_lataccel, state, last_action):\n",
    "        roll_lataccel, v_ego, a_ego = state\n",
    "        state = torch.tensor([v_ego, a_ego, roll_lataccel, target_lataccel, current_lataccel, target_lataccel-current_lataccel, last_action])\n",
    "            \n",
    "        action = agent.choose_action(state)[0]\n",
    "          \n",
    "        return action\n",
    "    \n",
    "    def plot_rollout(sim):\n",
    "      fig, ax = plt.subplots(figsize=(10, 5))\n",
    "      ax.plot(sim.target_lataccel_history, label=\"Target Lateral Acceleration\", alpha=0.5)\n",
    "      ax.plot(sim.current_lataccel_history, label=\"Actual Lateral Acceleration\", alpha=0.5)\n",
    "      ax.legend()\n",
    "      ax.set_xlabel(\"Step\")\n",
    "      ax.set_ylabel(\"Lateral Acceleration\")\n",
    "      ax.set_title(\"Rollout\")\n",
    "      plt.show()\n",
    "    \n",
    "    model = TinyPhysicsModel(\"./models/tinyphysics.onnx\", debug=True)\n",
    "    controller = MyController()\n",
    "    \n",
    "    sim = TinyPhysicsSimulator(model, \"./data/00000.csv\", controller=controller, debug=False)\n",
    "    \n",
    "    print(sim.rollout())\n",
    "    \n",
    "    plot_rollout(sim)\n",
    "\n",
    "    model = TinyPhysicsModel(\"./models/tinyphysics.onnx\", debug=True)\n",
    "    controller = MyController()\n",
    "    \n",
    "    sim = TinyPhysicsSimulator(model, \"./data/00002.csv\", controller=controller, debug=False)\n",
    "    \n",
    "    print(sim.rollout())\n",
    "    \n",
    "    plot_rollout(sim)\n",
    "\n",
    "\n",
    "    model = TinyPhysicsModel(\"./models/tinyphysics.onnx\", debug=True)\n",
    "    controller = MyController()\n",
    "    \n",
    "    sim = TinyPhysicsSimulator(model, \"./data/00010.csv\", controller=controller, debug=False)\n",
    "    \n",
    "    print(sim.rollout())\n",
    "    \n",
    "    plot_rollout(sim)\n",
    "    times = 20  \n",
    "    evaluate_reward = 0\n",
    "    for _ in range(times):\n",
    "        done = False\n",
    "        random_integer = torch.randint(0, 19999, (1,)).item()\n",
    "        env = Environment(2,random_integer)\n",
    "        episode_reward = 0\n",
    "        while not done:\n",
    "            state = env.get_state()\n",
    "            action = agent.choose_action(state)[0]\n",
    "            actual, reward, done = env.step(action)\n",
    "            episode_reward += reward\n",
    "            \n",
    "        evaluate_reward += env.sim.compute_cost()[\"total_cost\"]\n",
    "\n",
    "    return float(evaluate_reward / float(times))\n",
    "\n",
    "def count_steps(filename):\n",
    "     with open(filename, 'r') as file:\n",
    "        return sum(1 for line in file)\n",
    "\n",
    "def generate_filename(index):\n",
    "    return f\"./data/{index:05}.csv\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Environment Class**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Environment:\n",
    "\n",
    "    def __init__(self, max_action, start_index):\n",
    "        self.max_action = max_action\n",
    "        self.last_actual = None\n",
    "        self.num_steps = 0\n",
    "        self.current_file_index = start_index\n",
    "        self.max_file_index = 19999\n",
    "        self.prepare()\n",
    "\n",
    "    def prepare(self):\n",
    "        file_name = generate_filename(self.current_file_index)\n",
    "        self.num_steps = count_steps(file_name)-1\n",
    "        self.controller = SimpleController()\n",
    "        self.model = TinyPhysicsModel_Modified(\"./models/tinyphysics.onnx\", debug=False)\n",
    "        self.sim = TinyPhysicsSimulator_Modified(self.model, file_name, controller=self.controller, debug=False)\n",
    "        self.last_actual = None\n",
    "\n",
    "    def next_episode(self):\n",
    "        self.current_file_index = torch.randint(0, 20000, (1,)).item()\n",
    "        self.prepare()\n",
    "\n",
    "    def random_action(self):\n",
    "        random_action = -2.0 + 4.0 * torch.rand(1).item()\n",
    "        return random_action\n",
    "    \n",
    "    def get_state(self):\n",
    "        state_object, target =  self.sim.get_state_target(self.sim.step_idx)\n",
    "        roll_lataccel, v_ego, a_ego = state_object\n",
    "        last_action = self.sim.action_history[len(self.sim.action_history)-1]\n",
    "        actual = self.sim.current_lataccel_history[len(self.sim.current_lataccel_history)-1]\n",
    "        return torch.tensor([v_ego, a_ego, roll_lataccel, target, actual, target-actual, last_action])\n",
    "    \n",
    "    def step(self, action):\n",
    "        target = self.get_state()[3]\n",
    "        self.sim.step(action)\n",
    "        actual = self.sim.current_lataccel_history[len(self.sim.current_lataccel_history)-1]\n",
    "        last_actual = self.sim.current_lataccel_history[len(self.sim.current_lataccel_history)-2]\n",
    "        lateral_cost = 100.0*(actual-target)*(actual-target)\n",
    "        jerk_cost = 100.0*(actual-last_actual)*(actual-last_actual)/0.1\n",
    "        delta_action = self.sim.action_history[len( self.sim.action_history)-1]- self.sim.action_history[len( self.sim.action_history)-2]\n",
    "        action_cost = 0.0\n",
    "        action_cost = delta_action*delta_action\n",
    "        cost = (5.0*lateral_cost + 3.0*jerk_cost) + 10*action_cost\n",
    "        reward = -1.0*float(cost)\n",
    "        done = False\n",
    "        if self.sim.step_idx==self.num_steps-1:\n",
    "            done = True\n",
    "        return actual,float(reward), done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Training Config**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "state_dim = 7\n",
    "action_dim = 1\n",
    "max_action = 2\n",
    "agent = DDPG(state_dim, action_dim)\n",
    "replay_buffer = ReplayBuffer(state_dim, action_dim)\n",
    "\n",
    "noise_std = 0.5 * max_action  \n",
    "max_train_steps = 10000000000  # Maximum number of training steps\n",
    "random_steps = 2000  # Take the random actions in the beginning for the better exploration\n",
    "update_freq = 50  # Take 50 steps,then update the networks 50 times\n",
    "evaluate_freq = 1e5  # Evaluate the policy every 'evaluate_freq' steps\n",
    "evaluate_num = 0  # Record the number of evaluations\n",
    "evaluate_rewards = []  # Record the rewards during the evaluating\n",
    "total_steps = 0  # Record the total steps during the training\n",
    "finished = 0\n",
    "starting_episode = 300\n",
    "env = Environment(2,0)\n",
    "state = env.get_state()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Load Checkpoint**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# agent.load_checkpoint(\"backup_checkpoints/actor_checkpoint_0.pth\",\"backup_checkpoints/critic_checkpoint_0.pth\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Training**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lowest_eval = 10000000\n",
    "\n",
    "while True:\n",
    "    done = False\n",
    "    while not done:\n",
    "        state = env.get_state().to(DEVICE)\n",
    "        explore = torch.rand(1).item()\n",
    "        if replay_buffer.size < 200000:\n",
    "            action = env.random_action()\n",
    "        elif explore > 0.50:\n",
    "            action = env.random_action()\n",
    "        else:\n",
    "            action = agent.choose_action(state)\n",
    "            action = (action + np.random.normal(0, 0.01, size=action_dim)).clip(-max_action, max_action) # Add Gaussian noise to actions for exploration\n",
    "            action = action[0]\n",
    "       \n",
    "        actual, reward, done = env.step(action)\n",
    "        next_state = env.get_state().to(DEVICE)\n",
    "        replay_buffer.store(state.cpu(), action, reward, next_state.cpu(), done)\n",
    "\n",
    "        if done:\n",
    "            env.next_episode()\n",
    "            finished += 1\n",
    "\n",
    "        if done and finished%3 == 0 and replay_buffer.size >= 10:\n",
    "            for _ in range(10):\n",
    "                agent.learn(replay_buffer)\n",
    "        \n",
    "        if replay_buffer.size >= 10 and finished%50 == 0:\n",
    "            clear_output(wait=True)\n",
    "            finished += 1\n",
    "            evaluate_num += 1\n",
    "            evaluate_reward = evaluate_policy(agent)\n",
    "            if evaluate_reward<lowest_eval:\n",
    "                lowest_eval = evaluate_reward\n",
    "                agent.save_checkpoint(lowest_eval)\n",
    "            evaluate_rewards.append(evaluate_reward)\n",
    "           \n",
    "            print(type(evaluate_num))\n",
    "            print(evaluate_num)\n",
    "            print(\"evaluate_num:{} \\t evaluate_reward:{}\".format(evaluate_num, evaluate_reward))\n",
    "            plt.plot(evaluate_rewards)\n",
    "            plt.ylim([0,1500])\n",
    "\n",
    "        total_steps += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cost = np.load(\"submission_files/cost.npy\")\n",
    "cost = cost[60:]\n",
    "plt.plot(cost)\n",
    "plt.title(\"DDPG Training Progress\")\n",
    "plt.xlabel(\"Evaulation Iterations (Once per 50 episodes)\")\n",
    "plt.ylabel(\"Negative Reward\")\n",
    "plt.legend([\"5 x lataccel_cost + jerk_cost\"])\n",
    "plt.grid(True)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}