train.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import numpy as np\n",
    "import gymnasium as gym\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.distributions import Beta\n",
    "from torch.utils.data.sampler import BatchSampler, SubsetRandomSampler\n",
    "from utils import DrawLine\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "\n",
    "class Args:\n",
    "    gamma = 0.99\n",
    "    action_repeat = 8\n",
    "    img_stack = 4\n",
    "    seed = 0\n",
    "    render = False\n",
    "    vis = False\n",
    "    log_interval = 10\n",
    "\n",
    "args = Args()\n",
    "use_cuda = torch.cuda.is_available()\n",
    "device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n",
    "torch.manual_seed(args.seed)\n",
    "if use_cuda:\n",
    "    torch.cuda.manual_seed(args.seed)\n",
    "\n",
    "transition = np.dtype([('s', np.float64, (args.img_stack, 96, 96)), ('a', np.float64, (3,)), ('a_logp', np.float64),('r', np.float64), ('s_', np.float64, (args.img_stack, 96, 96))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Env:\n",
    "    \"\"\"\n",
    "    Environment wrapper for CarRacing\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, args):\n",
    "        self.env = gym.make('CarRacing-v3')\n",
    "        self.reward_threshold = self.env.spec.reward_threshold\n",
    "        self.args = args\n",
    "\n",
    "    def reset(self):\n",
    "        self.counter = 0\n",
    "        self.av_r = self.reward_memory()\n",
    "        self.die = False\n",
    "\n",
    "        obs, _ = self.env.reset()  # Handle tuple return\n",
    "        img_rgb = obs\n",
    "        img_gray = self.rgb2gray(img_rgb)\n",
    "        self.stack = [img_gray] * self.args.img_stack\n",
    "        return np.array(self.stack)\n",
    "\n",
    "    def step(self, action):\n",
    "        total_reward = 0\n",
    "        for _ in range(self.args.action_repeat):\n",
    "            img_rgb, reward, terminated, truncated, _ = self.env.step(action)\n",
    "            die = terminated or truncated\n",
    "\n",
    "            if die:\n",
    "                reward += 100\n",
    "            if np.mean(img_rgb[:, :, 1]) > 185.0:\n",
    "                reward -= 0.05\n",
    "\n",
    "            total_reward += reward\n",
    "            done = True if self.av_r(reward) <= -0.1 else False\n",
    "\n",
    "            if done or die:\n",
    "                break\n",
    "\n",
    "        img_gray = self.rgb2gray(img_rgb)\n",
    "        self.stack.pop(0)\n",
    "        self.stack.append(img_gray)\n",
    "        assert len(self.stack) == self.args.img_stack\n",
    "        return np.array(self.stack), total_reward, done, die\n",
    "\n",
    "    def render(self, *arg):\n",
    "        self.env.render(*arg)\n",
    "\n",
    "    @staticmethod\n",
    "    def rgb2gray(rgb, norm=True):\n",
    "        if isinstance(rgb, tuple):\n",
    "            rgb = np.array(rgb, dtype=np.float64)  # Ensure consistent dtype\n",
    "\n",
    "        if not (rgb.ndim == 3 and rgb.shape[2] == 3):\n",
    "            raise ValueError(\"Input must be an RGB image with shape (height, width, 3)\")\n",
    "\n",
    "        gray = np.dot(rgb[..., :3], [0.299, 0.587, 0.114])\n",
    "        if norm:\n",
    "            gray = gray / 128. - 1.\n",
    "        return gray\n",
    "\n",
    "    @staticmethod\n",
    "    def reward_memory():\n",
    "        count = 0\n",
    "        length = 100\n",
    "        history = np.zeros(length)\n",
    "\n",
    "        def memory(reward):\n",
    "            nonlocal count\n",
    "            history[count] = reward\n",
    "            count = (count + 1) % length\n",
    "            return np.mean(history)\n",
    "\n",
    "        return memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    \"\"\"\n",
    "    Actor-Critic Network for PPO\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.cnn_base = nn.Sequential(  # input shape (4, 96, 96)\n",
    "            nn.Conv2d(args.img_stack, 8, kernel_size=4, stride=2),\n",
    "            nn.ReLU(),  # activation\n",
    "            nn.Conv2d(8, 16, kernel_size=3, stride=2),  # (8, 47, 47)\n",
    "            nn.ReLU(),  # activation\n",
    "            nn.Conv2d(16, 32, kernel_size=3, stride=2),  # (16, 23, 23)\n",
    "            nn.ReLU(),  # activation\n",
    "            nn.Conv2d(32, 64, kernel_size=3, stride=2),  # (32, 11, 11)\n",
    "            nn.ReLU(),  # activation\n",
    "            nn.Conv2d(64, 128, kernel_size=3, stride=1),  # (64, 5, 5)\n",
    "            nn.ReLU(),  # activation\n",
    "            nn.Conv2d(128, 256, kernel_size=3, stride=1),  # (128, 3, 3)\n",
    "            nn.ReLU(),  # activation\n",
    "        )  # output shape (256, 1, 1)\n",
    "        self.v = nn.Sequential(nn.Linear(256, 100), nn.ReLU(), nn.Linear(100, 1))\n",
    "        self.fc = nn.Sequential(nn.Linear(256, 100), nn.ReLU())\n",
    "        self.alpha_head = nn.Sequential(nn.Linear(100, 3), nn.Softplus())\n",
    "        self.beta_head = nn.Sequential(nn.Linear(100, 3), nn.Softplus())\n",
    "        self.apply(self._weights_init)\n",
    "\n",
    "    @staticmethod\n",
    "    def _weights_init(m):\n",
    "        if isinstance(m, nn.Conv2d):\n",
    "            nn.init.xavier_uniform_(m.weight, gain=nn.init.calculate_gain('relu'))\n",
    "            nn.init.constant_(m.bias, 0.1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.cnn_base(x)\n",
    "        x = x.view(-1, 256)\n",
    "        v = self.v(x)\n",
    "        x = self.fc(x)\n",
    "        alpha = self.alpha_head(x) + 1\n",
    "        beta = self.beta_head(x) + 1\n",
    "\n",
    "        return (alpha, beta), v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Agent():\n",
    "    \"\"\"\n",
    "    Agent for training\n",
    "    \"\"\"\n",
    "    max_grad_norm = 0.5\n",
    "    clip_param = 0.1  # epsilon in clipped loss\n",
    "    ppo_epoch = 10\n",
    "    buffer_capacity, batch_size = 2000, 128\n",
    "\n",
    "    def __init__(self):\n",
    "        self.training_step = 0\n",
    "        self.net = Net().double().to(device)\n",
    "        self.buffer = np.empty(self.buffer_capacity, dtype=transition)\n",
    "        self.counter = 0\n",
    "\n",
    "        self.optimizer = optim.Adam(self.net.parameters(), lr=1e-4)\n",
    "\n",
    "    def select_action(self, state):\n",
    "        state = torch.from_numpy(state).double().to(device).unsqueeze(0)\n",
    "        with torch.no_grad():\n",
    "            alpha, beta = self.net(state)[0]\n",
    "        dist = Beta(alpha, beta)\n",
    "        action = dist.sample()\n",
    "        a_logp = dist.log_prob(action).sum(dim=1)\n",
    "\n",
    "        action = action.squeeze().cpu().numpy()\n",
    "        a_logp = a_logp.item()\n",
    "        return action, a_logp\n",
    "\n",
    "    def save_param(self):\n",
    "        torch.save(self.net.state_dict(), 'param/ppo_net_params1.pkl')\n",
    "\n",
    "    def store(self, transition):\n",
    "        self.buffer[self.counter] = transition\n",
    "        self.counter += 1\n",
    "        if self.counter == self.buffer_capacity:\n",
    "            self.counter = 0\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "    \n",
    "    def load_param(self):\n",
    "        self.net.load_state_dict(torch.load('param/ppo_net_params1.pkl'))\n",
    "\n",
    "    def update(self):\n",
    "        self.training_step += 1\n",
    "\n",
    "        s = torch.tensor(self.buffer['s'], dtype=torch.double).to(device)\n",
    "        a = torch.tensor(self.buffer['a'], dtype=torch.double).to(device)\n",
    "        r = torch.tensor(self.buffer['r'], dtype=torch.double).to(device).view(-1, 1)\n",
    "        s_ = torch.tensor(self.buffer['s_'], dtype=torch.double).to(device)\n",
    "\n",
    "        old_a_logp = torch.tensor(self.buffer['a_logp'], dtype=torch.double).to(device).view(-1, 1)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            target_v = r + args.gamma * self.net(s_)[1]\n",
    "            adv = target_v - self.net(s)[1]\n",
    "\n",
    "        for _ in range(self.ppo_epoch):\n",
    "            for index in BatchSampler(SubsetRandomSampler(range(self.buffer_capacity)), self.batch_size, False):\n",
    "\n",
    "                alpha, beta = self.net(s[index])[0]\n",
    "                dist = Beta(alpha, beta)\n",
    "                a_logp = dist.log_prob(a[index]).sum(dim=1, keepdim=True)\n",
    "                ratio = torch.exp(a_logp - old_a_logp[index])\n",
    "\n",
    "                surr1 = ratio * adv[index]\n",
    "                surr2 = torch.clamp(ratio, 1.0 - self.clip_param, 1.0 + self.clip_param) * adv[index]\n",
    "                action_loss = -torch.min(surr1, surr2).mean()\n",
    "                value_loss = F.smooth_l1_loss(self.net(s[index])[1], target_v[index])\n",
    "                loss = action_loss + 2. * value_loss\n",
    "\n",
    "                self.optimizer.zero_grad()\n",
    "                loss.backward()\n",
    "                self.optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ep 0\tLast score: 99.63\tMoving average score: 1.00\n",
      "Ep 100\tLast score: -17.93\tMoving average score: 8.15\n",
      "Ep 200\tLast score: -18.01\tMoving average score: 7.52\n",
      "Ep 300\tLast score: 124.57\tMoving average score: 15.45\n",
      "Ep 400\tLast score: -18.09\tMoving average score: 12.47\n",
      "Ep 500\tLast score: 13.42\tMoving average score: 13.97\n",
      "Ep 600\tLast score: -17.91\tMoving average score: 15.49\n",
      "Ep 700\tLast score: 9.91\tMoving average score: 18.25\n",
      "Ep 800\tLast score: 15.98\tMoving average score: 20.23\n",
      "Ep 900\tLast score: 14.62\tMoving average score: 21.46\n",
      "Ep 1000\tLast score: 56.06\tMoving average score: 34.54\n",
      "Ep 1100\tLast score: 18.25\tMoving average score: 37.13\n",
      "Ep 1200\tLast score: 171.72\tMoving average score: 61.67\n",
      "Ep 1300\tLast score: 56.01\tMoving average score: 120.32\n",
      "Ep 1400\tLast score: 320.44\tMoving average score: 229.07\n",
      "Ep 1500\tLast score: 315.64\tMoving average score: 296.04\n",
      "Ep 1600\tLast score: 434.48\tMoving average score: 357.79\n",
      "Ep 1700\tLast score: 422.15\tMoving average score: 418.18\n",
      "Ep 1800\tLast score: 602.36\tMoving average score: 474.49\n",
      "Ep 1900\tLast score: 598.66\tMoving average score: 487.89\n",
      "Ep 2000\tLast score: 354.08\tMoving average score: 497.62\n",
      "Ep 2100\tLast score: 641.11\tMoving average score: 509.26\n",
      "Ep 2200\tLast score: 686.87\tMoving average score: 569.02\n",
      "Ep 2300\tLast score: 270.39\tMoving average score: 610.28\n",
      "Ep 2400\tLast score: 736.84\tMoving average score: 659.69\n",
      "Ep 2500\tLast score: 770.32\tMoving average score: 684.03\n",
      "Ep 2600\tLast score: 762.89\tMoving average score: 715.94\n",
      "Ep 2700\tLast score: 772.58\tMoving average score: 738.62\n",
      "Ep 2800\tLast score: 800.64\tMoving average score: 762.29\n",
      "Ep 2900\tLast score: 841.58\tMoving average score: 771.21\n",
      "Ep 3000\tLast score: 822.82\tMoving average score: 778.08\n",
      "Ep 3100\tLast score: 927.84\tMoving average score: 815.63\n",
      "Ep 3200\tLast score: 425.93\tMoving average score: 783.82\n",
      "Ep 3300\tLast score: 602.56\tMoving average score: 782.37\n",
      "Ep 3400\tLast score: 286.42\tMoving average score: 801.34\n",
      "Ep 3500\tLast score: 932.91\tMoving average score: 800.10\n",
      "Ep 3600\tLast score: 1005.70\tMoving average score: 832.61\n",
      "Ep 3700\tLast score: 993.42\tMoving average score: 831.19\n",
      "Ep 3800\tLast score: 670.17\tMoving average score: 836.21\n",
      "Ep 3900\tLast score: 537.08\tMoving average score: 835.37\n",
      "Ep 4000\tLast score: 603.39\tMoving average score: 707.82\n",
      "Ep 4100\tLast score: 557.63\tMoving average score: 649.06\n",
      "Ep 4200\tLast score: 615.66\tMoving average score: 621.54\n",
      "Ep 4300\tLast score: 613.01\tMoving average score: 619.73\n",
      "Ep 4400\tLast score: 625.00\tMoving average score: 614.33\n",
      "Ep 4500\tLast score: 634.62\tMoving average score: 606.54\n",
      "Ep 4600\tLast score: 519.52\tMoving average score: 584.49\n",
      "Ep 4700\tLast score: 586.81\tMoving average score: 578.45\n",
      "Ep 4800\tLast score: 612.32\tMoving average score: 580.86\n",
      "Ep 4900\tLast score: 652.63\tMoving average score: 600.82\n",
      "Ep 5000\tLast score: 663.27\tMoving average score: 628.42\n",
      "Ep 5100\tLast score: 580.65\tMoving average score: 648.66\n",
      "Ep 5200\tLast score: 608.83\tMoving average score: 669.34\n",
      "Ep 5300\tLast score: 703.18\tMoving average score: 676.23\n",
      "Ep 5400\tLast score: 787.76\tMoving average score: 667.55\n",
      "Ep 5500\tLast score: 645.05\tMoving average score: 671.10\n",
      "Ep 5600\tLast score: 690.97\tMoving average score: 670.57\n",
      "Ep 5700\tLast score: 738.28\tMoving average score: 669.24\n",
      "Ep 5800\tLast score: 674.83\tMoving average score: 656.92\n",
      "Ep 5900\tLast score: 613.64\tMoving average score: 663.44\n",
      "Ep 6000\tLast score: 614.38\tMoving average score: 664.05\n",
      "Ep 6100\tLast score: 689.90\tMoving average score: 663.75\n",
      "Ep 6200\tLast score: 724.14\tMoving average score: 665.16\n",
      "Ep 6300\tLast score: 652.03\tMoving average score: 655.51\n",
      "Ep 6400\tLast score: 639.61\tMoving average score: 661.56\n",
      "Ep 6500\tLast score: 754.51\tMoving average score: 675.94\n",
      "Ep 6600\tLast score: 718.31\tMoving average score: 689.82\n",
      "Ep 6700\tLast score: 705.88\tMoving average score: 691.30\n",
      "Ep 6800\tLast score: 655.52\tMoving average score: 681.60\n",
      "Ep 6900\tLast score: 684.40\tMoving average score: 678.30\n",
      "Ep 7000\tLast score: 765.38\tMoving average score: 672.97\n",
      "Ep 7100\tLast score: 685.43\tMoving average score: 688.85\n",
      "Ep 7200\tLast score: 734.27\tMoving average score: 711.29\n",
      "Ep 7300\tLast score: 679.37\tMoving average score: 729.57\n",
      "Ep 7400\tLast score: 708.20\tMoving average score: 739.65\n",
      "Ep 7500\tLast score: 586.02\tMoving average score: 746.75\n",
      "Ep 7600\tLast score: 736.65\tMoving average score: 729.03\n",
      "Ep 7700\tLast score: 798.56\tMoving average score: 732.56\n",
      "Ep 7800\tLast score: 844.70\tMoving average score: 750.78\n",
      "Ep 7900\tLast score: 789.12\tMoving average score: 778.78\n",
      "Ep 8000\tLast score: 803.99\tMoving average score: 794.56\n",
      "Ep 8100\tLast score: 880.87\tMoving average score: 819.54\n",
      "Ep 8200\tLast score: 875.44\tMoving average score: 823.18\n",
      "Ep 8300\tLast score: 863.95\tMoving average score: 841.71\n",
      "Ep 8400\tLast score: 835.53\tMoving average score: 854.82\n",
      "Ep 8500\tLast score: 927.01\tMoving average score: 857.04\n",
      "Ep 8600\tLast score: 940.07\tMoving average score: 856.54\n",
      "Ep 8700\tLast score: 854.67\tMoving average score: 856.28\n",
      "Ep 8800\tLast score: 942.97\tMoving average score: 859.44\n",
      "Ep 8900\tLast score: 893.38\tMoving average score: 850.37\n",
      "Ep 9000\tLast score: 776.40\tMoving average score: 848.59\n",
      "Ep 9100\tLast score: 1003.60\tMoving average score: 870.36\n",
      "Ep 9200\tLast score: 472.00\tMoving average score: 876.07\n",
      "Ep 9300\tLast score: 1005.80\tMoving average score: 893.14\n",
      "Ep 9400\tLast score: 938.41\tMoving average score: 887.07\n",
      "Ep 9500\tLast score: 956.83\tMoving average score: 880.27\n",
      "Solved! Running reward is now 900.6507724132664 and the last episode runs to 967.5090252707491!\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    agent = Agent()\n",
    "    env = Env(args)\n",
    "\n",
    "    training_records = []\n",
    "    scores = []\n",
    "    episodes = []\n",
    "    running_score = 0\n",
    "\n",
    "    for i_ep in range(100000):\n",
    "        score = 0\n",
    "        state = env.reset()\n",
    "\n",
    "        for t in range(1000):\n",
    "            action, a_logp = agent.select_action(state)\n",
    "            state_, reward, done, die = env.step(action * np.array([2., 1., 1.]) + np.array([-1., 0., 0.]))\n",
    "\n",
    "            if args.render:\n",
    "                env.render()\n",
    "            if agent.store((state, action, a_logp, reward, state_)):\n",
    "                agent.update()\n",
    "            score += reward\n",
    "            state = state_\n",
    "            if done or die:\n",
    "                break\n",
    "\n",
    "        running_score = running_score * 0.99 + score * 0.01\n",
    "\n",
    "        if i_ep % 100 == 0:\n",
    "            episodes.append(i_ep)\n",
    "            scores.append(running_score)\n",
    "            print('Ep {}\\tLast score: {:.2f}\\tMoving average score: {:.2f}'.format(i_ep, score, running_score))\n",
    "        if i_ep % 10 == 0:\n",
    "            agent.save_param()\n",
    "\n",
    "        if running_score > env.reward_threshold:\n",
    "            print(\"Solved! Running reward is now {} and the last episode runs to {}!\".format(running_score, score))\n",
    "            break\n",
    "\n",
    "    # Plot scores after training\n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(episodes, scores, label=\"Moving Average Score\")\n",
    "    plt.xlabel(\"Episode\")\n",
    "    plt.ylabel(\"Moving Average Score\")\n",
    "    plt.title(\"Training Progress\")\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.savefig(\"training_progress.png\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "900\n"
     ]
    }
   ],
   "source": [
    "print(env.reward_threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "adps",
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}