DQN_(LunarLander_v2).ipynb

{
  "metadata": {
    "kernelspec": {
      "language": "python",
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "version": "3.6.4",
      "file_extension": ".py",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "name": "python",
      "mimetype": "text/x-python"
    },
    "colab": {
      "name": "DQN (LunarLander-v2)",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat_minor": 0,
  "nbformat": 4,
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/laurencecao/Apollo-11/blob/master/DQN_(LunarLander_v2).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Install necessary packages"
      ],
      "metadata": {
        "id": "d-epG8_6JHGX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install numpy torch gym box2d-py"
      ],
      "metadata": {
        "id": "yGg7pj-eJHGZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Import necessary packages"
      ],
      "metadata": {
        "id": "6Fv274aDJHGa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "import numpy as np\n",
        "\n",
        "import torch as T\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim"
      ],
      "metadata": {
        "trusted": true,
        "id": "GsELYViKJHGa"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Select Device"
      ],
      "metadata": {
        "id": "_us7Dg3VJHGb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "device = T.device(\"cuda:0\" if T.cuda.is_available() else \"cpu\")\n",
        "\n",
        "if T.cuda.is_available():\n",
        "    print(f'Running on {T.cuda.get_device_name(0)}')\n",
        "else:\n",
        "    print('Running on CPU')"
      ],
      "metadata": {
        "trusted": true,
        "id": "XYLy6AaNJHGb",
        "outputId": "3633cee0-b281-4f36-b39f-58cb934afb0b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Running on NVIDIA L4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The Neural Network (Q values)"
      ],
      "metadata": {
        "id": "ttufiCbUJHGc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch as T\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "\n",
        "class QNetwork(nn.Module):\n",
        "    \"\"\" Actor (Policy) Model.\"\"\"\n",
        "\n",
        "    def __init__(self, state_size, action_size, seed, fc1_unit=64,\n",
        "                 fc2_unit=64):\n",
        "        \"\"\"\n",
        "        Initialize parameters and build model.\n",
        "        Params\n",
        "        =======\n",
        "            state_size (int): Dimension of each state\n",
        "            action_size (int): Dimension of each action\n",
        "            seed (int): Random seed\n",
        "            fc1_unit (int): Number of nodes in first hidden layer\n",
        "            fc2_unit (int): Number of nodes in second hidden layer\n",
        "        \"\"\"\n",
        "        super(QNetwork, self).__init__()  # calls __init__ method of nn.Module class\n",
        "        self.seed = T.manual_seed(seed)\n",
        "        self.fc1 = nn.Linear(state_size, fc1_unit)\n",
        "        self.fc2 = nn.Linear(fc1_unit, fc2_unit)\n",
        "        self.fc3 = nn.Linear(fc2_unit, action_size)\n",
        "\n",
        "    def forward(self, x):\n",
        "        # x = state\n",
        "        \"\"\"\n",
        "        Build a network that maps state -> action values.\n",
        "        \"\"\"\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = F.relu(self.fc2(x))\n",
        "        return self.fc3(x)\n"
      ],
      "metadata": {
        "trusted": true,
        "id": "5FQ6rXDVJHGc"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Experience Replay"
      ],
      "metadata": {
        "id": "UKf5BbAAJHGc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from collections import deque, namedtuple\n",
        "\n",
        "class ReplayBuffer:\n",
        "    \"\"\"Fixed-size buffer to store experience tuples.\"\"\"\n",
        "\n",
        "    def __init__(self, action_size, buffer_size, batch_size, seed):\n",
        "        \"\"\"Initialize a ReplayBuffer object.\n",
        "        Params\n",
        "        ======\n",
        "            action_size (int): dimension of each action\n",
        "            buffer_size (int): maximum size of buffer\n",
        "            batch_size (int): size of each training batch\n",
        "            seed (int): random seed\n",
        "        \"\"\"\n",
        "        self.action_size = action_size\n",
        "        self.memory = deque(maxlen=buffer_size)\n",
        "        self.batch_size = batch_size\n",
        "        self.experience = namedtuple(\"Experience\", field_names=[\"state\", \"action\", \"reward\", \"next_state\", \"done\"])\n",
        "        self.seed = random.seed(seed)\n",
        "\n",
        "    def add(self, state, action, reward, next_state, done):\n",
        "        \"\"\"Add a new experience to memory.\"\"\"\n",
        "        e = self.experience(state, action, reward, next_state, done)\n",
        "        self.memory.append(e)\n",
        "\n",
        "    def sample(self):\n",
        "        \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n",
        "        experiences = random.sample(self.memory, k=self.batch_size)\n",
        "\n",
        "        states = T.from_numpy(np.vstack([e.state for e in experiences if e is not None])).float().to(device)\n",
        "        actions = T.from_numpy(np.vstack([e.action for e in experiences if e is not None])).long().to(device)\n",
        "        rewards = T.from_numpy(np.vstack([e.reward for e in experiences if e is not None])).float().to(device)\n",
        "        next_states = T.from_numpy(np.vstack([e.next_state for e in experiences if e is not None])).float().to(\n",
        "            device)\n",
        "        dones = T.from_numpy(np.vstack([e.done for e in experiences if e is not None]).astype(np.uint8)).float().to(\n",
        "            device)\n",
        "\n",
        "        return states, actions, rewards, next_states, dones\n",
        "\n",
        "    def __len__(self):\n",
        "        \"\"\"Return the current size of internal memory.\"\"\"\n",
        "        return len(self.memory)"
      ],
      "metadata": {
        "trusted": true,
        "id": "Cg-bE_naJHGc"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Agent class to put it all together"
      ],
      "metadata": {
        "id": "vqkoeK5ZJHGd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# hyper parameters\n",
        "BUFFER_SIZE = int(1e5)  # replay buffer size\n",
        "BATCH_SIZE = 64  # minibatch size\n",
        "GAMMA = 0.99  # discount factor\n",
        "TAU = 1e-3  # for soft update of target parameters\n",
        "LR = 5e-4  # learning rate\n",
        "UPDATE_EVERY = 4  # how often to update the network\n",
        "\n",
        "\n",
        "class Agent:\n",
        "    \"\"\"Interacts with and learns from the environment.\"\"\"\n",
        "\n",
        "    def __init__(self, state_size, action_size, seed):\n",
        "        \"\"\"Initialize an Agent object.\n",
        "\n",
        "        Params\n",
        "        ======\n",
        "            state_size (int): dimension of each state\n",
        "            action_size (int): dimension of each action\n",
        "            seed (int): random seed\n",
        "        \"\"\"\n",
        "        random.seed(seed)\n",
        "        self.state_size = state_size\n",
        "        self.action_size = action_size\n",
        "\n",
        "        # Q-Network\n",
        "        self.qnetwork_local = QNetwork(state_size, action_size, seed).to(device)\n",
        "        self.qnetwork_target = QNetwork(state_size, action_size, seed).to(device)\n",
        "        self.optimizer = optim.Adam(self.qnetwork_local.parameters(), lr=LR)\n",
        "\n",
        "        # Replay memory\n",
        "        self.memory = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE, seed)\n",
        "        # Initialize time step (for updating every UPDATE_EVERY steps)\n",
        "        self.t_step = 0\n",
        "\n",
        "    def step(self, state, action, reward, next_state, done):\n",
        "        # Save experience in replay memory\n",
        "        self.memory.add(state, action, reward, next_state, done)\n",
        "\n",
        "        # Learn every UPDATE_EVERY time steps.\n",
        "        self.t_step = (self.t_step + 1) % UPDATE_EVERY\n",
        "        if self.t_step == 0:\n",
        "            # If enough samples are available in memory, get random subset and learn\n",
        "            if len(self.memory) > BATCH_SIZE:\n",
        "                experiences = self.memory.sample()\n",
        "                self.learn(experiences, GAMMA)\n",
        "\n",
        "    def act(self, state, eps=0.):\n",
        "        \"\"\"Returns actions for given state as per current policy.\n",
        "\n",
        "        Params\n",
        "        ======\n",
        "            state (array_like): current state\n",
        "            eps (float): epsilon, for epsilon-greedy action selection\n",
        "        \"\"\"\n",
        "        state = T.from_numpy(state).float().unsqueeze(0).to(device)\n",
        "        self.qnetwork_local.eval()\n",
        "        with T.no_grad():\n",
        "            action_values = self.qnetwork_local(state)\n",
        "        self.qnetwork_local.train()\n",
        "\n",
        "        # Epsilon-greedy action selection\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",
        "    def learn(self, experiences, gamma):\n",
        "        \"\"\"Update value parameters using given batch of experience tuples.\n",
        "        Params\n",
        "        ======\n",
        "            experiences (Tuple[torch.Tensor]): tuple of (s, a, r, s', done) tuples\n",
        "            gamma (float): discount factor\n",
        "        \"\"\"\n",
        "        states, actions, rewards, next_states, dones = experiences\n",
        "\n",
        "        # Get max predicted Q values (for next states) from target model\n",
        "        q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\n",
        "        # Compute Q targets for current states\n",
        "        q_targets = rewards + (gamma * q_targets_next * (1 - dones))\n",
        "\n",
        "        # Get expected Q values from local model\n",
        "        q_expected = self.qnetwork_local(states).gather(1, actions)\n",
        "\n",
        "        # Compute loss\n",
        "        loss = F.mse_loss(q_expected, q_targets)\n",
        "        # Minimize the loss\n",
        "        self.optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        self.optimizer.step()\n",
        "\n",
        "        # ------------------- update target network ------------------- #\n",
        "        self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)\n",
        "\n",
        "    def soft_update(self, local_model, target_model, tau):\n",
        "        \"\"\"Soft update model parameters.\n",
        "        θ_target = τ*θ_local + (1 - τ)*θ_target\n",
        "        Params\n",
        "        ======\n",
        "            local_model (PyTorch model): weights will be copied from\n",
        "            target_model (PyTorch model): weights will be copied to\n",
        "            tau (float): interpolation parameter\n",
        "        \"\"\"\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"
      ],
      "metadata": {
        "trusted": true,
        "id": "dMvIHt2fJHGd"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The training loop"
      ],
      "metadata": {
        "id": "yQtM9_vGJHGe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def dqn(n_episodes=2000, max_t=1000, eps_start=1.0, eps_end=0.01, eps_decay=0.995):\n",
        "    \"\"\"Deep Q-Learning.\n",
        "\n",
        "    Params\n",
        "    ======\n",
        "        n_episodes (int): maximum number of training episodes\n",
        "        max_t (int): maximum number of timesteps per episode\n",
        "        eps_start (float): starting value of epsilon, for epsilon-greedy action selection\n",
        "        eps_end (float): minimum value of epsilon\n",
        "        eps_decay (float): multiplicative factor (per episode) for decreasing epsilon\n",
        "    \"\"\"\n",
        "    scores = []  # list containing scores from each episode\n",
        "    scores_window = deque(maxlen=100)  # last 100 scores\n",
        "    eps = eps_start  # initialize epsilon\n",
        "    for i_episode in range(1, n_episodes + 1):\n",
        "        state = env.reset()\n",
        "        score = 0\n",
        "        for t in range(max_t):\n",
        "            if isinstance(state, tuple):\n",
        "              state = state[0]\n",
        "            action = agent.act(state, eps)\n",
        "            next_state, reward, done, truncated, _ = env.step(action)\n",
        "            agent.step(state, action, reward, next_state, done)\n",
        "            state = next_state\n",
        "            score += reward\n",
        "            if done:\n",
        "                break\n",
        "        scores_window.append(score)  # save most recent score\n",
        "        scores.append(score)  # save most recent score\n",
        "        eps = max(eps_end, eps_decay * eps)  # decrease epsilon\n",
        "        print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)), end=\"\")\n",
        "        if i_episode % 100 == 0:\n",
        "            print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\n",
        "        if np.mean(scores_window) >= 200.0:\n",
        "            print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode - 100,\n",
        "                                                                                         np.mean(scores_window)))\n",
        "            T.save(agent.qnetwork_local.state_dict(), 'data.pth')\n",
        "            break\n",
        "    return scores\n",
        ""
      ],
      "metadata": {
        "trusted": true,
        "id": "seg0kfYJJHGe"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import gym\n",
        "\n",
        "# initialize environment\n",
        "env = gym.make('LunarLander-v2')\n",
        "# env.seed(0)\n",
        "print('State shape: ', env.observation_space.shape)\n",
        "print('Number of actions: ', env.action_space.n)\n",
        "\n",
        "# initialize agent\n",
        "agent = Agent(state_size=8, action_size=4, seed=0)\n",
        "\n",
        "# run the training session\n",
        "scores = dqn()"
      ],
      "metadata": {
        "trusted": true,
        "id": "MnZeQDFTJHGe",
        "outputId": "b20271d1-f6e4-449d-f79f-a3c70343f525",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "State shape:  (8,)\n",
            "Number of actions:  4\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/opt/conda/lib/python3.10/site-packages/gym/utils/passive_env_checker.py:233: DeprecationWarning: `np.bool8` is a deprecated alias for `np.bool_`.  (Deprecated NumPy 1.24)\n",
            "  if not isinstance(terminated, (bool, np.bool8)):\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Episode 100\tAverage Score: -188.23\n",
            "Episode 200\tAverage Score: -134.95\n",
            "Episode 300\tAverage Score: -70.04\n",
            "Episode 400\tAverage Score: 5.51\n",
            "Episode 500\tAverage Score: 36.89\n",
            "Episode 600\tAverage Score: 79.99\n",
            "Episode 700\tAverage Score: 169.98\n",
            "Episode 800\tAverage Score: 177.46\n",
            "Episode 851\tAverage Score: 200.22\n",
            "Environment solved in 751 episodes!\tAverage Score: 200.22\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Plot the rewards"
      ],
      "metadata": {
        "id": "JL9sI301JHGf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%matplotlib inline\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# plot the scores\n",
        "fig = plt.figure()\n",
        "ax = fig.add_subplot(111)\n",
        "plt.plot(np.arange(len(scores)), scores)\n",
        "plt.ylabel('Score')\n",
        "plt.xlabel('Epsiode #')\n",
        "plt.show()"
      ],
      "metadata": {
        "trusted": true,
        "id": "pHb9Jg6FJHGf",
        "outputId": "e88347c5-f1f9-40a8-ede1-8ddc5045588c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        }
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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"
          },
          "metadata": {}
        }
      ]
    }
  ]
}