Double_and_Duelling_may_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Double and Duelling may 1.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "APPENDIX 2: ADVANCED DQN: DOUBLE AND Deuling\n"
      ],
      "metadata": {
        "id": "x8WhzEvfrFiB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Base code implimentation from https://github.com/Curt-Park/rainbow-is-all-you-need with adaptations from https://github.com/philtabor/Youtube-Code-Repository/tree/master/ReinforcementLearning/DeepQLearning, and https://www.youtube.com/watch?v=WHRQUZrxxGw&t=4786s"
      ],
      "metadata": {
        "id": "ab8D8t6mrGYL"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yBDKxUWTdyqF"
      },
      "outputs": [],
      "source": [
        "#importing the libraries\n",
        "from torch.cuda import random\n",
        "!pip install Box2D\n",
        "import os\n",
        "from typing import Dict, List, Tuple\n",
        "import math\n",
        "\n",
        "import gym\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torch import randint\n",
        "import torch.optim as optim\n",
        "from IPython.display import clear_output\n",
        "from torch.nn.utils import clip_grad_norm_\n",
        "\n",
        "!pip install box2d-py\n",
        "!pip install gym[all]\n",
        "!pip install gym[Box_2D]\n",
        "!pip install git+https://github.com/ngc92/space-wrappers.git\n",
        "!pip install \"ray[rllib]\"==1.6\n",
        "\n",
        "import gym\n",
        "import space_wrappers\n",
        "\n",
        "\n",
        "from torch import randint\n",
        "import random\n",
        "from random import sample, random\n",
        "\n",
        "from collections import deque,namedtuple\n",
        "from typing import Any\n",
        "from random import sample, random\n",
        "\n",
        "from dataclasses import dataclass\n",
        "from ray import tune\n",
        "import numpy as np\n",
        "import ray.rllib.agents.dqn as dqn"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Create the replay buffer\n",
        "class ReplayBuffer:\n",
        "\n",
        "    def __init__(self, obs_dim, size, batch_size = 32):\n",
        "        self.observations = np.zeros([size, obs_dim], dtype=np.float32)\n",
        "        self.next_observations = np.zeros([size, obs_dim], dtype=np.float32)\n",
        "        self.actions_buffer = np.zeros([size], dtype=np.float32)\n",
        "        self.rewards_buffer = np.zeros([size], dtype=np.float32)\n",
        "        self.done_buffer = np.zeros(size, dtype=np.float32)\n",
        "        self.max_size, self.batch_size = size, batch_size\n",
        "        self.ptr, self.size, = 0, 0\n",
        "\n",
        "    def store(self,observation,action, reward, next_observation, done):\n",
        "        self.observations[self.ptr] = observation\n",
        "        self.next_observations[self.ptr] = next_observation\n",
        "        self.actions_buffer[self.ptr] = action\n",
        "        self.rewards_buffer[self.ptr] = reward\n",
        "        self.done_buffer[self.ptr] = done\n",
        "        self.ptr = (self.ptr + 1) % self.max_size\n",
        "        self.size = min(self.size + 1, self.max_size)\n",
        "\n",
        "    def sample_batch(self):\n",
        "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
        "        return dict(observations=self.observations[idxs],\n",
        "                    next_observations=self.next_observations[idxs],\n",
        "                    action=self.actions_buffer[idxs],\n",
        "                    reward=self.rewards_buffer[idxs],\n",
        "                    done=self.done_buffer[idxs])\n",
        "\n",
        "    def __len__(self) -> int:\n",
        "        return self.size\n",
        "\n",
        "\n",
        "#Create Network\n",
        "\n",
        "class Network(nn.Module):\n",
        "    def __init__(self, states_in, actions_out):\n",
        "        super(Network, self).__init__()\n",
        "\n",
        "        self.layers = nn.Sequential(\n",
        "            nn.Linear(states_in, 128), \n",
        "            nn.ReLU(),\n",
        "            nn.Linear(128, 128), \n",
        "            nn.ReLU(), \n",
        "            nn.Linear(128, actions_out)\n",
        "        )\n",
        "\n",
        "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
        "        return self.layers(x)\n",
        "\n",
        "#Double - DQN Agent\n",
        "\n",
        "class Double_DQNAgent:\n",
        "\n",
        "    def __init__(self, env ,memory_size, batch_size, target_update, epsilon_decay, max_epsilon = 1.0, min_epsilon= 0.1, gamma = 0.99,):\n",
        "\n",
        "        observations_dim = env.observation_space.shape[0]\n",
        "        action_dim = env.action_space.n\n",
        "        \n",
        "        self.env = env\n",
        "        self.memory = ReplayBuffer(observations_dim, memory_size, batch_size)\n",
        "        self.batch_size = batch_size\n",
        "        self.epsilon = max_epsilon\n",
        "        self.epsilon_decay = epsilon_decay\n",
        "        self.max_epsilon = max_epsilon\n",
        "        self.min_epsilon = min_epsilon\n",
        "        self.target_update = target_update\n",
        "        self.gamma = gamma\n",
        "        \n",
        "        # device: cpu / gpu\n",
        "        self.device = torch.device(\n",
        "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "        )\n",
        "        print(self.device)\n",
        "\n",
        "        # networks: dqn, dqn_target\n",
        "        self.dqn = Network(observations_dim, action_dim).to(self.device)\n",
        "        self.dqn_target = Network(observations_dim, action_dim).to(self.device)\n",
        "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
        "        self.dqn_target.eval()\n",
        "        \n",
        "        # optimizer\n",
        "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
        "\n",
        "        #store tranisitions in memory\n",
        "        self.transition = list()\n",
        "        \n",
        "        # mode: train / test\n",
        "        self.is_test = False\n",
        "\n",
        "    def select_action(self, state):\n",
        "        #epsilon greedy policy\n",
        "        if self.epsilon > np.random.random():\n",
        "            selected_action = self.env.action_space.sample()\n",
        "        else:\n",
        "            selected_action = self.dqn(\n",
        "                torch.FloatTensor(state).to(self.device)\n",
        "            ).argmax()\n",
        "            selected_action = selected_action.detach().cpu().numpy()\n",
        "        \n",
        "        if not self.is_test:\n",
        "            self.transition = [state, selected_action]\n",
        "        \n",
        "        return selected_action\n",
        "\n",
        "    def step(self, action):\n",
        "        #action -> next_state, reward, done\n",
        "        next_state, reward, done, _ = self.env.step(action)\n",
        "\n",
        "        if not self.is_test:\n",
        "            self.transition += [reward, next_state, done]\n",
        "            self.memory.store(*self.transition)\n",
        "    \n",
        "        return next_state, reward, done\n",
        "\n",
        "    def update_model(self):\n",
        "        #update model\n",
        "        samples = self.memory.sample_batch()\n",
        "\n",
        "        loss = self._compute_dqn_loss(samples)\n",
        "\n",
        "        self.optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        #trick gradient clipping:\n",
        "        clip_grad_norm_(self.dqn.parameters(), 10.0)\n",
        "        self.optimizer.step()\n",
        "\n",
        "        return loss.item()\n",
        "        \n",
        "    def train(self, num_frames, plotting_interval = 100):\n",
        "        #train agent\n",
        "        self.is_test = False\n",
        "        \n",
        "        state = self.env.reset()\n",
        "        update_cnt = 0\n",
        "        epsilons = []\n",
        "        losses = []\n",
        "        scores = []\n",
        "        score = 0\n",
        "\n",
        "        for frame_idx in range(1, num_frames + 1):\n",
        "            action = self.select_action(state)\n",
        "            next_state, reward, done = self.step(action)\n",
        "\n",
        "            state = next_state\n",
        "            score += reward\n",
        "\n",
        "            #end episode\n",
        "            if done:\n",
        "                state = self.env.reset()\n",
        "                scores.append(score)\n",
        "                score = 0\n",
        "\n",
        "            #buffer if filled for training\n",
        "            if len(self.memory) >= self.batch_size:\n",
        "                loss = self.update_model()\n",
        "                losses.append(loss)\n",
        "                update_cnt += 1\n",
        "                \n",
        "                # epsilon decay\n",
        "                self.epsilon = max(\n",
        "                    self.min_epsilon, self.epsilon - (\n",
        "                        self.max_epsilon - self.min_epsilon\n",
        "                    ) * self.epsilon_decay\n",
        "                )\n",
        "                epsilons.append(self.epsilon)\n",
        "                \n",
        "                # update target network\n",
        "                if update_cnt % self.target_update == 0:\n",
        "                    self._target_hard_update()\n",
        "\n",
        "            # plotting\n",
        "            if frame_idx % plotting_interval == 0:\n",
        "                self._plot(frame_idx, scores, losses, epsilons)\n",
        "                \n",
        "        self.env.close()\n",
        "                \n",
        "    def test(self, video_folder):\n",
        "        \"\"\"Test the agent.\"\"\"\n",
        "        self.is_test = True\n",
        "        \n",
        "        # for recording a video\n",
        "        naive_env = self.env\n",
        "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
        "        \n",
        "        state = self.env.reset()\n",
        "        done = False\n",
        "        score = 0\n",
        "        \n",
        "        while not done:\n",
        "            action = self.select_action(state)\n",
        "            next_state, reward, done = self.step(action)\n",
        "\n",
        "            state = next_state\n",
        "            score += reward\n",
        "        \n",
        "        print(\"score: \", score)\n",
        "        self.env.close()\n",
        "        \n",
        "        # reset\n",
        "        self.env = naive_env\n",
        "\n",
        "    def _compute_dqn_loss(self, samples):\n",
        "        device = self.device \n",
        "        state = torch.FloatTensor(samples[\"observations\"]).to(device)\n",
        "        next_state = torch.FloatTensor(samples[\"next_observations\"]).to(device)\n",
        "        action = torch.LongTensor(samples[\"action\"].reshape(-1, 1)).to(device)\n",
        "        reward = torch.FloatTensor(samples[\"reward\"].reshape(-1, 1)).to(device)\n",
        "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
        "        \n",
        "        #current Q network decides which one is the best next action a’ among all the available next actions, \n",
        "        #and then the target neural network evaluates this action to know its Q-value.\n",
        "        curr_q_value = self.dqn(state).gather(1, action)\n",
        "        #Double DQN\n",
        "        next_q_value = self.dqn_target(next_state).gather(  # Double DQN\n",
        "            1, self.dqn(next_state).argmax(dim=1, keepdim=True)\n",
        "        ).detach()\n",
        "        mask = 1 - done\n",
        "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
        "\n",
        "        # calculate the dqn loss\n",
        "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
        "\n",
        "        return loss\n",
        "    \n",
        "    def _target_hard_update(self):\n",
        "        #Update target network\n",
        "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
        "                \n",
        "    def _plot(self, frame_idx, scores, losses, epsilons,):\n",
        "        #plot train\n",
        "        clear_output(True)\n",
        "        plt.figure(figsize=(20, 5))\n",
        "        plt.subplot(131)\n",
        "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
        "        plt.plot(scores)\n",
        "        plt.subplot(132)\n",
        "        plt.title('loss')\n",
        "        plt.plot(losses)\n",
        "        plt.subplot(133)\n",
        "        plt.title('epsilons')\n",
        "        plt.plot(epsilons)\n",
        "        plt.show()\n",
        "\n"
      ],
      "metadata": {
        "id": "IbN4Xer8fS5V"
      },
      "execution_count": 46,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# parameters\n",
        "env = gym.make('LunarLander-v2')\n",
        "num_frames = 30_000\n",
        "memory_size = 1000\n",
        "batch_size = 32\n",
        "target_update = 200\n",
        "epsilon_decay = 1 / 2000\n",
        "\n",
        "# train\n",
        "agent_double = Double_DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iEbxCNBFferc",
        "outputId": "0a9f8c38-87cf-4e2d-93ce-7d312e8dbaa3"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cpu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "agent_double.train(num_frames)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 336
        },
        "id": "eR5_EtM7fjKC",
        "outputId": "e948eac5-e897-4168-c2ce-8e93d6a67f21"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1440x360 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Dueling DQN: The steps are similar than above except we have a different Neurel network and compute loss function."
      ],
      "metadata": {
        "id": "y0ryMYWxm_IB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Network(nn.Module):\n",
        "    def __init__(self, states_in, actions_out):\n",
        "        \"\"\"Initialization.\"\"\"\n",
        "        super(Network, self).__init__()\n",
        "\n",
        "        # set common feature layer\n",
        "        self.feature_layer = nn.Sequential(\n",
        "            nn.Linear(states_in, 128), \n",
        "            nn.ReLU(),\n",
        "        )\n",
        "        \n",
        "        ##advantage function for each action a =  (A(s, a))\n",
        "        self.advantage_layer = nn.Sequential(\n",
        "            nn.Linear(128, 128),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(128, actions_out),\n",
        "        )\n",
        "\n",
        "        #state value function for state s =  (V(s))\n",
        "        self.value_layer = nn.Sequential(\n",
        "            nn.Linear(128, 128),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(128, 1),\n",
        "        )\n",
        "\n",
        "    def forward(self, x) -> torch.Tensor:\n",
        "        feature = self.feature_layer(x)\n",
        "        \n",
        "        value = self.value_layer(feature)\n",
        "        advantage = self.advantage_layer(feature)\n",
        "\n",
        "        # infinitely many solutions so trick to make problem identifiable\n",
        "        # we take mean\n",
        "        q = value + advantage - advantage.mean(dim=-1, keepdim=True)\n",
        "        \n",
        "        return q\n",
        "\n",
        "#Double - DQN Agent\n",
        "\n",
        "class Duelling_DQNAgent:\n",
        "\n",
        "    def __init__(self, env ,memory_size, batch_size, target_update, epsilon_decay, max_epsilon = 1.0, min_epsilon= 0.1, gamma = 0.99,):\n",
        "\n",
        "        observations_dim = env.observation_space.shape[0]\n",
        "        action_dim = env.action_space.n\n",
        "        \n",
        "        self.env = env\n",
        "        self.memory = ReplayBuffer(observations_dim, memory_size, batch_size)\n",
        "        self.batch_size = batch_size\n",
        "        self.epsilon = max_epsilon\n",
        "        self.epsilon_decay = epsilon_decay\n",
        "        self.max_epsilon = max_epsilon\n",
        "        self.min_epsilon = min_epsilon\n",
        "        self.target_update = target_update\n",
        "        self.gamma = gamma\n",
        "        \n",
        "        # device: cpu / gpu\n",
        "        self.device = torch.device(\n",
        "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "        )\n",
        "        print(self.device)\n",
        "\n",
        "        # networks: dqn, dqn_target\n",
        "        self.dqn = Network(observations_dim, action_dim).to(self.device)\n",
        "        self.dqn_target = Network(observations_dim, action_dim).to(self.device)\n",
        "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
        "        self.dqn_target.eval()\n",
        "        \n",
        "        # optimizer\n",
        "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
        "\n",
        "        #store tranisitions in memory\n",
        "        self.transition = list()\n",
        "        \n",
        "        # mode: train / test\n",
        "        self.is_test = False\n",
        "\n",
        "    def select_action(self, state):\n",
        "        #epsilon greedy policy\n",
        "        if self.epsilon > np.random.random():\n",
        "            selected_action = self.env.action_space.sample()\n",
        "        else:\n",
        "            selected_action = self.dqn(\n",
        "                torch.FloatTensor(state).to(self.device)\n",
        "            ).argmax()\n",
        "            selected_action = selected_action.detach().cpu().numpy()\n",
        "        \n",
        "        if not self.is_test:\n",
        "            self.transition = [state, selected_action]\n",
        "        \n",
        "        return selected_action\n",
        "\n",
        "    def step(self, action):\n",
        "        #action -> next_state, reward, done\n",
        "        next_state, reward, done, _ = self.env.step(action)\n",
        "\n",
        "        if not self.is_test:\n",
        "            self.transition += [reward, next_state, done]\n",
        "            self.memory.store(*self.transition)\n",
        "    \n",
        "        return next_state, reward, done\n",
        "\n",
        "    def update_model(self):\n",
        "        #update model\n",
        "        samples = self.memory.sample_batch()\n",
        "\n",
        "        loss = self._compute_dqn_loss(samples)\n",
        "\n",
        "        self.optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        #trick gradient clipping:\n",
        "        clip_grad_norm_(self.dqn.parameters(), 10.0)\n",
        "        self.optimizer.step()\n",
        "\n",
        "        return loss.item()\n",
        "        \n",
        "    def train(self, num_frames, plotting_interval = 100):\n",
        "        #train agent\n",
        "        self.is_test = False\n",
        "        \n",
        "        state = self.env.reset()\n",
        "        update_cnt = 0\n",
        "        epsilons = []\n",
        "        losses = []\n",
        "        scores = []\n",
        "        score = 0\n",
        "\n",
        "        for frame_idx in range(1, num_frames + 1):\n",
        "            action = self.select_action(state)\n",
        "            next_state, reward, done = self.step(action)\n",
        "\n",
        "            state = next_state\n",
        "            score += reward\n",
        "\n",
        "            #end episode\n",
        "            if done:\n",
        "                state = self.env.reset()\n",
        "                scores.append(score)\n",
        "                score = 0\n",
        "\n",
        "            #buffer if filled for training\n",
        "            if len(self.memory) >= self.batch_size:\n",
        "                loss = self.update_model()\n",
        "                losses.append(loss)\n",
        "                update_cnt += 1\n",
        "                \n",
        "                # epsilon decay\n",
        "                self.epsilon = max(\n",
        "                    self.min_epsilon, self.epsilon - (\n",
        "                        self.max_epsilon - self.min_epsilon\n",
        "                    ) * self.epsilon_decay\n",
        "                )\n",
        "                epsilons.append(self.epsilon)\n",
        "                \n",
        "                # update target network\n",
        "                if update_cnt % self.target_update == 0:\n",
        "                    self._target_hard_update()\n",
        "\n",
        "            # plotting\n",
        "            if frame_idx % plotting_interval == 0:\n",
        "                self._plot(frame_idx, scores, losses, epsilons)\n",
        "                \n",
        "        self.env.close()\n",
        "                \n",
        "    def test(self, video_folder):\n",
        "        \"\"\"Test the agent.\"\"\"\n",
        "        self.is_test = True\n",
        "        \n",
        "        # for recording a video\n",
        "        naive_env = self.env\n",
        "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
        "        \n",
        "        state = self.env.reset()\n",
        "        done = False\n",
        "        score = 0\n",
        "        \n",
        "        while not done:\n",
        "            action = self.select_action(state)\n",
        "            next_state, reward, done = self.step(action)\n",
        "\n",
        "            state = next_state\n",
        "            score += reward\n",
        "        \n",
        "        print(\"score: \", score)\n",
        "        self.env.close()\n",
        "        \n",
        "        # reset\n",
        "        self.env = naive_env\n",
        "\n",
        "    #Duelling\n",
        "    def _compute_dqn_loss(self, samples):\n",
        "        device = self.device  # for shortening the following lines\n",
        "        state = torch.FloatTensor(samples[\"observations\"]).to(device)\n",
        "        next_state = torch.FloatTensor(samples[\"next_observations\"]).to(device)\n",
        "        action = torch.LongTensor(samples[\"action\"].reshape(-1, 1)).to(device)\n",
        "        reward = torch.FloatTensor(samples[\"reward\"].reshape(-1, 1)).to(device)\n",
        "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
        "\n",
        "\n",
        "        curr_q_value = self.dqn(state).gather(1, action)\n",
        "        #duelling\n",
        "        next_q_value = self.dqn_target(next_state).max( \n",
        "            dim=1, keepdim=True\n",
        "        )[0].detach()\n",
        "        mask = 1 - done\n",
        "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
        "\n",
        "        # calculate dqn loss\n",
        "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
        "\n",
        "        return loss\n",
        "    \n",
        "    def _target_hard_update(self):\n",
        "        #Update target network\n",
        "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
        "                \n",
        "    def _plot(self, frame_idx, scores, losses, epsilons,):\n",
        "        #plot train\n",
        "        clear_output(True)\n",
        "        plt.figure(figsize=(20, 5))\n",
        "        plt.subplot(131)\n",
        "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
        "        plt.plot(scores)\n",
        "        plt.subplot(132)\n",
        "        plt.title('loss')\n",
        "        plt.plot(losses)\n",
        "        plt.subplot(133)\n",
        "        plt.title('epsilons')\n",
        "        plt.plot(epsilons)\n",
        "        plt.show()"
      ],
      "metadata": {
        "id": "bFfQjlxRl-cZ"
      },
      "execution_count": 49,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "env = gym.make('LunarLander-v2')\n",
        "num_frames = 30_000\n",
        "memory_size = 1000\n",
        "batch_size = 32\n",
        "target_update = 200\n",
        "epsilon_decay = 1 / 2000\n",
        "\n",
        "# train\n",
        "agent_duelling = Duelling_DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yPsHwiFEot6d",
        "outputId": "f6859599-a09e-4151-8189-3533082e699b"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cpu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "agent_duelling.train(num_frames)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 336
        },
        "id": "tTgM5GAUovR_",
        "outputId": "2b82593d-2ebc-429c-deaf-bc67afacf347"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1440x360 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}