SAC_SQIL_MountainCar.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "SAC_SQIL_MountainCar.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "eP8e9dKYFuHd"
      },
      "source": [
        "!pip install box2d-py\n",
        "!pip install stable-baselines3\n",
        "!pip install git+https://github.com/indrasweb/expert-offline-rl.git"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IitdeHDwF3rx"
      },
      "source": [
        "import numpy as np\n",
        "from google.colab import drive\n",
        "import gym\n",
        "from eorl import OfflineDataset\n",
        "import os\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import torch as T\n",
        "import torch.nn as nn\n",
        "\n",
        "from stable_baselines3.common.utils import set_random_seed\n",
        "from stable_baselines3.common.env_util import make_atari_env\n",
        "from stable_baselines3.common.vec_env import VecFrameStack\n",
        "from stable_baselines3.common.monitor import Monitor\n",
        "from stable_baselines3.common.callbacks import CheckpointCallback\n",
        "from stable_baselines3.common.type_aliases import ReplayBufferSamples\n",
        "from stable_baselines3.common.buffers import ReplayBuffer\n",
        "from stable_baselines3 import SAC"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OUG8MAapGDaM"
      },
      "source": [
        "DEVICE = T.device('cuda' if T.cuda.is_available() else 'cpu')\n",
        "ENV_NAME = 'MountainCarContinuous-v0'\n",
        "DS_NAME = 'MountainCarContinuous-v0'\n",
        "SAVE_DIR = 'gdrive/MyDrive/SQIL/Imitation/'\n",
        "ONLINE_STEPS = 1e5\n",
        "EXPERT_STEPS = 1e5\n",
        "SEED = 1337"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BeYYE97iemC3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2f1fb92e-b8cc-4ae9-9ac6-853aecb10c16"
      },
      "source": [
        "drive.mount('/content/gdrive/')  # model checkpoints + training stats \n",
        "set_random_seed(SEED)  # torch, np and py seeds\n",
        "ds = OfflineDataset(ENV_NAME, dataset_size=EXPERT_STEPS)\n",
        "\n",
        "if not os.path.exists(SAVE_DIR):\n",
        "    os.makedirs(SAVE_DIR)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/gdrive/; to attempt to forcibly remount, call drive.mount(\"/content/gdrive/\", force_remount=True).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5IuamzwgsE3L",
        "outputId": "789f695f-926e-444d-ed21-4ae920b03e67"
      },
      "source": [
        "env = Monitor(gym.make(ENV_NAME), filename=SAVE_DIR+ENV_NAME)\n",
        "\n",
        "checkpoint_callback = CheckpointCallback(\n",
        "    save_freq=ONLINE_STEPS, \n",
        "    save_path=SAVE_DIR, \n",
        "    name_prefix=ENV_NAME\n",
        ")\n",
        "\n",
        "model = SAC(\n",
        "    env=env,\n",
        "    policy='MlpPolicy',\n",
        "    learning_starts=0,\n",
        "    learning_rate=3e-4,\n",
        "    buffer_size=50000,\n",
        "    batch_size=512,\n",
        "    ent_coef=0.1,\n",
        "    train_freq=32,\n",
        "    gradient_steps=32,\n",
        "    gamma=0.9999,\n",
        "    tau=0.01,\n",
        "    verbose=1,\n",
        "    use_sde=True,\n",
        "    policy_kwargs=dict(log_std_init=-3.67, net_arch=[64, 64])\n",
        ")"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Using cuda device\n",
            "Wrapping the env in a DummyVecEnv.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ntDDp64BSaiQ"
      },
      "source": [
        "expert_buffer = ReplayBuffer(\n",
        "    20000, \n",
        "    model.replay_buffer.observation_space, \n",
        "    model.replay_buffer.action_space, \n",
        "    DEVICE\n",
        ")\n",
        "\n",
        "def populate_expert_buffer(expert_buf, expert_ds, num_samples=20000):\n",
        "    batch_size = 500\n",
        "    batches = num_samples // batch_size\n",
        "    \n",
        "    for _ in range(batches):\n",
        "        obs, acts, rwds, dones, next_obs = expert_ds.batch(batch_size)        \n",
        "        for i in range(batch_size):\n",
        "            expert_buf.add(obs[i], next_obs[i], acts[i], rwds[i], dones[i])"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s7xObwbidNSK"
      },
      "source": [
        "def modified_replay_buffer_sample(batch_size: int, env) -> ReplayBufferSamples:\n",
        "    online_samples = super(model.replay_buffer.__class__, model.replay_buffer).sample(batch_size//2, env)\n",
        "    expert_samples = expert_buffer.sample(batch_size//2, env)\n",
        "    obs      = T.cat((online_samples.observations, expert_samples.observations))\n",
        "    actions  = T.cat((online_samples.actions, expert_samples.actions))\n",
        "    next_obs = T.cat((online_samples.next_observations, expert_samples.next_observations))\n",
        "    rewards  = T.cat((T.zeros_like(online_samples.rewards), T.ones_like(expert_samples.rewards)))\n",
        "    dones    = T.cat((online_samples.dones, expert_samples.dones))\n",
        "    \n",
        "    return ReplayBufferSamples(obs, actions, next_obs, dones, rewards)\n",
        "\n",
        "model.replay_buffer.sample = modified_replay_buffer_sample"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vdcc3FOg1lvi"
      },
      "source": [
        "populate_expert_buffer(expert_buffer, ds, int(EXPERT_STEPS))"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P7f1m5gnd8XY",
        "outputId": "f9e72ca6-4c27-4a47-9294-1e87cdccbc19"
      },
      "source": [
        "model.learn(ONLINE_STEPS, log_interval=10, callback=checkpoint_callback)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "---------------------------------\n",
            "| rollout/           |          |\n",
            "|    ep_len_mean     | 745      |\n",
            "|    ep_rew_mean     | 22.2     |\n",
            "| time/              |          |\n",
            "|    episodes        | 10       |\n",
            "|    fps             | 86       |\n",
            "|    time_elapsed    | 86       |\n",
            "|    total timesteps | 7447     |\n",
            "| train/             |          |\n",
            "|    actor_loss      | -28.4    |\n",
            "|    critic_loss     | 1.07     |\n",
            "|    ent_coef        | 0.1      |\n",
            "|    learning_rate   | 0.0003   |\n",
            "|    n_updates       | 7424     |\n",
            "|    std             | 0.0271   |\n",
            "---------------------------------\n",
            "---------------------------------\n",
            "| rollout/           |          |\n",
            "|    ep_len_mean     | 591      |\n",
            "|    ep_rew_mean     | 51.9     |\n",
            "| time/              |          |\n",
            "|    episodes        | 20       |\n",
            "|    fps             | 86       |\n",
            "|    time_elapsed    | 136      |\n",
            "|    total timesteps | 11815    |\n",
            "| train/             |          |\n",
            "|    actor_loss      | -40.9    |\n",
            "|    critic_loss     | 1.4      |\n",
            "|    ent_coef        | 0.1      |\n",
            "|    learning_rate   | 0.0003   |\n",
            "|    n_updates       | 11808    |\n",
            "|    std             | 0.0276   |\n",
            "---------------------------------\n",
            "---------------------------------\n",
            "| rollout/           |          |\n",
            "|    ep_len_mean     | 660      |\n",
            "|    ep_rew_mean     | 43.5     |\n",
            "| time/              |          |\n",
            "|    episodes        | 30       |\n",
            "|    fps             | 86       |\n",
            "|    time_elapsed    | 228      |\n",
            "|    total timesteps | 19785    |\n",
            "| train/             |          |\n",
            "|    actor_loss      | -59.2    |\n",
            "|    critic_loss     | 3.82     |\n",
            "|    ent_coef        | 0.1      |\n",
            "|    learning_rate   | 0.0003   |\n",
            "|    n_updates       | 19776    |\n",
            "|    std             | 0.0266   |\n",
            "---------------------------------\n",
            "---------------------------------\n",
            "| rollout/           |          |\n",
            "|    ep_len_mean     | 744      |\n",
            "|    ep_rew_mean     | 30.9     |\n",
            "| time/              |          |\n",
            "|    episodes        | 40       |\n",
            "|    fps             | 86       |\n",
            "|    time_elapsed    | 344      |\n",
            "|    total timesteps | 29775    |\n",
            "| train/             |          |\n",
            "|    actor_loss      | -82.2    |\n",
            "|    critic_loss     | 4.61     |\n",
            "|    ent_coef        | 0.1      |\n",
            "|    learning_rate   | 0.0003   |\n",
            "|    n_updates       | 29760    |\n",
            "|    std             | 0.0284   |\n",
            "---------------------------------\n",
            "---------------------------------\n",
            "| rollout/           |          |\n",
            "|    ep_len_mean     | 795      |\n",
            "|    ep_rew_mean     | 23.1     |\n",
            "| time/              |          |\n",
            "|    episodes        | 50       |\n",
            "|    fps             | 86       |\n",
            "|    time_elapsed    | 459      |\n",
            "|    total timesteps | 39765    |\n",
            "| train/             |          |\n",
            "|    actor_loss      | -95.8    |\n",
            "|    critic_loss     | 5.55     |\n",
            "|    ent_coef        | 0.1      |\n",
            "|    learning_rate   | 0.0003   |\n",
            "|    n_updates       | 39744    |\n",
            "|    std             | 0.0298   |\n",
            "---------------------------------\n",
            "---------------------------------\n",
            "| rollout/           |          |\n",
            "|    ep_len_mean     | 829      |\n",
            "|    ep_rew_mean     | 17       |\n",
            "| time/              |          |\n",
            "|    episodes        | 60       |\n",
            "|    fps             | 86       |\n",
            "|    time_elapsed    | 575      |\n",
            "|    total timesteps | 49755    |\n",
            "| train/             |          |\n",
            "|    actor_loss      | -105     |\n",
            "|    critic_loss     | 9.14     |\n",
            "|    ent_coef        | 0.1      |\n",
            "|    learning_rate   | 0.0003   |\n",
            "|    n_updates       | 49728    |\n",
            "|    std             | 0.0314   |\n",
            "---------------------------------\n",
            "---------------------------------\n",
            "| rollout/           |          |\n",
            "|    ep_len_mean     | 854      |\n",
            "|    ep_rew_mean     | 10.8     |\n",
            "| time/              |          |\n",
            "|    episodes        | 70       |\n",
            "|    fps             | 86       |\n",
            "|    time_elapsed    | 692      |\n",
            "|    total timesteps | 59745    |\n",
            "| train/             |          |\n",
            "|    actor_loss      | -118     |\n",
            "|    critic_loss     | 7.89     |\n",
            "|    ent_coef        | 0.1      |\n",
            "|    learning_rate   | 0.0003   |\n",
            "|    n_updates       | 59744    |\n",
            "|    std             | 0.0347   |\n",
            "---------------------------------\n",
            "---------------------------------\n",
            "| rollout/           |          |\n",
            "|    ep_len_mean     | 872      |\n",
            "|    ep_rew_mean     | 7.32     |\n",
            "| time/              |          |\n",
            "|    episodes        | 80       |\n",
            "|    fps             | 86       |\n",
            "|    time_elapsed    | 807      |\n",
            "|    total timesteps | 69735    |\n",
            "| train/             |          |\n",
            "|    actor_loss      | -124     |\n",
            "|    critic_loss     | 7.91     |\n",
            "|    ent_coef        | 0.1      |\n",
            "|    learning_rate   | 0.0003   |\n",
            "|    n_updates       | 69728    |\n",
            "|    std             | 0.0409   |\n",
            "---------------------------------\n",
            "---------------------------------\n",
            "| rollout/           |          |\n",
            "|    ep_len_mean     | 886      |\n",
            "|    ep_rew_mean     | 4.95     |\n",
            "| time/              |          |\n",
            "|    episodes        | 90       |\n",
            "|    fps             | 86       |\n",
            "|    time_elapsed    | 922      |\n",
            "|    total timesteps | 79725    |\n",
            "| train/             |          |\n",
            "|    actor_loss      | -126     |\n",
            "|    critic_loss     | 9.16     |\n",
            "|    ent_coef        | 0.1      |\n",
            "|    learning_rate   | 0.0003   |\n",
            "|    n_updates       | 79712    |\n",
            "|    std             | 0.0376   |\n",
            "---------------------------------\n",
            "---------------------------------\n",
            "| rollout/           |          |\n",
            "|    ep_len_mean     | 897      |\n",
            "|    ep_rew_mean     | 3.62     |\n",
            "| time/              |          |\n",
            "|    episodes        | 100      |\n",
            "|    fps             | 86       |\n",
            "|    time_elapsed    | 1037     |\n",
            "|    total timesteps | 89715    |\n",
            "| train/             |          |\n",
            "|    actor_loss      | -130     |\n",
            "|    critic_loss     | 12.1     |\n",
            "|    ent_coef        | 0.1      |\n",
            "|    learning_rate   | 0.0003   |\n",
            "|    n_updates       | 89696    |\n",
            "|    std             | 0.0348   |\n",
            "---------------------------------\n",
            "---------------------------------\n",
            "| rollout/           |          |\n",
            "|    ep_len_mean     | 923      |\n",
            "|    ep_rew_mean     | 0.91     |\n",
            "| time/              |          |\n",
            "|    episodes        | 110      |\n",
            "|    fps             | 86       |\n",
            "|    time_elapsed    | 1152     |\n",
            "|    total timesteps | 99705    |\n",
            "| train/             |          |\n",
            "|    actor_loss      | -144     |\n",
            "|    critic_loss     | 9.97     |\n",
            "|    ent_coef        | 0.1      |\n",
            "|    learning_rate   | 0.0003   |\n",
            "|    n_updates       | 99680    |\n",
            "|    std             | 0.0397   |\n",
            "---------------------------------\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<stable_baselines3.sac.sac.SAC at 0x7f279a814110>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 611
        },
        "id": "fWnAam1PgqS2",
        "outputId": "5605574a-b2ca-4e03-d8f2-e201f1f7fe9e"
      },
      "source": [
        " def plot_log(df_path):\n",
        "\n",
        "    with open(df_path, \"rt\") as f:\n",
        "        _ = f.readline()\n",
        "        df = pd.read_csv(f)\n",
        "        df.sort_values(\"t\", inplace=True)\n",
        "        df.reset_index(inplace=True)\n",
        "\n",
        "    # compute rolling avg and std\n",
        "    sma_y = df['r'].rolling(100, min_periods=1).mean()\n",
        "    std_y = df['r'].rolling(100, min_periods=1).std()\n",
        "    \n",
        "    # plot with seaborn\n",
        "    sns.set()\n",
        "    fig, ax = plt.subplots(figsize=(10,10))\n",
        "    ax.set_xlabel('Timesteps')\n",
        "    ax.set_ylabel('Reward')\n",
        "    clrs = sns.color_palette(\"husl\", 8)\n",
        "\n",
        "    true_x = (ONLINE_STEPS // max(df['index'])) * df['index']\n",
        "\n",
        "    # fill standard deviation\n",
        "    ax.plot(true_x, sma_y, c=clrs[0])\n",
        "    ax.fill_between(true_x, sma_y-std_y,  sma_y+std_y, \n",
        "                    alpha=0.3, facecolor=clrs[0]) \n",
        "    plt.savefig(SAVE_DIR+ENV_NAME+'.reward_history.png', \n",
        "                dpi=300, pad_inches=0)\n",
        "    plt.show()\n",
        "\n",
        "plot_log(SAVE_DIR+ENV_NAME+'.monitor.csv')"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    }
  ]
}