20240213_Navigation_DuelingDQN_train.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Nov05/Google-Colaboratory/blob/master/20240213_Navigation_DuelingDQN_train.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **\\<TOP>**\n",
        "\n",
        "* modified by nov05 on 2024-02-13\n",
        "* check [**the dueling DQN paper**, arxiv 1511.06581](https://arxiv.org/abs/1511.06581)     \n",
        "* go to [the eval notebook](https://github.com/Nov05/udacity-deep-reinforcement-learning/blob/master/p1_navigation/20240211_Navigation_DQN_eval.ipynb) (run in Windows 11)   \n",
        "\n",
        "<br>\n",
        "\n",
        "---\n",
        "\n",
        "* check the original DQN notebook on [GitHub](https://github.com/udacity/deep-reinforcement-learning/tree/master/p1_navigation)  \n",
        "the dependency folder `./python` on [GitHub](https://github.com/udacity/deep-reinforcement-learning/tree/master/python)       \n",
        "* refer to [the DQN notebook](https://drive.google.com/file/d/1J4tO1sFULVQ5MAhRfTz4gpThqd3_NgZR) and [other notebooks](https://gist.github.com/Nov05/4e0ff3edba96928facaff063039c7bce)  \n",
        "* refer to [the Dueling DQN for pixel game](https://github.com/dxyang/DQN_pytorch/blob/master/model.py)  \n",
        "\n",
        "<br>\n",
        "\n",
        "---\n",
        "\n",
        "<br>\n",
        "\n",
        "<table>\n",
        "<tr>\n",
        "<th> Dueling Architecture </th>\n",
        "<th> The green module </th>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>\n",
        "<img src=\"https://github.com/Nov05/pictures/blob/master/Udacity/20231221_reinforcement%20learning/2024-02-13%2012_08_13-1511.06581.pdf.jpg?raw=true\" width=300>  \n",
        "</td>\n",
        "<td>\n",
        "<img src=\"https://github.com/Nov05/pictures/blob/master/Udacity/20231221_reinforcement%20learning/2024-02-13%2012_11_04-1511.06581.pdf.jpg?raw=true\" width=300>\n",
        "</td>\n",
        "</tr>\n",
        "</table>  \n",
        "\n",
        "```text\n",
        "▪️ Since both the advantage and the value stream propagate gradients to the last convolutional layer in the backward pass,\n",
        "we rescale the combined gradient entering the last convolutional layer by 1/√2. This simple heuristic mildly increases stability.\n",
        "▪️ In addition, we clip the gradients to have their norm less than or equal to 10. This clipping is not\n",
        "standard practice in deep RL, but common in recurrent network training (Bengio et al., 2013).\n",
        "\n",
        "```\n"
      ],
      "metadata": {
        "id": "YoyHLk7nCbpl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!cat /etc/*release\n",
        "## Ubuntu 22.04.3 LTS (Jammy Jellyfish)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w3XfoZ4aGEiB",
        "outputId": "d13acafa-e801-46fd-f4d5-bd2c6c129120"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "DISTRIB_ID=Ubuntu\n",
            "DISTRIB_RELEASE=22.04\n",
            "DISTRIB_CODENAME=jammy\n",
            "DISTRIB_DESCRIPTION=\"Ubuntu 22.04.3 LTS\"\n",
            "PRETTY_NAME=\"Ubuntu 22.04.3 LTS\"\n",
            "NAME=\"Ubuntu\"\n",
            "VERSION_ID=\"22.04\"\n",
            "VERSION=\"22.04.3 LTS (Jammy Jellyfish)\"\n",
            "VERSION_CODENAME=jammy\n",
            "ID=ubuntu\n",
            "ID_LIKE=debian\n",
            "HOME_URL=\"https://www.ubuntu.com/\"\n",
            "SUPPORT_URL=\"https://help.ubuntu.com/\"\n",
            "BUG_REPORT_URL=\"https://bugs.launchpad.net/ubuntu/\"\n",
            "PRIVACY_POLICY_URL=\"https://www.ubuntu.com/legal/terms-and-policies/privacy-policy\"\n",
            "UBUNTU_CODENAME=jammy\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%capture\n",
        "## download the \"\"./python\" folder.\n",
        "## https://github.com/udacity/deep-reinforcement-learning/tree/master/python\n",
        "import gdown\n",
        "url = \"https://drive.google.com/drive/folders/10a5WA1afaEIRgfYz7513kEc0eJTQQ1mK\"\n",
        "gdown.download_folder(url)"
      ],
      "metadata": {
        "id": "udH5oFm8eTeE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "%%capture\n",
        "## change work directory\n",
        "%cd python\n",
        "## get the banana build. you don't need to install ml-agents.\n",
        "!wget https://s3-us-west-1.amazonaws.com/udacity-drlnd/P1/Banana/Banana_Linux.zip\n",
        "!unzip Banana_Linux.zip\n",
        "!rm Banana_Linux.zip"
      ],
      "metadata": {
        "id": "AfIssFbUDF7K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ebUQoIf5Cabc"
      },
      "source": [
        "# **Navigation**   \n",
        "\n",
        "---\n",
        "\n",
        "In this notebook, you will learn how to use the Unity ML-Agents environment for the first project of the [Deep Reinforcement Learning Nanodegree](https://www.udacity.com/course/deep-reinforcement-learning-nanodegree--nd893)."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **1. Start the Environment**  \n",
        "\n",
        "We begin by importing some necessary packages.  If the code cell below returns an error, please revisit the project instructions to double-check that you have installed [Unity ML-Agents](https://github.com/Unity-Technologies/ml-agents/blob/master/docs/Installation.md) and [NumPy](http://www.numpy.org/)."
      ],
      "metadata": {
        "id": "CunpqWwGUsVe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "👉 If you restart the session (Ctrl+M.), run from the following cell.  "
      ],
      "metadata": {
        "id": "saPrh1GlyO3b"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oFKuzS6ECabg"
      },
      "outputs": [],
      "source": [
        "# %cd python\n",
        "from unityagents import UnityEnvironment\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nSUan7BLCabh"
      },
      "source": [
        "Next, we will start the environment!  **_Before running the code cell below_**, change the `file_name` parameter to match the location of the Unity environment that you downloaded.\n",
        "\n",
        "- **Mac**: `\"path/to/Banana.app\"`\n",
        "- **Windows** (x86): `\"path/to/Banana_Windows_x86/Banana.exe\"`\n",
        "- **Windows** (x86_64): `\"path/to/Banana_Windows_x86_64/Banana.exe\"`\n",
        "- **Linux** (x86): `\"path/to/Banana_Linux/Banana.x86\"`\n",
        "- **Linux** (x86_64): `\"path/to/Banana_Linux/Banana.x86_64\"`\n",
        "- **Linux** (x86, headless): `\"path/to/Banana_Linux_NoVis/Banana.x86\"`\n",
        "- **Linux** (x86_64, headless): `\"path/to/Banana_Linux_NoVis/Banana.x86_64\"`\n",
        "\n",
        "For instance, if you are using a Mac, then you downloaded `Banana.app`.  If this file is in the same folder as the notebook, then the line below should appear as follows:\n",
        "```\n",
        "env = UnityEnvironment(file_name=\"Banana.app\")\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CyHlsgF3Cabh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "000e1856-14f3-4f96-fe62-381924b0dffd"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CPU times: user 21.7 ms, sys: 9.99 ms, total: 31.7 ms\n",
            "Wall time: 1.11 s\n"
          ]
        }
      ],
      "source": [
        "%%time\n",
        "env = UnityEnvironment(file_name=\"./Banana_Linux/Banana.x86_64\", no_graphics=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qJ7AKsSjCabi"
      },
      "source": [
        "Environments contain **_brains_** which are responsible for deciding the actions of their associated agents. Here we check for the first brain available, and set it as the default brain we will be controlling from Python."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "37OjyA8kCabi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e69d5c55-5208-4b6b-f45e-b94bc79131a4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Unity brain name: BananaBrain\n",
            "        Number of Visual Observations (per agent): 0\n",
            "        Vector Observation space type: continuous\n",
            "        Vector Observation space size (per agent): 37\n",
            "        Number of stacked Vector Observation: 1\n",
            "        Vector Action space type: discrete\n",
            "        Vector Action space size (per agent): 4\n",
            "        Vector Action descriptions: , , , \n"
          ]
        }
      ],
      "source": [
        "# get the default brain\n",
        "brain_name = env.brain_names[0]\n",
        "brain = env.brains[brain_name]\n",
        "print(brain)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VRatfghmCabi"
      },
      "source": [
        "### **2. Examine the State and Action Spaces**   \n",
        "\n",
        "The simulation contains a single agent that navigates a large environment.  At each time step, it has four actions at its disposal:\n",
        "- `0` - walk forward\n",
        "- `1` - walk backward\n",
        "- `2` - turn left\n",
        "- `3` - turn right\n",
        "\n",
        "The state space has `37` dimensions and contains the agent's velocity, along with ray-based perception of objects around agent's forward direction.  A reward of `+1` is provided for collecting a yellow banana, and a reward of `-1` is provided for collecting a blue banana.\n",
        "\n",
        "Run the code cell below to print some information about the environment."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1iWX9CxqCabi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "52812078-041b-44aa-f800-5a9a0caeacef"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of agents: 1\n",
            "Number of actions: 4\n",
            "States look like:\n",
            " [1.         0.         0.         0.         0.84408134 0.\n",
            " 0.         1.         0.         0.0748472  0.         1.\n",
            " 0.         0.         0.25755    1.         0.         0.\n",
            " 0.         0.74177343 0.         1.         0.         0.\n",
            " 0.25854847 0.         0.         1.         0.         0.09355672\n",
            " 0.         1.         0.         0.         0.31969345 0.\n",
            " 0.        ]\n",
            "States have length: 37\n"
          ]
        }
      ],
      "source": [
        "## reset the environment\n",
        "env_info = env.reset(train_mode=True)[brain_name]\n",
        "## number of agents in the environment\n",
        "print('Number of agents:', len(env_info.agents))\n",
        "## number of actions\n",
        "action_size = brain.vector_action_space_size\n",
        "print('Number of actions:', action_size)\n",
        "## examine the state space\n",
        "state = env_info.vector_observations[0]\n",
        "print('States look like:\\n', state)\n",
        "state_size = len(state)\n",
        "print('States have length:', state_size)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N1uk5TwTCabj"
      },
      "source": [
        "### **3. Take Random Actions in the Environment**  \n",
        "\n",
        "In the next code cell, you will learn how to use the Python API to control the agent and receive feedback from the environment.\n",
        "\n",
        "Once this cell is executed, you will watch the agent's performance, if it selects an action (uniformly) at random with each time step.  A window should pop up that allows you to observe the agent, as it moves through the environment.  \n",
        "\n",
        "Of course, as part of the project, you'll have to change the code so that the agent is able to use its experience to gradually choose better actions when interacting with the environment!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Q4fkinLMCabj"
      },
      "outputs": [],
      "source": [
        "# %%time\n",
        "# env_info = env.reset(train_mode=False)[brain_name] # reset the environment\n",
        "# state = env_info.vector_observations[0]            # get the current state\n",
        "# score = 0                                          # initialize the score\n",
        "# while True:\n",
        "#     action = np.random.randint(action_size)        # select an action\n",
        "#     env_info = env.step(action)[brain_name]        # send the action to the environment\n",
        "#     next_state = env_info.vector_observations[0]   # get the next state\n",
        "#     reward = env_info.rewards[0]                   # get the reward\n",
        "#     done = env_info.local_done[0]                  # see if episode has finished\n",
        "#     score += reward                                # update the score\n",
        "#     state = next_state                             # roll over the state to next time step\n",
        "#     if done:                                       # exit loop if episode finished\n",
        "#         break\n",
        "# print(\"Score: {}\".format(score))\n",
        "# # env.close()\n",
        "# ## Wall time: 29.8 s"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ujhLsquRCabk"
      },
      "source": [
        "When finished, you can close the environment."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zi47q_qRCabk"
      },
      "source": [
        "### **4. It's Your Turn!**  \n",
        "\n",
        "Now it's your turn to train your own agent to solve the environment!  When training the environment, set `train_mode=True`, so that the line for resetting the environment looks like the following:\n",
        "```python\n",
        "env_info = env.reset(train_mode=True)[brain_name]\n",
        "```  \n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **class QNetwork**  "
      ],
      "metadata": {
        "id": "7iRZgpcgxEqZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "class QNetwork(nn.Module):\n",
        "    \"\"\"Actor (Policy) Model.\"\"\"\n",
        "\n",
        "    def __init__(self, state_size, action_size, seed):\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",
        "        \"\"\"\n",
        "        super(QNetwork, self).__init__()\n",
        "        self.seed = torch.manual_seed(seed)\n",
        "        \"*** YOUR CODE HERE ***\"\n",
        "        self.layer1 = nn.Linear(state_size, 64)\n",
        "        self.layer2 = nn.Linear(64, 64)\n",
        "        self.layer3_adv = nn.Linear(in_features=64, out_features=action_size) ## advantage\n",
        "        self.layer3_val = nn.Linear(in_features=64, out_features=1) ## state value\n",
        "\n",
        "    def forward(self, state):\n",
        "        \"\"\"Build a network that maps state -> action values.\"\"\"\n",
        "        x = F.relu(self.layer1(state))\n",
        "        x = F.relu(self.layer2(x))\n",
        "        adv, val = self.layer3_adv(x), self.layer3_val(x)\n",
        "        # print(val.shape, adv.shape, adv.mean(1).shape,\n",
        "        #       adv.mean(1).unsqueeze(1).expand(x.size(0), action_size).shape)\n",
        "        return (val + adv - adv.mean(1).unsqueeze(1).expand(x.size(0), action_size)) / (2**0.5)"
      ],
      "metadata": {
        "id": "heidiYbOcioo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# ## verify tensor shapes\n",
        "# ## e.g. torch.Size([1, 1]) torch.Size([1, 4]) torch.Size([1]) torch.Size([1, 4])\n",
        "# ##      tensor([[-0.0165,  0.0439, -0.0170, -0.0675]], grad_fn=<DivBackward0>)\n",
        "# import numpy as np\n",
        "# qnetwork = QNetwork(37, 4, 0)\n",
        "# state = np.random.rand(37)\n",
        "# state = torch.from_numpy(state).float().unsqueeze(0)\n",
        "# qnetwork.forward(state)"
      ],
      "metadata": {
        "id": "-yU2oe9co0dW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **class ReplayBuffer**     "
      ],
      "metadata": {
        "id": "6l4Jf0G_xNjv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import random\n",
        "from collections import namedtuple, deque\n",
        "import torch\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "\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",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\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",
        "\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 = torch.from_numpy(np.vstack([e.state for e in experiences if e])).float().to(device) ## aka. observations\n",
        "        actions = torch.from_numpy(np.vstack([e.action for e in experiences if e])).long().to(device)\n",
        "        rewards = torch.from_numpy(np.vstack([e.reward for e in experiences if e])).float().to(device)\n",
        "        next_states = torch.from_numpy(np.vstack([e.next_state for e in experiences if e])).float().to(device)\n",
        "        dones = torch.from_numpy(np.vstack([e.done for e in experiences if e]).astype(np.uint8)).float().to(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": {
        "id": "xSDkHEfQc8Yr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **class Agent**  "
      ],
      "metadata": {
        "id": "5TfjidDqxR-C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "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",
        "        self.state_size = state_size\n",
        "        self.action_size = action_size\n",
        "        self.seed = random.seed(seed)\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 = torch.from_numpy(state).float().unsqueeze(0).to(device)\n",
        "        self.qnetwork_local.eval()\n",
        "        with torch.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",
        "        target_j = reward_j + gamma * max_a ()\n",
        "\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",
        "        ## TODO: compute and minimize the loss\n",
        "        \"*** YOUR CODE HERE ***\"\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",
        "        ## clip the gradients\n",
        "        nn.utils.clip_grad_norm_(self.qnetwork_local.parameters(), 10.)\n",
        "        nn.utils.clip_grad_norm_(self.qnetwork_target.parameters(), 10.)\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",
        "\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)"
      ],
      "metadata": {
        "id": "jkWEhpWodak6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "agent = Agent(state_size=state_size, action_size=action_size, seed=0)\n",
        "# print(agent.qnetwork_local)\n",
        "for param in list(agent.qnetwork_local.parameters()):\n",
        "    print(param.shape)"
      ],
      "metadata": {
        "id": "XrL6hmKSdkXw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e3973dd3-2b39-43ba-cd1f-81d7905a2d0b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([64, 37])\n",
            "torch.Size([64])\n",
            "torch.Size([64, 64])\n",
            "torch.Size([64])\n",
            "torch.Size([4, 64])\n",
            "torch.Size([4])\n",
            "torch.Size([1, 64])\n",
            "torch.Size([1])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Benchmark Implementation**  \n",
        "\n",
        "In case you get stuck, note that you should be able to solve the project by making only minor modifications to the DQN code provided as part of the Deep Q-Networks lesson. Please see the image below for an example of how you might expect your agent's score to evolve. If you're interested in about how long it should take, in the solution code for the project, we were able to solve the project **in fewer than 1800 episodes**."
      ],
      "metadata": {
        "id": "VDq9ciUTo6qt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **function train()**"
      ],
      "metadata": {
        "id": "Z1DvJnO7xZ2t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%time\n",
        "import sys\n",
        "from tqdm import tqdm\n",
        "\n",
        "def train(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",
        "    score_max = float('-inf')\n",
        "    is_solved = False\n",
        "    eps = eps_start                    # initialize epsilon\n",
        "    for i_episode in range(1, n_episodes+1):\n",
        "    # for i_episode in tqdm(range(1, n_episodes+1), desc=\"Episodes\", position=0, leave=True):\n",
        "        state = env.reset(train_mode=True)[brain_name].vector_observations[0]\n",
        "        score = 0\n",
        "        for t in range(max_t):\n",
        "            action = agent.act(state, eps)\n",
        "            env_info = env.step(action)[brain_name]\n",
        "            next_state, reward, done = env_info.vector_observations[0], \\\n",
        "                                       env_info.rewards[0], env_info.local_done[0]\n",
        "            agent.step(state, action, reward, next_state, done) ## learn every UPDATE_EVERY = 4 steps\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",
        "        scores_mean = np.mean(scores_window)\n",
        "        if scores_mean>=20. and scores_mean>score_max:\n",
        "            score_max = scores_mean\n",
        "            if not is_solved:\n",
        "                is_solved = True\n",
        "                print('\\nEnvironment solved in {:d} episodes!'.format(i_episode-100))\n",
        "            print(\"\\nCheckpoint is saved at episode {:d}, average score: {:.2f}\".format(i_episode, np.mean(scores_window)))\n",
        "            torch.save(agent.qnetwork_local.state_dict(), f'checkpoint_{i_episode}.pth')\n",
        "    return scores\n",
        "\n",
        "scores = train()"
      ],
      "metadata": {
        "id": "ZXwpOfAgohD3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "545d04be-a438-4e99-fe13-b2d26ee8b265"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Episode 100\tAverage Score: 0.41\n",
            "Episode 200\tAverage Score: 2.81\n",
            "Episode 300\tAverage Score: 6.19\n",
            "Episode 400\tAverage Score: 9.32\n",
            "Episode 500\tAverage Score: 13.57\n",
            "Episode 600\tAverage Score: 15.33\n",
            "Episode 700\tAverage Score: 15.67\n",
            "Episode 800\tAverage Score: 15.87\n",
            "Episode 900\tAverage Score: 16.20\n",
            "Episode 1000\tAverage Score: 16.47\n",
            "Episode 1100\tAverage Score: 16.46\n",
            "Episode 1200\tAverage Score: 17.12\n",
            "Episode 1300\tAverage Score: 16.46\n",
            "Episode 1400\tAverage Score: 16.58\n",
            "Episode 1500\tAverage Score: 16.43\n",
            "Episode 1600\tAverage Score: 15.84\n",
            "Episode 1700\tAverage Score: 16.37\n",
            "Episode 1800\tAverage Score: 17.03\n",
            "Episode 1900\tAverage Score: 17.03\n",
            "Episode 2000\tAverage Score: 17.03\n",
            "CPU times: user 31min 45s, sys: 1min 57s, total: 33min 43s\n",
            "Wall time: 45min 39s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tesla T4, linear_256_64:  \n",
        "2000 episodes, avg score around 15  \n",
        "Wall time: 29min 39s  "
      ],
      "metadata": {
        "id": "rgdfw3T94sBp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## since the training didn't reach 20, the desired score, no checkpoint has been automatically save.\n",
        "## manually save the model weights.\n",
        "torch.save(agent.qnetwork_local.state_dict(), f'dqn_checkpoint_2000.pth')"
      ],
      "metadata": {
        "id": "6M1IUnaK3sWv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "# plot the scores\n",
        "fig = plt.figure()\n",
        "ax = fig.add_subplot(111)\n",
        "plt.plot(np.arange(len(scores)), scores)\n",
        "plt.plot(np.arange(len(scores)), pd.DataFrame(scores).rolling(window=100).mean())\n",
        "plt.ylabel('Score')\n",
        "plt.xlabel('Episode #')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "xW7u04YVt8yM",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        },
        "outputId": "486bc1db-056f-4dbb-b854-ecf4979570d3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **\\<BOTTOM>**  "
      ],
      "metadata": {
        "id": "igVarKO4ZdSz"
      }
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "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.6.4"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}