DRL_19_REINFORCE_Algorithm-OLD.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "DRL_19_REINFORCE_Algorithm.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "40Yb47zJQglm",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "DEEP REINFORCEMENT LEARNING EXPLAINED - 19\n",
        "# **Policy-Gradient Methods**\n",
        "### REINFORCE Algorithm (basic)\n",
        "---\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q40Fa7qM4_lE",
        "colab_type": "text"
      },
      "source": [
        "Import necessary packages"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FA1Y5VCv20XZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import gym\n",
        "import numpy as np\n",
        "from collections import deque\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import torch\n",
        "torch.manual_seed(0) # set random seed\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "from torch.distributions import Categorical\n",
        "\n"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4m0Vm4Yp91ZI",
        "colab_type": "text"
      },
      "source": [
        "Tunning the image rendering in colab\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kgpHXywd5SyZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "096214d1-f51b-4787-8ddf-afaa85882e1f"
      },
      "source": [
        "# Taken from \n",
        "# https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7\n",
        "\n",
        "!apt-get install -y xvfb x11-utils\n",
        "\n",
        "!pip install pyvirtualdisplay==0.2.* \\\n",
        "             PyOpenGL==3.1.* \\\n",
        "             PyOpenGL-accelerate==3.1.*\n",
        "\n",
        "!pip install gym[box2d]==0.17.*\n",
        "\n",
        "# Taken from https://github.com/actions/virtual-environments/issues/214\n",
        "!sudo apt-get update\n",
        "!sudo apt-get install xvfb --fix-missing\n",
        "\n",
        "import pyvirtualdisplay\n",
        "\n",
        "_display = pyvirtualdisplay.Display(visible=False, size=(1400, 900))\n",
        "_ = _display.start()\n",
        "\n",
        "!echo $DISPLAY # sanity checking should now be set to some value\n",
        "\n",
        "from IPython import display"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "xvfb is already the newest version (2:1.19.6-1ubuntu4.5).\n",
            "The following package was automatically installed and is no longer required:\n",
            "  libnvidia-common-440\n",
            "Use 'apt autoremove' to remove it.\n",
            "Suggested packages:\n",
            "  mesa-utils\n",
            "The following NEW packages will be installed:\n",
            "  libxxf86dga1 x11-utils\n",
            "0 upgraded, 2 newly installed, 0 to remove and 71 not upgraded.\n",
            "Need to get 209 kB of archives.\n",
            "After this operation, 711 kB of additional disk space will be used.\n",
            "Get:1 http://archive.ubuntu.com/ubuntu bionic/main amd64 libxxf86dga1 amd64 2:1.1.4-1 [13.7 kB]\n",
            "Get:2 http://archive.ubuntu.com/ubuntu bionic/main amd64 x11-utils amd64 7.7+3build1 [196 kB]\n",
            "Fetched 209 kB in 0s (2,587 kB/s)\n",
            "Selecting previously unselected package libxxf86dga1:amd64.\n",
            "(Reading database ... 144586 files and directories currently installed.)\n",
            "Preparing to unpack .../libxxf86dga1_2%3a1.1.4-1_amd64.deb ...\n",
            "Unpacking libxxf86dga1:amd64 (2:1.1.4-1) ...\n",
            "Selecting previously unselected package x11-utils.\n",
            "Preparing to unpack .../x11-utils_7.7+3build1_amd64.deb ...\n",
            "Unpacking x11-utils (7.7+3build1) ...\n",
            "Setting up libxxf86dga1:amd64 (2:1.1.4-1) ...\n",
            "Setting up x11-utils (7.7+3build1) ...\n",
            "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n",
            "Processing triggers for libc-bin (2.27-3ubuntu1) ...\n",
            "/sbin/ldconfig.real: /usr/local/lib/python3.6/dist-packages/ideep4py/lib/libmkldnn.so.0 is not a symbolic link\n",
            "\n",
            "Requirement already satisfied: pyvirtualdisplay==0.2.* in /usr/local/lib/python3.6/dist-packages (0.2.5)\n",
            "Requirement already satisfied: PyOpenGL==3.1.* in /usr/local/lib/python3.6/dist-packages (3.1.5)\n",
            "Requirement already satisfied: PyOpenGL-accelerate==3.1.* in /usr/local/lib/python3.6/dist-packages (3.1.5)\n",
            "Requirement already satisfied: EasyProcess in /usr/local/lib/python3.6/dist-packages (from pyvirtualdisplay==0.2.*) (0.3)\n",
            "Requirement already satisfied: gym[box2d]==0.17.* in /usr/local/lib/python3.6/dist-packages (0.17.2)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.6/dist-packages (from gym[box2d]==0.17.*) (1.4.1)\n",
            "Requirement already satisfied: numpy>=1.10.4 in /usr/local/lib/python3.6/dist-packages (from gym[box2d]==0.17.*) (1.18.5)\n",
            "Requirement already satisfied: pyglet<=1.5.0,>=1.4.0 in /usr/local/lib/python3.6/dist-packages (from gym[box2d]==0.17.*) (1.5.0)\n",
            "Requirement already satisfied: cloudpickle<1.4.0,>=1.2.0 in /usr/local/lib/python3.6/dist-packages (from gym[box2d]==0.17.*) (1.3.0)\n",
            "Requirement already satisfied: box2d-py~=2.3.5; extra == \"box2d\" in /usr/local/lib/python3.6/dist-packages (from gym[box2d]==0.17.*) (2.3.8)\n",
            "Requirement already satisfied: future in /usr/local/lib/python3.6/dist-packages (from pyglet<=1.5.0,>=1.4.0->gym[box2d]==0.17.*) (0.16.0)\n",
            "Hit:1 http://archive.ubuntu.com/ubuntu bionic InRelease\n",
            "Hit:2 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic InRelease\n",
            "Hit:3 http://archive.ubuntu.com/ubuntu bionic-updates InRelease\n",
            "Hit:4 http://security.ubuntu.com/ubuntu bionic-security InRelease\n",
            "Hit:5 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran35/ InRelease\n",
            "Hit:6 http://archive.ubuntu.com/ubuntu bionic-backports InRelease\n",
            "Hit:7 http://ppa.launchpad.net/marutter/c2d4u3.5/ubuntu bionic InRelease\n",
            "Ign:8 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  InRelease\n",
            "Ign:9 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  InRelease\n",
            "Hit:10 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Release\n",
            "Hit:11 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  Release\n",
            "Reading package lists... Done\n",
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "xvfb is already the newest version (2:1.19.6-1ubuntu4.5).\n",
            "The following package was automatically installed and is no longer required:\n",
            "  libnvidia-common-440\n",
            "Use 'sudo apt autoremove' to remove it.\n",
            "0 upgraded, 0 newly installed, 0 to remove and 71 not upgraded.\n",
            ":1005\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JKCArPYvBkYi",
        "colab_type": "text"
      },
      "source": [
        "OpenAI Gym's Cartpole Environment"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_3_4zOdQBl2g",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 65
        },
        "outputId": "827783b6-fa79-4597-ba25-4e7205134680"
      },
      "source": [
        "env = gym.make('CartPole-v0')\n",
        "print('observation space:', env.observation_space)\n",
        "print('action space:', env.action_space)\n",
        "print('threshold: ', env.spec.reward_threshold)\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "observation space: Box(4,)\n",
            "action space: Discrete(2)\n",
            "threshold:  195.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NJC916BU-9L6",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "Define  policy π (and initialize with random weights θ)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gRVXyg9A1zQh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "class Policy(nn.Module):\n",
        "    def __init__(self, s_size=4, h_size=16, a_size=2):\n",
        "        super(Policy, self).__init__()\n",
        "        self.fc1 = nn.Linear(s_size, h_size)\n",
        "        self.fc2 = nn.Linear(h_size, a_size)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = self.fc2(x)\n",
        "        return F.softmax(x, dim=1)\n",
        "    \n",
        "    def act(self, state):\n",
        "        state = torch.from_numpy(state).float().unsqueeze(0).to(device)\n",
        "        probs = self.forward(state).cpu()\n",
        "        m = Categorical(probs)\n",
        "        action = m.sample()\n",
        "        return action.item(), m.log_prob(action)\n"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e8R55NgQL4EC",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "\n",
        "Train the Agent with REINFORCE"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k0C85qx0L1VV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 82
        },
        "outputId": "d71ebd8d-c102-47d2-ef3f-3d5840d91119"
      },
      "source": [
        "policy = Policy().to(device)\n",
        "optimizer = optim.Adam(policy.parameters(), lr=1e-2)\n",
        "\n",
        "def reinforce(n_episodes=10000, max_t=1000, gamma=1.0):\n",
        "    scores_deque = deque(maxlen=100)\n",
        "    scores = []\n",
        "    for i_episode in range(1, n_episodes+1):\n",
        "        saved_log_probs = []\n",
        "        rewards = []\n",
        "        state = env.reset()\n",
        "        for t in range(max_t):\n",
        "            action, log_prob = policy.act(state)\n",
        "            saved_log_probs.append(log_prob)\n",
        "            state, reward, done, _ = env.step(action)\n",
        "            rewards.append(reward)\n",
        "            if done:\n",
        "                break \n",
        "        scores_deque.append(sum(rewards))\n",
        "        scores.append(sum(rewards))\n",
        "        \n",
        "        discounts = [gamma**i for i in range(len(rewards)+1)]\n",
        "        R = sum([a*b for a,b in zip(discounts, rewards)])\n",
        "        \n",
        "        policy_loss = []\n",
        "        for log_prob in saved_log_probs:\n",
        "            policy_loss.append(-log_prob * R)\n",
        "        policy_loss = torch.cat(policy_loss).sum()\n",
        "        \n",
        "        optimizer.zero_grad()\n",
        "        policy_loss.backward()\n",
        "        optimizer.step()\n",
        "        \n",
        "        if i_episode % 100 == 0:\n",
        "            print('Episode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_deque)))\n",
        "        if np.mean(scores_deque)>=195.0:\n",
        "            print('Environment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode-100, np.mean(scores_deque)))\n",
        "            break\n",
        "        \n",
        "    return scores\n",
        "\n",
        "print(policy)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Policy(\n",
            "  (fc1): Linear(in_features=4, out_features=16, bias=True)\n",
            "  (fc2): Linear(in_features=16, out_features=2, bias=True)\n",
            ")\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XX6voeeDL1k8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 181
        },
        "outputId": "fa480d1a-df37-4e5f-f39c-7aab45b9e8fb"
      },
      "source": [
        "    scores = reinforce()"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Episode 100\tAverage Score: 31.65\n",
            "Episode 200\tAverage Score: 72.02\n",
            "Episode 300\tAverage Score: 24.59\n",
            "Episode 400\tAverage Score: 38.92\n",
            "Episode 500\tAverage Score: 153.28\n",
            "Episode 600\tAverage Score: 160.69\n",
            "Episode 700\tAverage Score: 73.46\n",
            "Episode 800\tAverage Score: 153.40\n",
            "Episode 900\tAverage Score: 134.30\n",
            "Environment solved in 892 episodes!\tAverage Score: 196.54\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YxYkuflPMMmm",
        "colab_type": "text"
      },
      "source": [
        "Plot the Scores"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-5ldq30sMKVO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 277
        },
        "outputId": "40e67cf2-081c-4caf-8329-55b85be4d252"
      },
      "source": [
        "fig = plt.figure()\n",
        "plt.plot(np.arange(1, len(scores)+1), scores)\n",
        "plt.ylabel('Score')\n",
        "plt.xlabel('Episode #')\n",
        "plt.show()"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9R3_QsYSBzYn",
        "colab_type": "text"
      },
      "source": [
        "Render Cartpole Environment before train"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OhhqfVxD28VZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def watch_agent():\n",
        "  env = gym.make('CartPole-v0')\n",
        "  state = env.reset()\n",
        "  rewards = []\n",
        "  img = plt.imshow(env.render(mode='rgb_array'))\n",
        "  for t in range(2000):\n",
        "    action, _ = policy.act(state)\n",
        "    img.set_data(env.render(mode='rgb_array')) \n",
        "    plt.axis('off')\n",
        "    display.display(plt.gcf())\n",
        "    display.clear_output(wait=True)\n",
        "    state, reward, done, _ = env.step(action)\n",
        "    rewards.append(reward)\n",
        "    if done:\n",
        "        print(\"Reward:\", sum([r for r in rewards]))\n",
        "        break \n",
        "  env.close()"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TT-xoG5VA9rZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 263
        },
        "outputId": "bd6a8047-e7ce-403d-8b91-25b404b80cf3"
      },
      "source": [
        "watch_agent()"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Reward: 200.0\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}