5a - Proximal Policy Optimization (PPO) [LunarLander].ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://medium.com/@jonathan_hui/rl-trust-region-policy-optimization-trpo-explained-a6ee04eeeee9\n",
    "https://stackoverflow.com/a/50663200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "import torch.distributions as distributions\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import gym"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_env = gym.make('LunarLander-v2')\n",
    "test_env = gym.make('LunarLander-v2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "SEED = 1234\n",
    "\n",
    "train_env.seed(SEED);\n",
    "test_env.seed(SEED+1);\n",
    "np.random.seed(SEED);\n",
    "torch.manual_seed(SEED);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLP(nn.Module):\n",
    "    def __init__(self, input_dim, hidden_dim, output_dim, dropout = 0.1):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.net = nn.Sequential(\n",
    "            nn.Linear(input_dim, hidden_dim),\n",
    "            nn.Dropout(dropout),\n",
    "            nn.PReLU(),\n",
    "            nn.Linear(hidden_dim, hidden_dim),\n",
    "            nn.Dropout(dropout),\n",
    "            nn.PReLU(),\n",
    "            nn.Linear(hidden_dim, output_dim)\n",
    "        )\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.net(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActorCritic(nn.Module):\n",
    "    def __init__(self, actor, critic):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.actor = actor\n",
    "        self.critic = critic\n",
    "        \n",
    "    def forward(self, state):\n",
    "        \n",
    "        action_pred = self.actor(state)\n",
    "        value_pred = self.critic(state)\n",
    "        \n",
    "        return action_pred, value_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "INPUT_DIM = train_env.observation_space.shape[0]\n",
    "HIDDEN_DIM = 128\n",
    "OUTPUT_DIM = train_env.action_space.n\n",
    "\n",
    "actor = MLP(INPUT_DIM, HIDDEN_DIM, OUTPUT_DIM)\n",
    "critic = MLP(INPUT_DIM, HIDDEN_DIM, 1)\n",
    "\n",
    "policy = ActorCritic(actor, critic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_weights(m):\n",
    "    if type(m) == nn.Linear:\n",
    "        torch.nn.init.xavier_normal_(m.weight)\n",
    "        m.bias.data.fill_(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ActorCritic(\n",
       "  (actor): MLP(\n",
       "    (net): Sequential(\n",
       "      (0): Linear(in_features=8, out_features=128, bias=True)\n",
       "      (1): Dropout(p=0.1, inplace=False)\n",
       "      (2): PReLU(num_parameters=1)\n",
       "      (3): Linear(in_features=128, out_features=128, bias=True)\n",
       "      (4): Dropout(p=0.1, inplace=False)\n",
       "      (5): PReLU(num_parameters=1)\n",
       "      (6): Linear(in_features=128, out_features=4, bias=True)\n",
       "    )\n",
       "  )\n",
       "  (critic): MLP(\n",
       "    (net): Sequential(\n",
       "      (0): Linear(in_features=8, out_features=128, bias=True)\n",
       "      (1): Dropout(p=0.1, inplace=False)\n",
       "      (2): PReLU(num_parameters=1)\n",
       "      (3): Linear(in_features=128, out_features=128, bias=True)\n",
       "      (4): Dropout(p=0.1, inplace=False)\n",
       "      (5): PReLU(num_parameters=1)\n",
       "      (6): Linear(in_features=128, out_features=1, bias=True)\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "policy.apply(init_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "LEARNING_RATE = 0.0005\n",
    "\n",
    "optimizer = optim.Adam(policy.parameters(), lr = LEARNING_RATE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(env, policy, optimizer, discount_factor, ppo_steps, ppo_clip):\n",
    "        \n",
    "    policy.train()\n",
    "        \n",
    "    states = []\n",
    "    actions = []\n",
    "    log_prob_actions = []\n",
    "    values = []\n",
    "    rewards = []\n",
    "    done = False\n",
    "    episode_reward = 0\n",
    "\n",
    "    state = env.reset()\n",
    "\n",
    "    while not done:\n",
    "\n",
    "        state = torch.FloatTensor(state).unsqueeze(0)\n",
    "\n",
    "        #append state here, not after we get the next state from env.step()\n",
    "        states.append(state)\n",
    "        \n",
    "        action_pred, value_pred = policy(state)\n",
    "                \n",
    "        action_prob = F.softmax(action_pred, dim = -1)\n",
    "                \n",
    "        dist = distributions.Categorical(action_prob)\n",
    "        \n",
    "        action = dist.sample()\n",
    "        \n",
    "        log_prob_action = dist.log_prob(action)\n",
    "        \n",
    "        state, reward, done, _ = env.step(action.item())\n",
    "\n",
    "        actions.append(action)\n",
    "        log_prob_actions.append(log_prob_action)\n",
    "        values.append(value_pred)\n",
    "        rewards.append(reward)\n",
    "        \n",
    "        episode_reward += reward\n",
    "    \n",
    "    states = torch.cat(states)\n",
    "    actions = torch.cat(actions)    \n",
    "    log_prob_actions = torch.cat(log_prob_actions)\n",
    "    values = torch.cat(values).squeeze(-1)\n",
    "    \n",
    "    returns = calculate_returns(rewards, discount_factor)\n",
    "    advantages = calculate_advantages(returns, values)\n",
    "    \n",
    "    policy_loss, value_loss = update_policy(policy, states, actions, log_prob_actions, advantages, returns, optimizer, ppo_steps, ppo_clip)\n",
    "\n",
    "    return policy_loss, value_loss, episode_reward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_returns(rewards, discount_factor, normalize = True):\n",
    "    \n",
    "    returns = []\n",
    "    R = 0\n",
    "    \n",
    "    for r in reversed(rewards):\n",
    "        R = r + R * discount_factor\n",
    "        returns.insert(0, R)\n",
    "        \n",
    "    returns = torch.tensor(returns)\n",
    "    \n",
    "    if normalize:\n",
    "        returns = (returns - returns.mean()) / returns.std()\n",
    "        \n",
    "    return returns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_advantages(returns, values, normalize = True):\n",
    "    \n",
    "    advantages = returns - values\n",
    "    \n",
    "    if normalize:\n",
    "        \n",
    "        advantages = (advantages - advantages.mean()) / advantages.std()\n",
    "        \n",
    "    return advantages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_policy(policy, states, actions, log_prob_actions, advantages, returns, optimizer, ppo_steps, ppo_clip):\n",
    "    \n",
    "    total_policy_loss = 0 \n",
    "    total_value_loss = 0\n",
    "    \n",
    "    states = states.detach()\n",
    "    actions = actions.detach()\n",
    "    log_prob_actions = log_prob_actions.detach()\n",
    "    advantages = advantages.detach()\n",
    "    returns = returns.detach()\n",
    "    \n",
    "    for _ in range(ppo_steps):\n",
    "                \n",
    "        #get new log prob of actions for all input states\n",
    "        action_pred, value_pred = policy(states)\n",
    "        value_pred = value_pred.squeeze(-1)\n",
    "        action_prob = F.softmax(action_pred, dim = -1)\n",
    "        dist = distributions.Categorical(action_prob)\n",
    "        \n",
    "        #new log prob using old actions\n",
    "        new_log_prob_actions = dist.log_prob(actions)\n",
    "        \n",
    "        policy_ratio = (new_log_prob_actions - log_prob_actions).exp()\n",
    "                \n",
    "        policy_loss_1 = policy_ratio * advantages\n",
    "        policy_loss_2 = torch.clamp(policy_ratio, min = 1.0 - ppo_clip, max = 1.0 + ppo_clip) * advantages\n",
    "        \n",
    "        policy_loss = - torch.min(policy_loss_1, policy_loss_2).mean()\n",
    "        \n",
    "        value_loss = F.smooth_l1_loss(returns, value_pred).mean()\n",
    "    \n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        policy_loss.backward()\n",
    "        value_loss.backward()\n",
    "\n",
    "        optimizer.step()\n",
    "    \n",
    "        total_policy_loss += policy_loss.item()\n",
    "        total_value_loss += value_loss.item()\n",
    "    \n",
    "    return total_policy_loss / ppo_steps, total_value_loss / ppo_steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, policy):\n",
    "    \n",
    "    policy.eval()\n",
    "    \n",
    "    rewards = []\n",
    "    done = False\n",
    "    episode_reward = 0\n",
    "\n",
    "    state = env.reset()\n",
    "\n",
    "    while not done:\n",
    "\n",
    "        state = torch.FloatTensor(state).unsqueeze(0)\n",
    "\n",
    "        with torch.no_grad():\n",
    "        \n",
    "            action_pred, _ = policy(state)\n",
    "\n",
    "            action_prob = F.softmax(action_pred, dim = -1)\n",
    "                \n",
    "        action = torch.argmax(action_prob, dim = -1)\n",
    "                \n",
    "        state, reward, done, _ = env.step(action.item())\n",
    "\n",
    "        episode_reward += reward\n",
    "        \n",
    "    return episode_reward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| Episode:  10 | Mean Train Rewards:  -175.8 | Mean Test Rewards:  -404.3 |\n",
      "| Episode:  20 | Mean Train Rewards:  -161.0 | Mean Test Rewards:  -299.2 |\n",
      "| Episode:  30 | Mean Train Rewards:  -141.4 | Mean Test Rewards:  -211.4 |\n",
      "| Episode:  40 | Mean Train Rewards:  -128.4 | Mean Test Rewards:  -242.1 |\n",
      "| Episode:  50 | Mean Train Rewards:  -121.2 | Mean Test Rewards:  -219.9 |\n",
      "| Episode:  60 | Mean Train Rewards:  -116.4 | Mean Test Rewards:  -281.5 |\n",
      "| Episode:  70 | Mean Train Rewards:  -172.3 | Mean Test Rewards:  -746.9 |\n",
      "| Episode:  80 | Mean Train Rewards:  -187.6 | Mean Test Rewards: -1225.0 |\n",
      "| Episode:  90 | Mean Train Rewards:  -248.6 | Mean Test Rewards: -1408.4 |\n",
      "| Episode: 100 | Mean Train Rewards:  -259.9 | Mean Test Rewards: -1266.7 |\n",
      "| Episode: 110 | Mean Train Rewards:  -310.9 | Mean Test Rewards: -1487.1 |\n",
      "| Episode: 120 | Mean Train Rewards:  -211.3 | Mean Test Rewards: -1534.6 |\n",
      "| Episode: 130 | Mean Train Rewards:   -48.5 | Mean Test Rewards: -1094.1 |\n",
      "| Episode: 140 | Mean Train Rewards:   -61.7 | Mean Test Rewards:  -909.4 |\n",
      "| Episode: 150 | Mean Train Rewards:  -126.0 | Mean Test Rewards: -1444.2 |\n",
      "| Episode: 160 | Mean Train Rewards:  -107.7 | Mean Test Rewards: -1788.5 |\n",
      "| Episode: 170 | Mean Train Rewards:   -95.6 | Mean Test Rewards: -2187.0 |\n",
      "| Episode: 180 | Mean Train Rewards:   -72.5 | Mean Test Rewards: -1794.7 |\n",
      "| Episode: 190 | Mean Train Rewards:   -35.9 | Mean Test Rewards: -1229.0 |\n",
      "| Episode: 200 | Mean Train Rewards:    -0.2 | Mean Test Rewards:  -781.7 |\n",
      "| Episode: 210 | Mean Train Rewards:    19.5 | Mean Test Rewards:  -633.5 |\n",
      "| Episode: 220 | Mean Train Rewards:    57.9 | Mean Test Rewards:  -524.5 |\n",
      "| Episode: 230 | Mean Train Rewards:    65.8 | Mean Test Rewards:  -456.9 |\n",
      "| Episode: 240 | Mean Train Rewards:    78.1 | Mean Test Rewards:  -300.7 |\n",
      "| Episode: 250 | Mean Train Rewards:    70.4 | Mean Test Rewards:  -229.5 |\n",
      "| Episode: 260 | Mean Train Rewards:    62.9 | Mean Test Rewards:  -195.1 |\n",
      "| Episode: 270 | Mean Train Rewards:    66.8 | Mean Test Rewards:  -239.0 |\n",
      "| Episode: 280 | Mean Train Rewards:    65.6 | Mean Test Rewards:  -262.3 |\n",
      "| Episode: 290 | Mean Train Rewards:    72.0 | Mean Test Rewards:  -247.9 |\n",
      "| Episode: 300 | Mean Train Rewards:    74.8 | Mean Test Rewards:  -183.0 |\n",
      "| Episode: 310 | Mean Train Rewards:    66.3 | Mean Test Rewards:  -220.4 |\n",
      "| Episode: 320 | Mean Train Rewards:    56.6 | Mean Test Rewards:  -246.7 |\n",
      "| Episode: 330 | Mean Train Rewards:    67.5 | Mean Test Rewards:  -187.8 |\n",
      "| Episode: 340 | Mean Train Rewards:    86.5 | Mean Test Rewards:   -95.4 |\n",
      "| Episode: 350 | Mean Train Rewards:   111.2 | Mean Test Rewards:    -7.8 |\n",
      "| Episode: 360 | Mean Train Rewards:   110.9 | Mean Test Rewards:    33.7 |\n",
      "| Episode: 370 | Mean Train Rewards:   113.9 | Mean Test Rewards:    50.9 |\n",
      "| Episode: 380 | Mean Train Rewards:   114.5 | Mean Test Rewards:    39.3 |\n",
      "| Episode: 390 | Mean Train Rewards:   109.6 | Mean Test Rewards:    38.7 |\n",
      "| Episode: 400 | Mean Train Rewards:   101.6 | Mean Test Rewards:     7.7 |\n",
      "| Episode: 410 | Mean Train Rewards:   106.2 | Mean Test Rewards:   -17.2 |\n",
      "| Episode: 420 | Mean Train Rewards:   105.9 | Mean Test Rewards:    40.5 |\n",
      "| Episode: 430 | Mean Train Rewards:   114.3 | Mean Test Rewards:   121.9 |\n",
      "| Episode: 440 | Mean Train Rewards:   120.5 | Mean Test Rewards:   186.2 |\n",
      "| Episode: 450 | Mean Train Rewards:   118.7 | Mean Test Rewards:   178.5 |\n",
      "| Episode: 460 | Mean Train Rewards:   121.8 | Mean Test Rewards:   167.9 |\n",
      "| Episode: 470 | Mean Train Rewards:   134.2 | Mean Test Rewards:   170.8 |\n",
      "| Episode: 480 | Mean Train Rewards:   132.6 | Mean Test Rewards:   194.8 |\n",
      "| Episode: 490 | Mean Train Rewards:   123.0 | Mean Test Rewards:   180.8 |\n",
      "| Episode: 500 | Mean Train Rewards:   116.9 | Mean Test Rewards:   176.8 |\n",
      "| Episode: 510 | Mean Train Rewards:   132.8 | Mean Test Rewards:   197.0 |\n",
      "Reached reward threshold in 511 episodes\n"
     ]
    }
   ],
   "source": [
    "MAX_EPISODES = 1_000\n",
    "DISCOUNT_FACTOR = 0.99\n",
    "N_TRIALS = 25\n",
    "REWARD_THRESHOLD = 200\n",
    "PRINT_EVERY = 10\n",
    "PPO_STEPS = 5\n",
    "PPO_CLIP = 0.2\n",
    "\n",
    "train_rewards = []\n",
    "test_rewards = []\n",
    "\n",
    "for episode in range(1, MAX_EPISODES+1):\n",
    "    \n",
    "    policy_loss, value_loss, train_reward = train(train_env, policy, optimizer, DISCOUNT_FACTOR, PPO_STEPS, PPO_CLIP)\n",
    "    \n",
    "    test_reward = evaluate(test_env, policy)\n",
    "    \n",
    "    train_rewards.append(train_reward)\n",
    "    test_rewards.append(test_reward)\n",
    "    \n",
    "    mean_train_rewards = np.mean(train_rewards[-N_TRIALS:])\n",
    "    mean_test_rewards = np.mean(test_rewards[-N_TRIALS:])\n",
    "    \n",
    "    if episode % PRINT_EVERY == 0:\n",
    "        \n",
    "        print(f'| Episode: {episode:3} | Mean Train Rewards: {mean_train_rewards:7.1f} | Mean Test Rewards: {mean_test_rewards:7.1f} |')\n",
    "    \n",
    "    if mean_test_rewards >= REWARD_THRESHOLD:\n",
    "        \n",
    "        print(f'Reached reward threshold in {episode} episodes')\n",
    "        \n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12,8))\n",
    "plt.plot(test_rewards, label='Test Reward')\n",
    "plt.plot(train_rewards, label='Train Reward')\n",
    "plt.xlabel('Episode', fontsize=20)\n",
    "plt.ylabel('Reward', fontsize=20)\n",
    "plt.hlines(REWARD_THRESHOLD, 0, len(test_rewards), color='r')\n",
    "plt.legend(loc='lower right')\n",
    "plt.grid()"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}