dqn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "dc7462aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import os\n",
    "import pygame\n",
    "import gymnasium as gym\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from collections import namedtuple, deque\n",
    "from pathlib import Path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "260c1bd6-2abd-4fc1-928c-1a027f67cdfa",
   "metadata": {},
   "outputs": [],
   "source": [
    "HIDDEN_SIZE = 128\n",
    "BUFFER_SIZE = int(10_000)\n",
    "BATCH_SIZE = 128\n",
    "GAMMA = 0.99\n",
    "TAU = 0.005\n",
    "STEP_SIZE = 1e-4\n",
    "UPDATE_Q_NETWORK_EVERY_STEPS = 1\n",
    "\n",
    "LOG_EVERY_STEPS = 100\n",
    "PATH_SAVE_DIR = \"./checkpoints/dqn\"\n",
    "\n",
    "MAX_AVG_REWARD = 500.\n",
    "\n",
    "NUM_EPISODES=600\n",
    "MAX_STEPS_EP=500\n",
    "EPS_START=0.9\n",
    "EPS_END=0.05\n",
    "EPS_DECAY=0.995\n",
    "SEED=1278173123\n",
    "\n",
    "NUM_EPISODES_TEST = 1000\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "f4ffed32",
   "metadata": {},
   "outputs": [],
   "source": [
    "class QNetwork(nn.Module):\n",
    "\n",
    "    def __init__(self, state_size, action_size, seed, hidden_size=128):\n",
    "        \"\"\"Initialize Q-Network. \"\"\"\n",
    "        super(QNetwork, self).__init__()\n",
    "        self.seed = torch.manual_seed(seed)\n",
    "        \n",
    "        self.state_size = state_size\n",
    "        self.action_size = action_size\n",
    "        self.hidden_size = hidden_size\n",
    "\n",
    "        self.fc1 = nn.Linear(self.state_size, hidden_size)\n",
    "        self.fc2 = nn.Linear(hidden_size, hidden_size)\n",
    "        self.fc3 = nn.Linear(hidden_size, action_size)\n",
    "\n",
    "    \n",
    "    def forward(self, state):\n",
    "        x = F.relu(self.fc1(state))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        action_values = self.fc3(x)\n",
    "\n",
    "        return action_values\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "f440761b-38df-4c72-9e83-67fd4d7920c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "\n",
    "    experience = namedtuple(\"Experience\", field_names=[\"state\", \"action\", \"reward\", \"next_state\", \"done\"])\n",
    "    \n",
    "    def __init__(self, action_size, buffer_size, batch_size, seed, device=\"cpu\"):\n",
    "        self.action_size = action_size\n",
    "        self.memory = deque(maxlen=buffer_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.seed = random.seed(seed)\n",
    "        self.device = device\n",
    "\n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        e = ReplayBuffer.experience(state, action, reward, next_state, done)\n",
    "        self.memory.append(e)\n",
    "\n",
    "    def sample(self):\n",
    "        experiences = random.sample(self.memory, k=self.batch_size)\n",
    "\n",
    "        states = (\n",
    "            torch.from_numpy(np.vstack([e.state for e in experiences if e is not None]))\n",
    "            .float()\n",
    "            .to(self.device)\n",
    "        )\n",
    "        actions = (\n",
    "            torch.from_numpy(\n",
    "                np.vstack([e.action for e in experiences if e is not None])\n",
    "            )\n",
    "            .float()\n",
    "            .to(self.device)\n",
    "        )\n",
    "        rewards = (\n",
    "            torch.from_numpy(\n",
    "                np.vstack([e.reward for e in experiences if e is not None])\n",
    "            )\n",
    "            .float()\n",
    "            .to(self.device)\n",
    "        )\n",
    "        next_states = (\n",
    "            torch.from_numpy(\n",
    "                np.vstack([e.next_state for e in experiences if e is not None])\n",
    "            )\n",
    "            .float()\n",
    "            .to(self.device)\n",
    "        )\n",
    "        dones = (\n",
    "            torch.from_numpy(\n",
    "                np.vstack([e.done for e in experiences if e is not None]).astype(\n",
    "                    np.uint8\n",
    "                )\n",
    "            )\n",
    "            .float()\n",
    "            .to(self.device)\n",
    "        )\n",
    "\n",
    "        return (states, actions, rewards, next_states, dones)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.memory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "9561933b-cf17-47ac-b057-fb7f786ac763",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"Interacts with and learns from the environment.\"\"\"\n",
    "\n",
    "    def __init__(self, state_size, action_size, hidden_size, seed):\n",
    "        \"\"\"Initialize a DQN Agent.\"\"\"\n",
    "        \n",
    "        self.state_size = state_size\n",
    "        self.action_size = action_size\n",
    "        self.seed = random.seed(seed)\n",
    "\n",
    "        self.qnetwork = QNetwork(state_size, action_size, hidden_size=hidden_size, seed=seed).to(device)\n",
    "        self.qnetwork_target = QNetwork(state_size, action_size, hidden_size=hidden_size, seed=seed).to(device)\n",
    "        self.optimizer = optim.AdamW(self.qnetwork.parameters(), lr=STEP_SIZE, amsgrad=True)\n",
    "\n",
    "        self.memory = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE, seed)\n",
    "        self.t_step = 0\n",
    "\n",
    "    \n",
    "    def step(self, state, action, reward, next_state, done):\n",
    "        self.memory.add(state, action, reward, next_state, done)\n",
    "\n",
    "        self.t_step = (self.t_step + 1) % UPDATE_Q_NETWORK_EVERY_STEPS\n",
    "        if self.t_step == 0:\n",
    "            if len(self.memory) > BATCH_SIZE:\n",
    "                experiences = self.memory.sample()\n",
    "                self.learn(experiences, GAMMA)\n",
    "                \n",
    "    \n",
    "    def act(self, state, eps=0.):\n",
    "        \"\"\"Returns actions for given state as per current policy. \"\"\"\n",
    "        state = torch.from_numpy(state).float().unsqueeze(0).to(device)\n",
    "\n",
    "        action_values = self.qnetwork(state)\n",
    "        \n",
    "        if random.random() > eps:\n",
    "            return np.argmax(action_values.cpu().data.numpy())\n",
    "        else:\n",
    "            return random.choice(np.arange(self.action_size))\n",
    "\n",
    "    \n",
    "    def learn(self, experiences, gamma):\n",
    "        \"\"\"Update value parameters using given batch of experience tuples. \"\"\"\n",
    "        states, actions, rewards, next_states, dones = experiences\n",
    "\n",
    "        Q_targets_next = torch.max(self.qnetwork_target(next_states), dim=1, keepdim=True)[0]\n",
    "        Q_targets = rewards + (GAMMA * Q_targets_next * (1 - dones))\n",
    "        Q_expected = self.qnetwork(states).gather(1, actions)\n",
    "        loss = F.huber_loss(Q_expected, Q_targets)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        self.soft_update(self.qnetwork, self.qnetwork_target, TAU)\n",
    "\n",
    "    \n",
    "    def soft_update(self, local_model, target_model, tau):\n",
    "        \"\"\"Soft update model parameters. \"\"\"\n",
    "        for target_param, local_param in zip(target_model.parameters(), local_model.parameters()):\n",
    "            target_param.data.copy_(tau * local_param.data + (1.0 - tau) * target_param.data)\n",
    "            target_param.requires_grad = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "4d73e259-2a25-465d-910f-114896683ad2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 100\tAverage Score: 17.75\n",
      "Episode 200\tAverage Score: 107.16\n",
      "Episode 300\tAverage Score: 137.19\n",
      "Episode 400\tAverage Score: 208.49\n",
      "Episode 500\tAverage Score: 491.05\n",
      "Episode 550\tAverage Score: 500.00\n",
      "Environment solved in 450 episodes!\tAverage Score: 500.00\n"
     ]
    }
   ],
   "source": [
    "scores = []\n",
    "scores_avg = []\n",
    "scores_window = deque(maxlen=100)\n",
    "eps = EPS_START\n",
    "env = gym.make(\"CartPole-v1\")\n",
    "env.reset(seed=SEED)\n",
    "\n",
    "agent = DQNAgent(state_size=env.observation_space.shape[0], action_size=env.action_space.n, hidden_size=HIDDEN_SIZE, seed=SEED)\n",
    "\n",
    "for i_episode in range(1, NUM_EPISODES+1):\n",
    "    obs, _ = env.reset()\n",
    "    score = 0.\n",
    "    for t in range(MAX_STEPS_EP):\n",
    "        action = agent.act(obs, eps)\n",
    "        obs_next, reward, done, truncated, info = env.step(action)\n",
    "        agent.step(obs, action, reward, obs_next, done)\n",
    "        score += reward\n",
    "        obs = obs_next\n",
    "        if done:\n",
    "            break \n",
    "    scores_window.append(score)\n",
    "    scores.append(score)\n",
    "    eps = max(EPS_END, EPS_DECAY*eps)\n",
    "    avg_reward = np.mean(scores_window)\n",
    "    scores_avg.append(avg_reward)\n",
    "    \n",
    "    print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, avg_reward), end=\"\")\n",
    "    if i_episode % LOG_EVERY_STEPS == 0:\n",
    "        print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, avg_reward))\n",
    "        \n",
    "    if avg_reward >= MAX_AVG_REWARD and i_episode >= 100:\n",
    "        print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode-100, avg_reward))\n",
    "        \n",
    "        if not Path(PATH_SAVE_DIR).exists():\n",
    "            os.makedirs(PATH_SAVE_DIR, exist_ok=True)\n",
    "        torch.save({\n",
    "            \"episode\": i_episode,\n",
    "            \"state_dict\": agent.qnetwork.state_dict(),\n",
    "            \"avg_reward\": avg_reward\n",
    "        }, f\"{PATH_SAVE_DIR}/checkpoint.pth\")\n",
    "        \n",
    "        break\n",
    "            \n",
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "4c534684-8fce-4aed-889d-f75f89886d4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 768x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(dpi=120)\n",
    "plt.plot(np.arange(len(scores)), scores, c=\"#6200ee\", alpha=0.7)\n",
    "plt.plot(scores_avg, c=\"#03dac6\")\n",
    "plt.ylabel('Score')\n",
    "plt.xlabel('Episode #')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ec163c9-80fc-4dbc-830b-051646855550",
   "metadata": {},
   "source": [
    "## Visualize a smart agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c666808-2a26-4975-84c6-baead7a009ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "load_path = f\"{PATH_SAVE_DIR}/checkpoint.pth\"\n",
    "cuda = torch.cuda.is_available()\n",
    "\n",
    "if cuda:\n",
    "    checkpoint = torch.load(load_path)\n",
    "else:\n",
    "    checkpoint = torch.load(load_path, map_location=lambda storage, loc: storage)\n",
    "\n",
    "env = gym.make(\"CartPole-v1\", render_mode=\"human\")\n",
    "agent = DQNAgent(state_size=env.observation_space.shape[0], action_size=env.action_space.n, seed=123)\n",
    "\n",
    "agent.qnetwork.load_state_dict(checkpoint['state_dict'])\n",
    "\n",
    "pygame.init()\n",
    "window_size = (640, 640)\n",
    "screen = pygame.display.set_mode(window_size)\n",
    "running = True\n",
    "\n",
    "for i in range(NUM_EPISODES_TEST):\n",
    "    obs, _ = env.reset()\n",
    "    for t in range(MAX_STEPS_EP):\n",
    "        action = agent.act(obs)\n",
    "        obs_next, reward, done, truncated, info = env.step(action)\n",
    "        if done:\n",
    "            break\n",
    "            \n",
    "        for event in pygame.event.get():\n",
    "            if event.type == pygame.QUIT:\n",
    "                running = False\n",
    "            elif event.type == pygame.KEYDOWN and event.key == pygame.K_q:\n",
    "                running = False\n",
    "                \n",
    "        if not running:\n",
    "            break\n",
    "\n",
    "    if not running:\n",
    "        break\n",
    "\n",
    "if not running:\n",
    "    print(\"Shutting down...\")\n",
    "    env.close()\n",
    "    pygame.quit()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}