{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ppo.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oIDlkuy6TvxO"
      },
      "source": [
        "# Learning a scheduler with Stable Baselines and PPO\n",
        "\n",
        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/renatolfc/sched-rl-gym/blob/master/docs/tutorials/ppo.ipynb)\n",
        "\n",
        "In this tutorial we're going to use [sched-rl-gym](https://github.com/renatolfc/sched-rl-gym) to train an agent that's able to schedule jobs as discussed in the paper. If you want to follow along the tutorial, just click the \"Open in Colab\" badge above and you be redirected to an interactive notebook created just for you. 🤩\n",
        "\n",
        "## Preliminaries\n",
        "\n",
        "The first step is to install the environment with all its dependencies with the following command (some time in the future we'll add the project to the PyPI, making the command a lot smaller):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "drO4silhTWtn"
      },
      "source": [
        "%%capture\n",
        "\n",
        "!git clone https://github.com/renatolfc/sched-rl-gym\n",
        "!cd sched-rl-gym ; pip install -e '.[all]'\n",
        "!ln -sf sched-rl-gym/schedgym"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D1mnJMx5101f"
      },
      "source": [
        "Now, in some initial versions of the environment, we used some `__future__` annotations that the Google Colab environment did not support. Therefore, we have to perform a cleanup before continuing.\n",
        "\n",
        "This should not be necessary on Python >= 3.7..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0WD097Rgt9z6"
      },
      "source": [
        "!find schedgym/ -type f -exec sed -i '/__future__/d' {} \\;"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZeI1Ofs0UtTl"
      },
      "source": [
        "Now we need to install [stable-baselines](https://stable-baselines.readthedocs.io/), which is going to allow us to train an agent:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zghKBPYbTeRg"
      },
      "source": [
        "%%capture\n",
        "\n",
        "!pip install tensorflow==1.15\n",
        "!pip install stable-baselines"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jGDvKw5XVD8E"
      },
      "source": [
        "That's it for all dependencies. What we need now is to:\n",
        " * Import the environment so that it can be registered with [OpenAI Gym](https://gym.openai.com)\n",
        " * Import stable-baselines to learn our agent\n",
        "\n",
        "We're also importing some other modules to interact with the filesystem and to help us compute some basic statistics..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PFND3Uq-U6iY"
      },
      "source": [
        "%%capture\n",
        "\n",
        "import os\n",
        "import gym\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import schedgym.envs as deeprm\n",
        "import schedgym.envs.base as base\n",
        "\n",
        "from stable_baselines import PPO2 as PPO\n",
        "from stable_baselines.common.vec_env import DummyVecEnv\n",
        "from stable_baselines.common.policies import FeedForwardPolicy"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gzfS5kGI2LdF"
      },
      "source": [
        "We're going to define some variables to match those of the paper. They are:\n",
        " * `SLOTS`: The number of job slots to choose from (the number of actions - 1 the agent can perform)\n",
        " * `BACKLOG`: The number of jobs we represent outside the job slots (this should be a multiple of the `TIME_HORIZON`, defined below)\n",
        " * `TIME_LIMIT`: The number of RL time steps before finishing an episode\n",
        " * The default workload in the environment creates a new job with probability 0.7. The experiments in the paper were performed with probability 0.3. So we copy the default workload and define the new probability"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1fKUBSUYVigG"
      },
      "source": [
        "SLOTS: int = 10\n",
        "BACKLOG: int = 60\n",
        "TIME_LIMIT: int = 50\n",
        "TIME_HORIZON: int = 20\n",
        "\n",
        "workload = base.DEFAULT_WORKLOAD.copy()\n",
        "workload['new_job_rate'] = .3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b2oXzOnr29xe"
      },
      "source": [
        "And since we're *not* using the default arguments, we're going to define a helper function to create new environments for us."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gmj9-QWHVusm"
      },
      "source": [
        "def setup_environment(envname, workload=None) -> deeprm.DeepRmEnv:\n",
        "    kwargs = {\n",
        "        'job_slots': SLOTS,\n",
        "        'time_limit': TIME_LIMIT,\n",
        "        'backlog_size': BACKLOG,\n",
        "        'time_horizon': TIME_HORIZON,\n",
        "        'use_raw_state': False,\n",
        "    }\n",
        "    if workload is not None:\n",
        "        kwargs['workload'] = workload\n",
        "    env: deeprm.DeepRmEnv = gym.make(\n",
        "        envname, **kwargs\n",
        "    )\n",
        "    env.reset()\n",
        "\n",
        "    return env"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KX2fyDyK3IYf"
      },
      "source": [
        "Now, the default PPO implementation in stable baselines uses a two-layer MLP with 64 nodes each, but we're using 20 nodes, so we define a custom policy network to train our agent.\n",
        "\n",
        "In the code below, `pi` corresponds to the policy network, while `vf` corresponds to the value function that is used as baseline function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TaoOAU0zvfQA"
      },
      "source": [
        "class CustomPolicy(FeedForwardPolicy):\n",
        "    def __init__(self, *args, **kwargs):\n",
        "        super(CustomPolicy, self).__init__(*args, **kwargs,\n",
        "                                           net_arch=[dict(pi=[20],\n",
        "                                                          vf=[20])],\n",
        "                                           feature_extraction=\"mlp\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ECZvQvRj31O3"
      },
      "source": [
        "With all that, we can instantiate our learner."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a36QRpdW37L9"
      },
      "source": [
        "env = setup_environment('DeepRM-v0', workload)\n",
        "env = DummyVecEnv([lambda: env])\n",
        "model = PPO(CustomPolicy, env, verbose=1,\n",
        "            learning_rate=5e-4, ent_coef=0.01)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cJqMHoxS3hRJ"
      },
      "source": [
        "With all these definitions, we can now run our training loop.\n",
        "\n",
        "The experiments in the paper ran for 1000 epochs, but that'd take too much time, so we're going to limit ourselves to a hundred.\n",
        "\n",
        "You will notice that we define an epoch as 10000 time steps. This is equivalent to the number of interactions with the environment DeepRM counts as one epoch.\n",
        "\n",
        "After each epoch, we save a snapshot of the model so that we can evaluate its performance. We should see ever improving, albeit noisy, performance."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9tct5pOCx8hh",
        "outputId": "78cc09b1-1446-4edb-9777-a49c0823497f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "total_epochs = 250\n",
        "timesteps_in_epoch = 1000\n",
        "for i in range(total_epochs):\n",
        "    print(f'\\rRunning training epoch: {i}/{total_epochs}', end='')\n",
        "    model.learn(total_timesteps=timesteps_in_epoch,\n",
        "                reset_num_timesteps=(i == 0),\n",
        "                log_interval=150)\n",
        "    model.save(f'ppo_deeprm-{i}')\n",
        "\n",
        "model.save('ppo_deeprm')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Running training epoch: 249/250"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sER9LxbJHBbJ"
      },
      "source": [
        "So now we have all intermediate sets of parameters. Nice!\n",
        "\n",
        "How can we evaluate them? Well, since the environment is stochastic, we will have to use Monte Carlo to approximate the agent performance. So, let us assume we use 30 independent samples (we used 60 in the paper) and report the average performance, alongside the standard deviation.\n",
        "\n",
        "We will also be (hard) limiting an episode to last for 200 time steps. In practice, they will terminate earlier due to the nature of our environment."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "--te_M9f8oK7"
      },
      "source": [
        "Before evaluating our environment, we need a few helper functions, as well as code for plotting. In the following cell, we import `matplotlib` to generate our graphs:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BjhsVqbQG-4K"
      },
      "source": [
        "%matplotlib inline\n",
        "import matplotlib as mpl\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "mpl.style.use('bmh')  # Bayesian Methods for Hackers"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qp5IpIdZDS5-"
      },
      "source": [
        "Now we define a function that, given a vector of rewards $\\langle r_1, r_2, \\ldots\\rangle$, gives us a vector $\\langle G_1=\\sum_{i=1}^{T}\\gamma^{i-1}r_i, G_2=\\sum_{i=2}^{T}\\gamma^{i-1}r_i, \\ldots \\rangle$, which will give us the sum of discounted rewards for all time steps encountered by the agent:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MoGPQk6vIBJl"
      },
      "source": [
        "def discount(x, gamma):\n",
        "    \"\"\"Returns discounted returns for all time steps in an episode.\n",
        "    \n",
        "    Given vector x, computes a vector y such that\n",
        "    y[i] = x[i] + gamma * x[i+1] + gamma^2 x[i+2] + ...\n",
        "    \"\"\"\n",
        "    out = np.zeros(len(x))\n",
        "    out[-1] = x[-1]\n",
        "    for i in reversed(list(range(len(x)-1))):\n",
        "        out[i] = x[i] + gamma*out[i+1]\n",
        "    return out"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7mo-7easEAVR"
      },
      "source": [
        "We also need the code that will instantiate the environment and evaluate the agent in such an environment. In this specific case, we gather a single trajectory, and compute the sum of rewards, the mean slowdown, the discounted sum of rewards for the first time step, and the mean reward for a single trajectory:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q3s8pk7XD8XZ"
      },
      "source": [
        "def run_baselines_model(args):\n",
        "    env, model, i, raw, workload = args\n",
        "    env = setup_environment(env, workload=workload)\n",
        "    env.use_raw_state = raw\n",
        "    np.random.seed(i)\n",
        "    rewards = []\n",
        "    state = env.reset()\n",
        "    for _ in range(200):\n",
        "        action, _ = model.predict(state, deterministic=True)\n",
        "        state, reward, done, _ = env.step(action)\n",
        "        rewards.append(reward)\n",
        "        if done:\n",
        "            break\n",
        "    mean_slowdown = np.mean([\n",
        "          1 + 1 / j.execution_time * (\n",
        "              (j.start_time - j.submission_time)\n",
        "              if j.start_time != -1\n",
        "              else (env.scheduler.current_time - j.submission_time)\n",
        "          )\n",
        "          for j in env.scheduler.all_jobs\n",
        "    ])\n",
        "    return np.sum(rewards), mean_slowdown, discount(rewards, 0.99)[0],\\\n",
        "           np.mean(rewards)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hWjuZaQSEcKq"
      },
      "source": [
        "Finally, with the two functions defined above, we can write code that evaluates the agent. In this particular case, the evaluation function takes a _class_ instance, an environment name, and a policy checkpoint file name template to evaluate an agent for `total_epochs` in a set of `runs` independent runs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OrfWRejCEcqs"
      },
      "source": [
        "from IPython.utils import io\n",
        "\n",
        "def evaluate(model_class, env, template, runs=30, total_epochs=total_epochs):\n",
        "  rewards, slowdowns, returns, means = [], [], [], []\n",
        "  for i in range(total_epochs):\n",
        "    print(f'\\rEvaluating epoch {i}/{total_epochs}', end='')\n",
        "    with io.capture_output():\n",
        "      model = model_class.load(template.format(i))\n",
        "    reward, slowdown, ret, mean = zip(\n",
        "      *[run_baselines_model((env, model, j, False, workload))\n",
        "        for j in range(runs)]\n",
        "    )\n",
        "    rewards.append(reward)\n",
        "    slowdowns.append(slowdown)\n",
        "    returns.append(ret)\n",
        "    means.append(mean)\n",
        "  return rewards, slowdowns, returns, means"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pKQnkFD6E47r"
      },
      "source": [
        "Finally, with all the above definitions, we can run our agent and evaluate it with a single call to `evaluate`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3olr7LNNIlVn",
        "outputId": "835325cd-6c2e-4c92-af63-4befef3f171e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "rewards, slowdowns, returns, means = evaluate(\n",
        "    PPO, 'DeepRM-v0', 'ppo_deeprm-{}', 60\n",
        ")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Evaluating epoch 249/250"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NqV5KzSPKBqG"
      },
      "source": [
        "With everything executed, we can investigate how our agent fared in the evaluation runs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_PBmZHOHLHeR",
        "outputId": "308f0d7f-e7ab-4486-f5cb-08edf1c01913",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        }
      },
      "source": [
        "df = pd.DataFrame({\n",
        "  'mean': [np.mean(r) for r in returns],\n",
        "  'std': [np.std(r) for r in returns]\n",
        "})\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "\n",
        "y = df['mean'].rolling(window=10).mean()\n",
        "yerror = df['std'].rolling(window=10).mean()\n",
        "x = y.index\n",
        "\n",
        "ax.plot(x, y)\n",
        "ax.fill_between(x, y - yerror, y + yerror, alpha=.5)\n",
        "ax.set_ylabel('Average discounted returns')\n",
        "ax.set_xlabel('Iteration')\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "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": "code",
      "metadata": {
        "id": "S4zO2PVbJM4I",
        "outputId": "85c90860-5330-4a73-8131-5df236ec0eb1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        }
      },
      "source": [
        "df = pd.DataFrame({\n",
        "  'mean': [np.mean(s) for s in slowdowns],\n",
        "  'std': [np.std(s) for s in slowdowns]\n",
        "})\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "\n",
        "y = df['mean'].rolling(window=10).mean()\n",
        "yerror = df['std'].rolling(window=10).mean()\n",
        "x = y.index\n",
        "\n",
        "ax.plot(x, y)\n",
        "ax.fill_between(x, y - yerror, y + yerror, alpha=.5)\n",
        "ax.set_ylabel('Average Slowdown')\n",
        "ax.set_xlabel('Iteration')\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "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"
          }
        }
      ]
    }
  ]
}