pongrl.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-Network implementation. (30 pts)\n",
    "\n",
    "This homework shamelessly demands you to implement DQN — an approximate Q-learning algorithm with experience replay and target networks — and see if it works any better this way.\n",
    "\n",
    "Original paper:\n",
    "https://arxiv.org/pdf/1312.5602.pdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can take some 2 hours for the agent to start improving, and up to 40 hours to convergence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bash: ../xvfb: No such file or directory\r\n"
     ]
    }
   ],
   "source": [
    "import sys, os\n",
    "if 'google.colab' in sys.modules and not os.path.exists('.setup_complete'):\n",
    "    !wget -q https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/setup_colab.sh -O- | bash\n",
    "        \n",
    "    !wget -q https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/week04_approx_rl/atari_wrappers.py\n",
    "    !wget -q https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/week04_approx_rl/utils.py\n",
    "    !wget -q https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/week04_approx_rl/replay_buffer.py\n",
    "    !wget -q https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/week04_approx_rl/framebuffer.py\n",
    "\n",
    "    !touch .setup_complete\n",
    "\n",
    "# This code creates a virtual display to draw game images on.\n",
    "# It will have no effect if your machine has a monitor.\n",
    "if type(os.environ.get(\"DISPLAY\")) is not str or len(os.environ.get(\"DISPLAY\")) == 0:\n",
    "    !bash ../xvfb start\n",
    "    os.environ['DISPLAY'] = ':1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: gym[atari] in ./venv/lib/python3.9/site-packages (0.21.0)\r\n",
      "Requirement already satisfied: numpy>=1.18.0 in ./venv/lib/python3.9/site-packages (from gym[atari]) (1.22.0)\r\n",
      "Requirement already satisfied: cloudpickle>=1.2.0 in ./venv/lib/python3.9/site-packages (from gym[atari]) (2.0.0)\r\n",
      "Requirement already satisfied: ale-py~=0.7.1 in ./venv/lib/python3.9/site-packages (from gym[atari]) (0.7.4)\r\n",
      "Requirement already satisfied: importlib-metadata>=4.10.0 in ./venv/lib/python3.9/site-packages (from ale-py~=0.7.1->gym[atari]) (4.10.0)\r\n",
      "Requirement already satisfied: importlib-resources in ./venv/lib/python3.9/site-packages (from ale-py~=0.7.1->gym[atari]) (5.7.0)\r\n",
      "Requirement already satisfied: zipp>=0.5 in ./venv/lib/python3.9/site-packages (from importlib-metadata>=4.10.0->ale-py~=0.7.1->gym[atari]) (3.7.0)\r\n",
      "\u001B[33mWARNING: You are using pip version 21.1.2; however, version 22.0.4 is available.\r\n",
      "You should consider upgrading via the '/Users/vaaven/PycharmProjects/scientificProject/venv/bin/python -m pip install --upgrade pip' command.\u001B[0m\r\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import utils\n",
    "\n",
    "!pip install 'gym[atari]'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import gym.spaces\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's play some old videogames\n",
    "![img](https://github.com/yandexdataschool/Practical_RL/raw/master/yet_another_week/_resource/nerd.png)\n",
    "\n",
    "This time we're gonna apply approximate Q-learning to an Atari game called Breakout. It's not the hardest thing out there, but it's definitely way more complex than anything we tried before.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "ENV_NAME = \"PongNoFrameskip-v4\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocessing (9 pts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see what observations look like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "A.L.E: Arcade Learning Environment (version 0.7.4+069f8bd)\n",
      "[Powered by Stella]\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 1152x648 with 10 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "env = gym.make(ENV_NAME)\n",
    "env.reset()\n",
    "\n",
    "env.render(\"rgb_array\")\n",
    "\n",
    "n_cols = 5\n",
    "n_rows = 2\n",
    "fig = plt.figure(figsize=(16, 9))\n",
    "\n",
    "for row in range(n_rows):\n",
    "    for col in range(n_cols):\n",
    "        ax = fig.add_subplot(n_rows, n_cols, row * n_cols + col + 1)\n",
    "        ax.imshow(env.render('rgb_array'))\n",
    "        env.step(env.action_space.sample())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let's play a little.**\n",
    "\n",
    "Pay attention to zoom and fps args of play function. Control: A, D, space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Does not work in Colab.\n",
    "# # Use KeyboardInterrupt (Kernel → Interrupt in Jupyter) to continue.\n",
    "\n",
    "# from gym.utils.play import play\n",
    "\n",
    "# play(env=gym.make(ENV_NAME), zoom=5, fps=30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Processing game image \n",
    "\n",
    "Raw Atari images are large, 210x160x3 by default. However, we don't need that level of detail in order to learn from them.\n",
    "\n",
    "We can thus save a lot of time by preprocessing game image, including\n",
    "* Resizing to a smaller shape, 64x64\n",
    "* Converting to grayscale\n",
    "* Cropping irrelevant image parts (top, bottom and edges)\n",
    "\n",
    "Also please keep one dimension for channel so that final shape would be 1x64x64.\n",
    "\n",
    "Tip: You can implement your own grayscale converter and assign a huge weight to the red channel. This dirty trick is not necessary but it will speed up learning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gym.core import ObservationWrapper\n",
    "from gym.spaces import Box\n",
    "import cv2\n",
    "\n",
    "\n",
    "class PreprocessAtariObs(ObservationWrapper):\n",
    "    def __init__(self, env):\n",
    "        \"\"\"A gym wrapper that crops, scales image into the desired shapes and grayscales it.\"\"\"\n",
    "        ObservationWrapper.__init__(self, env)\n",
    "\n",
    "        self.img_size = (1, 64, 64)\n",
    "        self.observation_space = Box(0.0, 1.0, self.img_size)\n",
    "\n",
    "\n",
    "    def _to_gray_scale(self, rgb, channel_weights=[0.8, 0.1, 0.1]):\n",
    "        return np.dot(rgb, channel_weights)\n",
    "\n",
    "\n",
    "    def observation(self, img):\n",
    "        \"\"\"what happens to each observation\"\"\"\n",
    "\n",
    "        # Here's what you need to do:\n",
    "        #  * crop image, remove irrelevant parts\n",
    "        #  * resize image to self.img_size\n",
    "        #     (Use imresize from any library you want,\n",
    "        #      e.g. opencv, PIL, keras. Don't use skimage.imresize\n",
    "        #      because it is extremely slow.)\n",
    "        #  * cast image to grayscale\n",
    "        #  * convert image pixels to (0,1) range, float32 type\n",
    "        # print(img)\n",
    "        img = img[30:195, 10:150]\n",
    "        img = self._to_gray_scale(img)\n",
    "        img = cv2.resize(img, dsize=self.img_size[1:], interpolation = cv2.INTER_AREA)\n",
    "        img = img[..., np.newaxis]\n",
    "        img /= np.max(img)\n",
    "        img = np.swapaxes(img, 0, 2)\n",
    "        img = np.swapaxes(img, 1, 2)\n",
    "        return img.astype(np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float32\n",
      "Formal tests seem fine. Here's an example of what you'll get.\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 1152x648 with 10 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import gym\n",
    "# spawn game instance for tests\n",
    "env = gym.make(ENV_NAME)  # create raw env\n",
    "env = PreprocessAtariObs(env)\n",
    "observation_shape = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "env.reset()\n",
    "obs, _, _, _ = env.step(env.action_space.sample())\n",
    "\n",
    "print(obs.dtype)\n",
    "\n",
    "# test observation\n",
    "assert obs.ndim == 3, \"observation must be [channel, h, w] even if there's just one channel\"\n",
    "assert obs.shape == observation_shape, obs.shape\n",
    "assert obs.dtype == 'float32'\n",
    "assert len(np.unique(obs)) > 2, \"your image must not be binary\"\n",
    "assert 0 <= np.min(obs) and np.max(\n",
    "    obs) <= 1, \"convert image pixels to [0,1] range\"\n",
    "\n",
    "assert np.max(obs) >= 0.5, \"It would be easier to see a brighter observation\"\n",
    "assert np.mean(obs) >= 0.1, \"It would be easier to see a brighter observation\"\n",
    "\n",
    "print(\"Formal tests seem fine. Here's an example of what you'll get.\")\n",
    "\n",
    "n_cols = 5\n",
    "n_rows = 2\n",
    "fig = plt.figure(figsize=(16, 9))\n",
    "obs = env.reset()\n",
    "for row in range(n_rows):\n",
    "    for col in range(n_cols):\n",
    "        ax = fig.add_subplot(n_rows, n_cols, row * n_cols + col + 1)\n",
    "        ax.imshow(obs[0, :, :], interpolation='none', cmap='gray')\n",
    "        obs, _, _, _ = env.step(env.action_space.sample())\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wrapping."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**About the game:** You have 5 lives and get points for breaking the wall. Higher bricks cost more than the lower ones. There are 4 actions: start game (should be called at the beginning and after each life is lost), move left, move right and do nothing. There are some common wrappers used for Atari environments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import atari_wrappers\n",
    "\n",
    "def PrimaryAtariWrap(env, clip_rewards=True):\n",
    "    assert 'NoFrameskip' in env.spec.id\n",
    "\n",
    "    # This wrapper holds the same action for <skip> frames and outputs\n",
    "    # the maximal pixel value of 2 last frames (to handle blinking\n",
    "    # in some envs)\n",
    "    env = atari_wrappers.MaxAndSkipEnv(env, skip=4)\n",
    "\n",
    "    # This wrapper sends done=True when each life is lost\n",
    "    # (not all the 5 lives that are givern by the game rules).\n",
    "    # It should make easier for the agent to understand that losing is bad.\n",
    "    env = atari_wrappers.EpisodicLifeEnv(env)\n",
    "\n",
    "    # This wrapper laucnhes the ball when an episode starts.\n",
    "    # Without it the agent has to learn this action, too.\n",
    "    # Actually it can but learning would take longer.\n",
    "    env = atari_wrappers.FireResetEnv(env)\n",
    "\n",
    "    # This wrapper transforms rewards to {-1, 0, 1} according to their sign\n",
    "    if clip_rewards:\n",
    "        env = atari_wrappers.ClipRewardEnv(env)\n",
    "\n",
    "    # This wrapper is yours :)\n",
    "    env = PreprocessAtariObs(env)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let's see if the game is still playable after applying the wrappers.**\n",
    "At playing the EpisodicLifeEnv wrapper seems not to work but actually it does (because after when life finishes a new ball is dropped automatically - it means that FireResetEnv wrapper understands that a new episode began)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Does not work in Colab.\n",
    "# # Use KeyboardInterrupt (Kernel → Interrupt in Jupyter) to continue.\n",
    "\n",
    "# from gym.utils.play import play\n",
    "#\n",
    "# def make_play_env():\n",
    "#     env = gym.make(ENV_NAME)\n",
    "#     env = PrimaryAtariWrap(env)\n",
    "# # in PyTorch images have shape [c, h, w] instead of common [h, w, c]\n",
    "#     env = atari_wrappers.AntiTorchWrapper(env)\n",
    "#     return env\n",
    "#\n",
    "# play(make_play_env(), zoom=2, fps=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Frame buffer\n",
    "\n",
    "Our agent can only process one observation at a time, so we gotta make sure it contains enough information to find optimal actions. For instance, agent has to react to moving objects so it must be able to measure object's velocity.\n",
    "\n",
    "To do so, we introduce a buffer that stores 4 last images. This time everything is pre-implemented for you, not really by the staff of the course :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from framebuffer import FrameBuffer2\n",
    "\n",
    "def make_env(clip_rewards=True, seed=None):\n",
    "    env = gym.make(ENV_NAME)  # create raw env\n",
    "    if seed is not None:\n",
    "        env.seed(seed)\n",
    "    env = PrimaryAtariWrap(env, clip_rewards)\n",
    "    env = FrameBuffer2(env, n_frames=4, dim_order='pytorch')\n",
    "    return env\n",
    "\n",
    "env = make_env()\n",
    "env.reset()\n",
    "n_actions = env.action_space.n\n",
    "state_shape = env.observation_space.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 864x720 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "<Figure size 1080x1080 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for _ in range(12):\n",
    "    obs, _, _, _ = env.step(env.action_space.sample())\n",
    "\n",
    "plt.figure(figsize=[12,10])\n",
    "plt.title(\"Game image\")\n",
    "plt.imshow(env.render(\"rgb_array\"))\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=[15,15])\n",
    "plt.title(\"Agent observation (4 frames top to bottom)\")\n",
    "plt.imshow(utils.img_by_obs(obs, state_shape), cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN as it is (12 pts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a network\n",
    "\n",
    "We now need to build a neural network that can map images to state q-values. This network will be called on every agent's step so it better not be resnet-152 unless you have an array of GPUs. Instead, you can use strided convolutions with a small number of features to save time and memory.\n",
    "\n",
    "You can build any architecture you want, but for reference, here's something that will more or less work:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![img](https://github.com/yandexdataschool/Practical_RL/raw/master/yet_another_week/_resource/dqn_arch.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dueling network: (+2 pts)**\n",
    "$$Q_{\\theta}(s, a) = V_{\\eta}(f_{\\xi}(s)) + A_{\\psi}(f_{\\xi}(s), a) - \\frac{\\sum_{a'}A_{\\psi}(f_{\\xi}(s), a')}{N_{actions}},$$\n",
    "where $\\xi$, $\\eta$, and $\\psi$ are, respectively, the parameters of the\n",
    "shared encoder $f_ξ$ , of the value stream $V_\\eta$ , and of the advan\n",
    "tage stream $A_\\psi$; and $\\theta = \\{\\xi, \\eta, \\psi\\}$ is their concatenation.\n",
    "\n",
    "For the architecture on the image $V$ and $A$ heads can follow the dense layer instead of $Q$. Please don't worry that the model becomes a little bigger."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "device(type='cpu')"
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "# those who have a GPU but feel unfair to use it can uncomment:\n",
    "# device = torch.device('cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv2d_size_out(size, kernel_size, stride):\n",
    "    \"\"\"\n",
    "    common use case:\n",
    "    cur_layer_img_w = conv2d_size_out(cur_layer_img_w, kernel_size, stride)\n",
    "    cur_layer_img_h = conv2d_size_out(cur_layer_img_h, kernel_size, stride)\n",
    "    to understand the shape for dense layer's input\n",
    "    \"\"\"\n",
    "    return (size - (kernel_size - 1) - 1) // stride  + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "\n",
    "        # Define your network body here. Please make sure agent is fully contained here\n",
    "        # nn.Flatten() can be useful\n",
    "        print(state_shape[0])\n",
    "        self.layer1 = nn.Sequential(nn.Conv2d(state_shape[0], 16, kernel_size=(3, 3), stride=2),\n",
    "            nn.ReLU(),\n",
    "            # nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        )\n",
    "        self.layer2 = nn.Sequential(nn.Conv2d(16, 32, kernel_size=(3, 3), stride=2),\n",
    "            nn.ReLU(),\n",
    "            # nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        )\n",
    "        self.layer3 = nn.Sequential(nn.Conv2d(32, 64, kernel_size=(3, 3), stride=2),\n",
    "            nn.ReLU(),\n",
    "            # nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        )\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = nn.Linear(3136, 256)\n",
    "        self.fc2 = nn.Linear(256, n_actions)\n",
    "\n",
    "        \n",
    "\n",
    "    def forward(self, state_t):\n",
    "        \"\"\"\n",
    "        takes agent's observation (tensor), returns qvalues (tensor)\n",
    "        :param state_t: a batch of 4-frame buffers, shape = [batch_size, 4, h, w]\n",
    "        \"\"\"\n",
    "        # Use your network to compute qvalues for given state\n",
    "        out = self.layer1(state_t)\n",
    "        out = self.layer2(out)\n",
    "        out = self.layer3(out)\n",
    "        out = out.reshape(out.size(0), -1)\n",
    "        out = self.flatten(out)\n",
    "        out = self.fc1(out)\n",
    "        out = self.fc2(out)\n",
    "        qvalues = out\n",
    "\n",
    "        assert qvalues.requires_grad, \"qvalues must be a torch tensor with grad\"\n",
    "        assert (\n",
    "            len(qvalues.shape) == 2 and \n",
    "            qvalues.shape[0] == state_t.shape[0] and \n",
    "            qvalues.shape[1] == n_actions\n",
    "        )\n",
    "\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        \"\"\"\n",
    "        like forward, but works on numpy arrays, not tensors\n",
    "        \"\"\"\n",
    "        model_device = next(self.parameters()).device\n",
    "        states = torch.tensor(states, device=model_device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        \"\"\"pick actions given qvalues. Uses epsilon-greedy exploration strategy. \"\"\"\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "agent = DQNAgent(state_shape, n_actions, epsilon=0.5).to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's try out our agent to see if it raises any errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    \"\"\" Plays n_games full games. If greedy, picks actions as argmax(qvalues). Returns mean reward. \"\"\"\n",
    "    rewards = []\n",
    "    for _ in range(n_games):\n",
    "        s = env.reset()\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, done, _ = env.step(action)\n",
    "            reward += r\n",
    "            if done:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/99/207qlzmd6k59qvb31j8tkwxw0000gn/T/ipykernel_38796/4205996277.py:59: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at  ../torch/csrc/utils/tensor_new.cpp:201.)\n",
      "  states = torch.tensor(states, device=model_device, dtype=torch.float32)\n",
      "[W NNPACK.cpp:79] Could not initialize NNPACK! Reason: Unsupported hardware.\n"
     ]
    },
    {
     "data": {
      "text/plain": "-21.0"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(env, agent, n_games=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "For this assignment, we provide you with experience replay buffer. If you implemented experience replay buffer in last week's assignment, you can copy-paste it here **to get 2 bonus points**.\n",
    "\n",
    "![img](https://github.com/yandexdataschool/Practical_RL/raw/master/yet_another_week/_resource/exp_replay.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The interface is fairly simple:\n",
    "* `exp_replay.add(obs, act, rw, next_obs, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns observations, actions, rewards, next_observations and is_done for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from replay_buffer import ReplayBuffer\n",
    "exp_replay = ReplayBuffer(10)\n",
    "\n",
    "for _ in range(30):\n",
    "    exp_replay.add(env.reset(), env.action_space.sample(), 1.0, env.reset(), done=False)\n",
    "\n",
    "obs_batch, act_batch, reward_batch, next_obs_batch, is_done_batch = exp_replay.sample(5)\n",
    "\n",
    "assert len(exp_replay) == 10, \"experience replay size should be 10 because that's what maximum capacity is\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record(initial_state, agent, env, exp_replay, n_steps=1):\n",
    "    \"\"\"\n",
    "    Play the game for exactly n_steps, record every (s,a,r,s', done) to replay buffer. \n",
    "    Whenever game ends, add record with done=True and reset the game.\n",
    "    It is guaranteed that env has done=False when passed to this function.\n",
    "\n",
    "    PLEASE DO NOT RESET ENV UNLESS IT IS \"DONE\"\n",
    "\n",
    "    :returns: return sum of rewards over time and the state in which the env stays\n",
    "    \"\"\"\n",
    "    s = initial_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps as per instructions above\n",
    "    for _ in range(n_steps):\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        action = agent.sample_actions(qvalues)[0]\n",
    "        new_s, r, done, _ = env.step(action)\n",
    "        sum_rewards += r\n",
    "        exp_replay.add(s, action, r, new_s, done)\n",
    "        s = new_s\n",
    "        if done:\n",
    "            env.reset()\n",
    "\n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Well done!\n"
     ]
    }
   ],
   "source": [
    "# testing your code.\n",
    "exp_replay = ReplayBuffer(2000)\n",
    "\n",
    "state = env.reset()\n",
    "play_and_record(state, agent, env, exp_replay, n_steps=1000)\n",
    "\n",
    "# if you're using your own experience replay buffer, some of those tests may need correction.\n",
    "# just make sure you know what your code does\n",
    "assert len(exp_replay) == 1000, \\\n",
    "    \"play_and_record should have added exactly 1000 steps, \" \\\n",
    "    \"but instead added %i\" % len(exp_replay)\n",
    "is_dones = list(zip(*exp_replay._storage))[-1]\n",
    "\n",
    "assert 0 < np.mean(is_dones) < 0.1, \\\n",
    "    \"Please make sure you restart the game whenever it is 'done' and \" \\\n",
    "    \"record the is_done correctly into the buffer. Got %f is_done rate over \" \\\n",
    "    \"%i steps. [If you think it's your tough luck, just re-run the test]\" % (\n",
    "        np.mean(is_dones), len(exp_replay))\n",
    "\n",
    "for _ in range(100):\n",
    "    obs_batch, act_batch, reward_batch, next_obs_batch, is_done_batch = exp_replay.sample(10)\n",
    "    assert obs_batch.shape == next_obs_batch.shape == (10,) + state_shape\n",
    "    assert act_batch.shape == (10,), \\\n",
    "        \"actions batch should have shape (10,) but is instead %s\" % str(act_batch.shape)\n",
    "    assert reward_batch.shape == (10,), \\\n",
    "        \"rewards batch should have shape (10,) but is instead %s\" % str(reward_batch.shape)\n",
    "    assert is_done_batch.shape == (10,), \\\n",
    "        \"is_done batch should have shape (10,) but is instead %s\" % str(is_done_batch.shape)\n",
    "    assert [int(i) in (0, 1) for i in is_dones], \\\n",
    "        \"is_done should be strictly True or False\"\n",
    "    assert [0 <= a < n_actions for a in act_batch], \"actions should be within [0, n_actions)\"\n",
    "\n",
    "print(\"Well done!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Target networks\n",
    "\n",
    "We also employ the so called \"target network\" - a copy of neural network weights to be used for reference Q-values:\n",
    "\n",
    "The network itself is an exact copy of agent network, but it's parameters are not trained. Instead, they are moved here from agent's actual network every so often.\n",
    "\n",
    "$$ Q_{reference}(s,a) = r + \\gamma \\cdot \\max _{a'} Q_{target}(s',a') $$\n",
    "\n",
    "![img](https://github.com/yandexdataschool/Practical_RL/raw/master/yet_another_week/_resource/target_net.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    },
    {
     "data": {
      "text/plain": "<All keys matched successfully>"
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_network = DQNAgent(agent.state_shape, agent.n_actions, epsilon=0.5).to(device)\n",
    "# This is how you can load weights from agent into target network\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning with... Q-learning\n",
    "Here we write a function similar to `agent.update` from tabular q-learning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute Q-learning TD error:\n",
    "\n",
    "$$ L = { 1 \\over N} \\sum_i [ Q_{\\theta}(s,a) - Q_{reference}(s,a) ] ^2 $$\n",
    "\n",
    "With Q-reference defined as\n",
    "\n",
    "$$ Q_{reference}(s,a) = r(s,a) + \\gamma \\cdot max_{a'} Q_{target}(s', a') $$\n",
    "\n",
    "Where\n",
    "* $Q_{target}(s',a')$ denotes Q-value of next state and next action predicted by __target_network__\n",
    "* $s, a, r, s'$ are current state, action, reward and next state respectively\n",
    "* $\\gamma$ is a discount factor defined two cells above.\n",
    "\n",
    "\n",
    "__Note 1:__ there's an example input below. Feel free to experiment with it before you write the function.\n",
    "\n",
    "__Note 2:__ compute_td_loss is a source of 99% of bugs in this homework. If reward doesn't improve, it often helps to go through it line by line [with a rubber duck](https://rubberduckdebugging.com/).\n",
    "\n",
    "**Double DQN (+2 pts)**\n",
    "\n",
    "$$ Q_{reference}(s,a) = r(s, a) + \\gamma \\cdot\n",
    "Q_{target}(s',argmax_{a'}Q_\\theta(s', a')) $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_td_loss(states, actions, rewards, next_states, is_done,\n",
    "                    agent, target_network,\n",
    "                    gamma=0.99,\n",
    "                    check_shapes=False,\n",
    "                    device=device):\n",
    "    \"\"\" Compute td loss using torch operations only. Use the formulae above. \"\"\"\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float32)    # shape: [batch_size, *state_shape]\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.int64)    # shape: [batch_size]\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float32)  # shape: [batch_size]\n",
    "    # shape: [batch_size, *state_shape]\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float)\n",
    "    is_done = torch.tensor(\n",
    "        is_done.astype('float32'),\n",
    "        device=device,\n",
    "        dtype=torch.float32,\n",
    "    )  # shape: [batch_size]\n",
    "    is_not_done = 1 - is_done\n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    predicted_qvalues = agent(states)  # shape: [batch_size, n_actions]\n",
    "\n",
    "    # compute q-values for all actions in next states\n",
    "    predicted_next_qvalues = target_network(next_states)  # shape: [batch_size, n_actions]\n",
    "    \n",
    "    # select q-values for chosen actions\n",
    "    predicted_qvalues_for_actions = predicted_qvalues[range(len(actions)), actions]  # shape: [batch_size]\n",
    "\n",
    "    # compute V*(next_states) using predicted next q-values\n",
    "    next_state_values = torch.tensor([torch.max(i) for i in predicted_next_qvalues])\n",
    "\n",
    "    assert next_state_values.dim() == 1 and next_state_values.shape[0] == states.shape[0], \\\n",
    "        \"must predict one value per state\"\n",
    "\n",
    "    # compute \"target q-values\" for loss - it's what's inside square parentheses in the above formula.\n",
    "    # at the last state use the simplified formula: Q(s,a) = r(s,a) since s' doesn't exist\n",
    "    # you can multiply next state values by is_not_done to achieve this.\n",
    "    target_qvalues_for_actions = rewards + gamma * next_state_values\n",
    "\n",
    "    # mean squared error loss to minimize\n",
    "    loss = torch.mean((predicted_qvalues_for_actions - target_qvalues_for_actions.detach()) ** 2)\n",
    "\n",
    "    if check_shapes:\n",
    "        assert predicted_next_qvalues.data.dim() == 2, \\\n",
    "            \"make sure you predicted q-values for all actions in next state\"\n",
    "        assert next_state_values.data.dim() == 1, \\\n",
    "            \"make sure you computed V(s') as maximum over just the actions axis and not all axes\"\n",
    "        assert target_qvalues_for_actions.data.dim() == 1, \\\n",
    "            \"there's something wrong with target q-values, they must be a vector\"\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sanity checks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_batch, act_batch, reward_batch, next_obs_batch, is_done_batch = exp_replay.sample(10)\n",
    "\n",
    "loss = compute_td_loss(obs_batch, act_batch, reward_batch, next_obs_batch, is_done_batch,\n",
    "                       agent, target_network,\n",
    "                       gamma=0.99, check_shapes=True)\n",
    "loss.backward()\n",
    "\n",
    "assert loss.requires_grad and tuple(loss.data.size()) == (), \\\n",
    "    \"you must return scalar loss - mean over batch\"\n",
    "assert np.any(next(agent.parameters()).grad.data.cpu().numpy() != 0), \\\n",
    "    \"loss must be differentiable w.r.t. network weights\"\n",
    "assert np.all(next(target_network.parameters()).grad is None), \\\n",
    "    \"target network should not have grads\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Main loop (9 pts)\n",
    "\n",
    "It's time to put everything together and see if it learns anything."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import trange\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "<torch._C.Generator at 0x7fed890473d0>"
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 228\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4\n"
     ]
    },
    {
     "data": {
      "text/plain": "<All keys matched successfully>"
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env = make_env(seed)\n",
    "state_shape = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "state = env.reset()\n",
    "\n",
    "agent = DQNAgent(state_shape, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_shape, n_actions).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Buffer of size $10^4$ fits into 5 Gb RAM.\n",
    "\n",
    "Larger sizes ($10^5$ and $10^6$ are common) can be used. It can improve the learning, but $10^4$ is quite enough. $10^2$ will probably fail learning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n"
     ]
    }
   ],
   "source": [
    "REPLAY_BUFFER_SIZE = 10**4\n",
    "N_STEPS = 100\n",
    "\n",
    "exp_replay = ReplayBuffer(REPLAY_BUFFER_SIZE)\n",
    "for i in range(REPLAY_BUFFER_SIZE // N_STEPS):\n",
    "    if not utils.is_enough_ram(min_available_gb=0.1):\n",
    "        break\n",
    "    play_and_record(state, agent, env, exp_replay, n_steps=N_STEPS)\n",
    "    if len(exp_replay) == REPLAY_BUFFER_SIZE:\n",
    "        break\n",
    "print(len(exp_replay))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "timesteps_per_epoch = 1\n",
    "batch_size = 16\n",
    "total_steps = 3 * 10**6\n",
    "decay_steps = 10**6\n",
    "\n",
    "opt = torch.optim.Adam(agent.parameters(), lr=1e-4)\n",
    "\n",
    "init_epsilon = 1\n",
    "final_epsilon = 0.1\n",
    "\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 5000\n",
    "eval_freq = 5000\n",
    "\n",
    "max_grad_norm = 50\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_rw_history = []\n",
    "td_loss_history = []\n",
    "grad_norm_history = []\n",
    "initial_state_v_history = []\n",
    "step = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "def wait_for_keyboard_interrupt():\n",
    "    try:\n",
    "        while True:\n",
    "            time.sleep(1)\n",
    "    except KeyboardInterrupt:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.10000\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 1152x648 with 4 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|█████▌    | 1396489/2531293 [13:23:28<10:52:55, 28.97it/s] \n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mKeyboardInterrupt\u001B[0m                         Traceback (most recent call last)",
      "\u001B[0;32m/var/folders/99/207qlzmd6k59qvb31j8tkwxw0000gn/T/ipykernel_38796/2267943098.py\u001B[0m in \u001B[0;36m<module>\u001B[0;34m\u001B[0m\n\u001B[1;32m     53\u001B[0m         \u001B[0mloss\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mbackward\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     54\u001B[0m         \u001B[0mgrad_norm\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mnn\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mutils\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mclip_grad_norm_\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0magent\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mparameters\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mmax_grad_norm\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m---> 55\u001B[0;31m         \u001B[0mopt\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mstep\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m     56\u001B[0m         \u001B[0mopt\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mzero_grad\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     57\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n",
      "\u001B[0;32m~/PycharmProjects/scientificProject/venv/lib/python3.9/site-packages/torch/optim/optimizer.py\u001B[0m in \u001B[0;36mwrapper\u001B[0;34m(*args, **kwargs)\u001B[0m\n\u001B[1;32m     86\u001B[0m                 \u001B[0mprofile_name\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0;34m\"Optimizer.step#{}.step\"\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mformat\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mobj\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0m__class__\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0m__name__\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     87\u001B[0m                 \u001B[0;32mwith\u001B[0m \u001B[0mtorch\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mautograd\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mprofiler\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mrecord_function\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mprofile_name\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m---> 88\u001B[0;31m                     \u001B[0;32mreturn\u001B[0m \u001B[0mfunc\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m*\u001B[0m\u001B[0margs\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m**\u001B[0m\u001B[0mkwargs\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m     89\u001B[0m             \u001B[0;32mreturn\u001B[0m \u001B[0mwrapper\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     90\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n",
      "\u001B[0;32m~/PycharmProjects/scientificProject/venv/lib/python3.9/site-packages/torch/autograd/grad_mode.py\u001B[0m in \u001B[0;36mdecorate_context\u001B[0;34m(*args, **kwargs)\u001B[0m\n\u001B[1;32m     26\u001B[0m         \u001B[0;32mdef\u001B[0m \u001B[0mdecorate_context\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m*\u001B[0m\u001B[0margs\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m**\u001B[0m\u001B[0mkwargs\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     27\u001B[0m             \u001B[0;32mwith\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0m__class__\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m---> 28\u001B[0;31m                 \u001B[0;32mreturn\u001B[0m \u001B[0mfunc\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m*\u001B[0m\u001B[0margs\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m**\u001B[0m\u001B[0mkwargs\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m     29\u001B[0m         \u001B[0;32mreturn\u001B[0m \u001B[0mcast\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mF\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mdecorate_context\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     30\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n",
      "\u001B[0;32m~/PycharmProjects/scientificProject/venv/lib/python3.9/site-packages/torch/optim/adam.py\u001B[0m in \u001B[0;36mstep\u001B[0;34m(self, closure)\u001B[0m\n\u001B[1;32m    131\u001B[0m                     \u001B[0mstate_steps\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mappend\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mstate\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0;34m'step'\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    132\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 133\u001B[0;31m             F.adam(params_with_grad,\n\u001B[0m\u001B[1;32m    134\u001B[0m                    \u001B[0mgrads\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    135\u001B[0m                    \u001B[0mexp_avgs\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
      "\u001B[0;32m~/PycharmProjects/scientificProject/venv/lib/python3.9/site-packages/torch/optim/_functional.py\u001B[0m in \u001B[0;36madam\u001B[0;34m(params, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, amsgrad, beta1, beta2, lr, weight_decay, eps)\u001B[0m\n\u001B[1;32m     96\u001B[0m         \u001B[0mstep_size\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mlr\u001B[0m \u001B[0;34m/\u001B[0m \u001B[0mbias_correction1\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     97\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m---> 98\u001B[0;31m         \u001B[0mparam\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0maddcdiv_\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mexp_avg\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mdenom\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mvalue\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0;34m-\u001B[0m\u001B[0mstep_size\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m     99\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    100\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n",
      "\u001B[0;31mKeyboardInterrupt\u001B[0m: "
     ]
    }
   ],
   "source": [
    "gamma = 0.99\n",
    "n_lives = 1\n",
    "\n",
    "state = env.reset()\n",
    "with trange(step, total_steps + 1) as progress_bar:\n",
    "    for step in progress_bar:\n",
    "        if not utils.is_enough_ram():\n",
    "            print('less that 100 Mb RAM available, freezing')\n",
    "            print('make sure everything is ok and use KeyboardInterrupt to continue')\n",
    "            wait_for_keyboard_interrupt()\n",
    "\n",
    "        agent.epsilon = utils.linear_decay(init_epsilon, final_epsilon, step, decay_steps)\n",
    "\n",
    "        # play\n",
    "        _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "        # train\n",
    "        states, actions, rewards, next_states, is_done = exp_replay.sample(batch_size)\n",
    "        states = torch.tensor(\n",
    "            states, dtype=torch.float32)    # shape: [batch_size, state_size]\n",
    "        actions = torch.tensor(actions, dtype=torch.long)    # shape: [batch_size]\n",
    "        rewards = torch.tensor(rewards, dtype=torch.float32)  # shape: [batch_size]\n",
    "        # shape: [batch_size, state_size]\n",
    "        next_states = torch.tensor(next_states, dtype=torch.float32)\n",
    "        is_done = torch.tensor(is_done, dtype=torch.uint8)\n",
    "\n",
    "        predicted_qvalues = agent(states)\n",
    "\n",
    "        # select q-values for chosen actions\n",
    "        predicted_qvalues_for_actions = predicted_qvalues[\n",
    "          range(states.shape[0]), actions\n",
    "        ]\n",
    "\n",
    "        # compute q-values for all actions in next states\n",
    "        # print([torch.max(network(i)) for i in next_states])\n",
    "        predicted_next_qvalues = target_network(next_states)\n",
    "\n",
    "        # compute V*(next_states) using predicted next q-values\n",
    "        next_state_values = torch.tensor([torch.max(i) for i in predicted_next_qvalues])\n",
    "        assert next_state_values.dtype == torch.float32\n",
    "\n",
    "        # compute \"target q-values\" for loss - it's what's inside square parentheses in the above formula.\n",
    "        target_qvalues_for_actions = rewards + gamma * next_state_values\n",
    "\n",
    "        # at the last state we shall use simplified formula: Q(s,a) = r(s,a) since s' doesn't exist\n",
    "        target_qvalues_for_actions = torch.where(\n",
    "            is_done, rewards, target_qvalues_for_actions)\n",
    "\n",
    "        # mean squared error loss to minimize\n",
    "        loss = torch.mean((predicted_qvalues_for_actions -\n",
    "                           target_qvalues_for_actions.detach()) ** 2)\n",
    "\n",
    "        loss.backward()\n",
    "        grad_norm = nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm)\n",
    "        opt.step()\n",
    "        opt.zero_grad()\n",
    "\n",
    "        if step % loss_freq == 0:\n",
    "            td_loss_history.append(loss.data.cpu().item())\n",
    "            grad_norm_history.append(grad_norm)\n",
    "\n",
    "        if step % refresh_target_network_freq == 0:\n",
    "            # Load agent weights into target_network\n",
    "            target_network.load_state_dict(agent.state_dict())\n",
    "\n",
    "        if step % eval_freq == 0:\n",
    "            mean_rw_history.append(evaluate(\n",
    "                make_env(clip_rewards=True, seed=step), agent, n_games=3 * n_lives, greedy=False)\n",
    "            )\n",
    "            initial_state_q_values = agent.get_qvalues(\n",
    "                [make_env(seed=step).reset()]\n",
    "            )\n",
    "            initial_state_v_history.append(np.max(initial_state_q_values))\n",
    "\n",
    "            clear_output(True)\n",
    "            print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "                (len(exp_replay), agent.epsilon))\n",
    "\n",
    "            plt.figure(figsize=[16, 9])\n",
    "\n",
    "            plt.subplot(2, 2, 1)\n",
    "            plt.title(\"Mean reward per life\")\n",
    "            plt.plot(mean_rw_history)\n",
    "            plt.grid()\n",
    "\n",
    "            assert not np.isnan(td_loss_history[-1])\n",
    "            plt.subplot(2, 2, 2)\n",
    "            plt.title(\"TD loss history (smoothened)\")\n",
    "            plt.plot(utils.smoothen(td_loss_history))\n",
    "            plt.grid()\n",
    "\n",
    "            plt.subplot(2, 2, 3)\n",
    "            plt.title(\"Initial state V\")\n",
    "            plt.plot(initial_state_v_history)\n",
    "            plt.grid()\n",
    "\n",
    "            plt.subplot(2, 2, 4)\n",
    "            plt.title(\"Grad norm history (smoothened)\")\n",
    "            plt.plot(utils.smoothen(grad_norm_history))\n",
    "            plt.grid()\n",
    "\n",
    "            plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agent is evaluated for 1 life, not for a whole episode of 5 lives. Rewards in evaluation are also truncated. Cuz this is what environment the agent is learning in and in this way mean rewards per life can be compared with initial state value\n",
    "\n",
    "**The goal is to get 15 points in the real env**. So 3 or better 4 points in the preprocessed one will probably be enough. You can interrupt learning then."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Final scoring is done on a whole episode with all 5 lives."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "outputs": [],
   "source": [
    "env = make_env()\n",
    "\n",
    "state = env.reset()\n",
    "\n",
    "for i in range(10000):\n",
    "    qvalues = target_network.get_qvalues([state])\n",
    "    action = qvalues.argmax(axis=-1)[0]\n",
    "    state, reward, done, info = env.step(action)\n",
    "    if done:\n",
    "        state = env.reset()\n",
    "    env.render()\n",
    "env.close()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(clip_rewards=False, seed=9),\n",
    "    agent, n_games=30, greedy=False, t_max=10 * 1000\n",
    ") * n_lives\n",
    "print('final score:', final_score)\n",
    "assert final_score >= 15, 'not as cool as DQN can'\n",
    "print('Cool!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to interpret plots:\n",
    "\n",
    "This aint no supervised learning so don't expect anything to improve monotonously. \n",
    "* **TD loss** is the MSE between agent's current Q-values and target Q-values. It may slowly increase or decrease, it's ok. The \"not ok\" behavior includes going NaN or stayng at exactly zero before agent has perfect performance.\n",
    "* **grad norm** just shows the intensivity of training. Not ok is growing to values of about 100 (or maybe even 50) though it depends on network architecture.\n",
    "* **mean reward** is the expected sum of r(s,a) agent gets over the full game session. It will oscillate, but on average it should get higher over time (after a few thousand iterations...). \n",
    " * In basic q-learning implementation it takes about 40k steps to \"warm up\" agent before it starts to get better.\n",
    "* **Initial state V** is the expected discounted reward for episode in the oppinion of the agent. It should behave more smoothly than **mean reward**. It should get higher over time but sometimes can experience drawdowns because of the agaent's overestimates.\n",
    "* **buffer size** - this one is simple. It should go up and cap at max size.\n",
    "* **epsilon** - agent's willingness to explore. If you see that agent's already at 0.01 epsilon before it's average reward is above 0 - it means you need to increase epsilon. Set it back to some 0.2 - 0.5 and decrease the pace at which it goes down.\n",
    "* Smoothing of plots is done with a gaussian kernel\n",
    "\n",
    "At first your agent will lose quickly. Then it will learn to suck less and at least hit the ball a few times before it loses. Finally it will learn to actually score points.\n",
    "\n",
    "**Training will take time.** A lot of it actually. Probably you will not see any improvment during first **150k** time steps (note that by default in this notebook agent is evaluated every 5000 time steps).\n",
    "\n",
    "But hey, long training time isn't _that_ bad:\n",
    "![img](https://github.com/yandexdataschool/Practical_RL/raw/master/yet_another_week/_resource/training.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## About hyperparameters:\n",
    "\n",
    "The task has something in common with supervised learning: loss is optimized through the buffer (instead of Train dataset). But the distribution of states and actions in the buffer **is not stationary** and depends on the policy that generated it. It can even happen that the mean TD error across the buffer is very low but the performance is extremely poor (imagine the agent collecting data to the buffer always manages to avoid the ball).\n",
    "\n",
    "* Total timesteps and training time: It seems to be so huge, but actually it is normal for RL.\n",
    "\n",
    "* $\\epsilon$ decay shedule was taken from the original paper and is like traditional for epsilon-greedy policies. At the beginning of the training the agent's greedy policy is poor so many random actions should be taken.\n",
    "\n",
    "* Optimizer: In the original paper RMSProp was used (they did not have Adam in 2013) and it can work not worse than Adam. For us Adam was default and it worked.\n",
    "\n",
    "* lr: $10^{-3}$ would probably be too huge\n",
    "\n",
    "* batch size: This one can be very important: if it is too small the agent can fail to learn. Huge batch takes more time to process. If batch of size 8 can not be processed on the hardware you use take 2 (or even 4) batches of size 4, divide the loss on them by 2 (or 4) and make optimization step after both backward() calls in torch.\n",
    "\n",
    "* target network update frequency: has something in common with learning rate. Too frequent updates can lead to divergence. Too rare can lead to slow leraning. For millions of total timesteps thousands of inner steps seem ok. One iteration of target network updating is an iteration of the (this time approximate) $\\gamma$-compression that stands behind Q-learning. The more inner steps it makes the more accurate is the compression.\n",
    "* max_grad_norm - just huge enough. In torch clip_grad_norm also evaluates the norm before clipping and it can be convenient for logging."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's have a closer look at this.\n",
    "\n",
    "If average episode score is below 200 using all 5 lives, then probably DQN has not converged fully. But anyway let's make a more complete record of an episode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval_env = make_env(clip_rewards=False)\n",
    "record = utils.play_and_log_episode(eval_env, agent)\n",
    "print('total reward for life:', np.sum(record['rewards']))\n",
    "for key in record:\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(5, 5))\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "\n",
    "ax.scatter(record['v_mc'], record['v_agent'])\n",
    "ax.plot(sorted(record['v_mc']), sorted(record['v_mc']),\n",
    "       'black', linestyle='--', label='x=y')\n",
    "\n",
    "ax.grid()\n",
    "ax.legend()\n",
    "ax.set_title('State Value Estimates')\n",
    "ax.set_xlabel('Monte-Carlo')\n",
    "ax.set_ylabel('Agent')\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}