{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Agent, RL and MultiEnvironment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is recommended to have a look at the [0_basic_functionalities](0_basic_functionalities.ipynb), [1_Observation_Agents](1_Observation_Agents.ipynb) and [2_Action_GridManipulation](2_Action_GridManipulation.ipynb) and especially [3_TrainingAnAgent](3_TrainingAnAgent.ipynb) notebooks before getting into this one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Objectives**\n",
    "\n",
    "In this notebook we will expose :\n",
    "* what is a \"MultiEnv\"\n",
    "* how can it be used with an agent\n",
    "* how can it be used to train a agent that uses different environments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Impossible to automatically add a menu / table of content to this notebook.\n",
      "You can download \"jyquickhelper\" package with: \n",
      "\"pip install jyquickhelper\"\n"
     ]
    }
   ],
   "source": [
    "res = None\n",
    "try:\n",
    "    from jyquickhelper import add_notebook_menu\n",
    "    res = add_notebook_menu()\n",
    "except ModuleNotFoundError:\n",
    "    print(\"Impossible to automatically add a menu / table of content to this notebook.\\nYou can download \\\"jyquickhelper\\\" package with: \\n\\\"pip install jyquickhelper\\\"\")\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import grid2op\n",
    "from grid2op.Reward import ConstantReward, FlatReward\n",
    "from tqdm.notebook import tqdm\n",
    "from grid2op.Runner import Runner\n",
    "import sys\n",
    "import os\n",
    "import numpy as np\n",
    "TRAINING_STEP = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## I) Download more data for the default environment.\n",
    "\n",
    "A lot of data have been made available for the default \"case14_redisp\" environment. Including this data in the package is not convenient. We chose instead to release them and make them easily available with a utility. To download them in the default directory (\"~/data_grid2op/case14_redisp\") on linux based system you can do the following (uncomment the following command)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !$sys.executable -m grid2op.download --name \"case14_realistic\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## I) Make a regular environment and agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we downloaded the dataset, it is time to make an environment that will use all the data avaiable. You can execute the following command line. If you see any error or warning consider re downloading the data, or adapting the key-word argument \"chronics_path\" to match the path where the data have been downloaded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = grid2op.make(\"rte_case14_realistic\", test=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A lot of data have been made available for the default \"rte_case14_realistic\" environment. Including this data in the package is not convenient. \n",
    "\n",
    "We chose instead to release them and make them easily available with a utility. To download them in the default directory (\"~/data_grid2op/case14_redisp\")  just pass the argument \"test=False\" (or don't pass anything else) as local=False is the default value. It will download approximately 300Mo of data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## II) Train a standard RL Agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure you are using a computer with at least 4 cores if you want to notice some speed-ups."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from grid2op.Environment import MultiEnvironment\n",
    "from grid2op.Agent import DoNothingAgent\n",
    "NUM_CORE = 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IIIa) Using the standard open AI gym loop\n",
    "\n",
    "Here we demonstrate how to use the multi environment class. First let's create a multi environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a simple agent\n",
    "agent = DoNothingAgent(env.action_space)\n",
    "\n",
    "# create the multi environment class\n",
    "multi_envs = MultiEnvironment(env=env, nb_env=NUM_CORE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A multienvironment is just like a regular environment but instead of dealing with one action, and one observation, is requires to be sent multiple actions, and returns a list of observations as well. \n",
    "\n",
    "It requires a grid2op environment to be initialized and creates some specific \"workers\", each a replication of the initial environment. None of the \"worker\" can be accessed directly. Supported methods are:\n",
    "- multi_env.reset\n",
    "- multi_env.step\n",
    "- multi_env.close\n",
    "\n",
    "That have similar behaviour to \"env.step\", \"env.close\" or \"env.reset\".\n",
    "\n",
    "\n",
    "It can be used the following manner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([<grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f88c6c65f10>,\n",
       "       <grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f88c6c654c0>,\n",
       "       <grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f88c6c652b0>,\n",
       "       <grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f88c6c65b80>,\n",
       "       <grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f88c6c65580>,\n",
       "       <grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f88c6c65b20>,\n",
       "       <grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f88c6c65a30>,\n",
       "       <grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f88c6c652e0>],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# initiliaze some variable with the proper dimension\n",
    "obss = multi_envs.reset()\n",
    "rews = [env.reward_range[0] for i in range(NUM_CORE)]\n",
    "dones = [False for i in range(NUM_CORE)]\n",
    "obss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[False, False, False, False, False, False, False, False]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, obs is not a single obervation, but a list (numpy nd array to be precise) of 4 observations, each one being an observation of a given \"worker\" environment.\n",
    "\n",
    "Worker environments are always called in the same order. It means the first observation of this vector will always correspond to the first worker environment. \n",
    "\n",
    "\n",
    "Similarly to Observation, the \"step\" function of a multi_environment takes as input a list of multiple actions, each action will be implemented in its own environment. It returns a list of observations, a list of rewards, and boolean list of whether or not the worker environment suffer from a game over (in that case this worker environment is automatically restarted using the \"reset\" method.)\n",
    "\n",
    "Because orker environments are always called in the same order, the first action sent to the \"multi_env.step\" function will also be applied on this first environment.\n",
    "\n",
    "It is possible to use it as follow:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([<grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f88c6848a90>,\n",
       "       <grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f88c6848c40>,\n",
       "       <grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f890ce82610>,\n",
       "       <grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f890ce82550>,\n",
       "       <grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f890ce825b0>,\n",
       "       <grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f890ce82850>,\n",
       "       <grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f890d6f0f40>,\n",
       "       <grid2op.Space.GridObjects.GridObjects.init_grid.<locals>.res object at 0x7f890d6f0970>],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# initialize the vector of actions that will be processed by each worker environment.\n",
    "acts = [None for _ in range(NUM_CORE)]\n",
    "for env_act_id in range(NUM_CORE):\n",
    "    acts[env_act_id] = agent.act(obss[env_act_id], rews[env_act_id], dones[env_act_id])\n",
    "    \n",
    "# feed them to the multi_env\n",
    "obss, rews, dones, infos = multi_envs.step(acts)\n",
    "\n",
    "# as explained, this is a vector of Observation (as many as NUM_CORE in this example)\n",
    "obss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The multi environment loop is really close to the \"gym\" loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# performs the appropriated steps\n",
    "for i in range(10):\n",
    "    acts = [None for _ in range(NUM_CORE)]\n",
    "    for env_act_id in range(NUM_CORE):\n",
    "        acts[env_act_id] = agent.act(obss[env_act_id], rews[env_act_id], dones[env_act_id])\n",
    "    obss, rews, dones, infos = multi_envs.step(acts)\n",
    "\n",
    "    # DO SOMETHING WITH THE AGENT IF YOU WANT\n",
    "    ## agent.train(obss, rews, dones)\n",
    "    \n",
    "\n",
    "# close the environments created by the multi_env\n",
    "multi_envs.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On the above example, `TRAINING_STEP` steps are performed on `NUM_CORE` environments in parrallel. The agent has then acted `TRAINING_STEP * NUM_CORE` (=`10 * 4 = 40` by default) times on `NUM_CORE` different environments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### III.b) Practical example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We reuse the code of the Notebook [3_TrainingAnAgent](3_TrainingAnAgent.ipynb) to train a new agent, but this time using more than one process of the machine. To further emphasize the working of multi environments, we put on a different module ([ml_agent](ml_agent.py)) the code of some agents and focus here on the training part. \n",
    "\n",
    "Note that compare to the previous notebook, the code have been adapted to used \"batch\" of data when predicting movments. The input data is also restricted to:\n",
    "- the relative flow value\n",
    "- the powerline status\n",
    "- the topology vector\n",
    "\n",
    "All the other component of the observations are not used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ml_agent import TrainingParam, ReplayBuffer, DeepQAgent\n",
    "from grid2op.Agent import AgentWithConverter\n",
    "from grid2op.Reward import RedispReward\n",
    "from grid2op.Converter import IdToAct\n",
    "import numpy as np\n",
    "import random\n",
    "import warnings\n",
    "import pdb\n",
    "with warnings.catch_warnings():\n",
    "    warnings.filterwarnings(\"ignore\", category=FutureWarning)\n",
    "    import tensorflow.keras\n",
    "    import tensorflow.keras.backend as K\n",
    "    from tensorflow.keras.models import load_model, Sequential, Model\n",
    "    from tensorflow.keras.optimizers import Adam\n",
    "    from tensorflow.keras.layers import Activation, Dropout, Flatten, Dense, subtract, add\n",
    "    from tensorflow.keras.layers import Input, Lambda, Concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TrainAgentMultiEnv(object):\n",
    "    def __init__(self, agent, nb_process, reward_fun=RedispReward, env=None, name=None):\n",
    "        # compare to the version showed in the notebook 3, the process buffer has been moved in this class\n",
    "        # and we add a multi_envs argument.\n",
    "        self.nb_process = nb_process\n",
    "        self.multi_envs = None\n",
    "        self.process_buffer = [[] for _ in range(self.nb_process)]\n",
    "        self.name = name\n",
    "        self.agent = agent\n",
    "        self.env = env\n",
    "        self.training_param = None\n",
    "    \n",
    "    def close(self):\n",
    "        self.multi_envs.close()\n",
    "        \n",
    "    def convert_process_buffer(self):\n",
    "        \"\"\"Converts the list of NUM_FRAMES images in the process buffer\n",
    "        into one training sample\"\"\"\n",
    "        # here i simply concatenate the action in case of multiple action in the \"buffer\"\n",
    "        if self.training_param.NUM_FRAMES != 1:\n",
    "            raise RuntimeError(\"This has not been tested with self.training_param.NUM_FRAMES != 1 for now\")\n",
    "        return np.array([np.concatenate(el) for el in self.process_buffer])\n",
    "        \n",
    "    def _build_valid_env(self, training_param):\n",
    "        # this function has also be adapted\n",
    "        create_new = False\n",
    "        if self.multi_envs is None:\n",
    "            create_new = True\n",
    "            # first we need to initialize the multi environment\n",
    "            self.multi_envs = MultiEnvironment(env=env, nb_env=self.nb_process)\n",
    "            \n",
    "            # then, as before, we reset it\n",
    "            obss = self.multi_envs.reset()\n",
    "            for worker_id in range(self.nb_process):\n",
    "                self.process_buffer[worker_id].append(self.agent.convert_obs(obss[worker_id]))\n",
    "                \n",
    "            # used in case of \"num frames\" != 1 (so not tested)\n",
    "            do_nothing = [self.env.action_space() for _ in range(self.nb_process)]\n",
    "            for _ in range(training_param.NUM_FRAMES-1):\n",
    "                # Initialize buffer with the first frames\n",
    "                s1, r1, _, _ = self.multi_envs.step(do_nothing)\n",
    "                for worker_id in range(self.nb_process):\n",
    "                    # difference compared to previous implementation: we loop through all the observations\n",
    "                    # and save them all\n",
    "                    self.process_buffer[worker_id].append(self.agent.convert_obs(s1[worker_id])) \n",
    "                    \n",
    "        return create_new\n",
    "    \n",
    "    def train(self, num_frames, training_param=TrainingParam()):\n",
    "        self.training_param = training_param\n",
    "        \n",
    "        # first we create an environment or make sure the given environment is valid\n",
    "        close_env = self._build_valid_env(training_param)\n",
    "        \n",
    "        # same as in the original implemenation, except the process buffer is now in this class\n",
    "        observation_num = 0\n",
    "        curr_state = self.convert_process_buffer()\n",
    "        \n",
    "        # we initialize the NN exactly as before\n",
    "        self.agent.init_deep_q(curr_state)\n",
    "            \n",
    "        # some parameters have been move to a class named \"training_param\" for convenience\n",
    "        epsilon = training_param.INITIAL_EPSILON\n",
    "        # now the number of alive frames and total reward depends on the \"underlying environment\". It is vector instead\n",
    "        # of scalar\n",
    "        alive_frame = np.zeros(self.nb_process, dtype=np.int)\n",
    "        total_reward = np.zeros(self.nb_process, dtype=np.float)\n",
    "\n",
    "        with tqdm(total=num_frames) as pbar:\n",
    "            while observation_num < num_frames:\n",
    "                if observation_num % 1000 == 999:\n",
    "                    print((\"Executing loop %d\" %observation_num))\n",
    "                    # for efficient reading of data: at early stage of training, it is advised to load\n",
    "                    # data by chunk: the model will do game over pretty easily (no need to load all the dataset)\n",
    "                    tmp = min(10000 * (num_frames // observation_num), 10000)\n",
    "                    self.multi_envs.set_chunk_size(int(max(100, tmp)))\n",
    "\n",
    "                # Slowly decay the learning rate\n",
    "                if epsilon > training_param.FINAL_EPSILON:\n",
    "                    epsilon -= (training_param.INITIAL_EPSILON-training_param.FINAL_EPSILON)/training_param.EPSILON_DECAY\n",
    "\n",
    "                initial_state = self.convert_process_buffer()\n",
    "                self.process_buffer = [[] for _ in range(self.nb_process)]\n",
    "\n",
    "                # TODO vectorize that in the Agent directly\n",
    "                # then we need to predict the next moves. Agents have been adapted to predict a batch of data\n",
    "                pm_i, pq_v = self.agent.deep_q.predict_movement(curr_state, epsilon)\n",
    "                # and build the convenient vectors (it was scalars before)\n",
    "                predict_movement_int = []\n",
    "                predict_q_value = []\n",
    "                acts = []\n",
    "                for p_id in range(self.nb_process):\n",
    "                    predict_movement_int.append(pm_i[p_id])\n",
    "                    predict_q_value.append(pq_v[p_id])\n",
    "                    # and then we convert it to a valid action\n",
    "                    acts.append(self.agent.convert_act(pm_i[p_id]))\n",
    "\n",
    "                # same loop as in notebook 3\n",
    "                reward, done = np.zeros(self.nb_process), np.full(self.nb_process, fill_value=False, dtype=np.bool)\n",
    "                for i in range(training_param.NUM_FRAMES):\n",
    "                    temp_observation_obj, temp_reward, temp_done, _ = self.multi_envs.step(acts)\n",
    "\n",
    "                    # we need to handle vectors for \"done\"\n",
    "                    reward[~temp_done] += temp_reward[~temp_done]\n",
    "                    # and then \"de stack\" the observations coming from different environments\n",
    "                    for worker_id, obs in enumerate(temp_observation_obj):\n",
    "                        self.process_buffer[worker_id].append(self.agent.convert_obs(temp_observation_obj[worker_id])) \n",
    "                    done = done | temp_done\n",
    "\n",
    "                    # increase of 1 the number of frame alive for relevant \"underlying environments\"\n",
    "                    alive_frame[~temp_done] += 1\n",
    "                    # loop through the environment where a game over was done, and print the results\n",
    "                    for env_done_idx in np.where(temp_done)[0]:\n",
    "                        print(\"For env with id {}\".format(env_done_idx))\n",
    "                        print(\"\\tLived with maximum time \", alive_frame[env_done_idx])\n",
    "                        print(\"\\tEarned a total of reward equal to \", total_reward[env_done_idx])\n",
    "\n",
    "                    reward[temp_done] = 0.\n",
    "                    total_reward[temp_done] = 0.\n",
    "                    total_reward += reward\n",
    "                    alive_frame[temp_done] = 0\n",
    "\n",
    "                # vectorized version of the previous code\n",
    "                new_state = self.convert_process_buffer()\n",
    "                # same as before, but looping through the \"underlying environment\"\n",
    "                for sub_env_id in range(self.nb_process):\n",
    "                    self.agent.replay_buffer.add(initial_state[sub_env_id],\n",
    "                                                 predict_movement_int[sub_env_id],\n",
    "                                                 reward[sub_env_id],\n",
    "                                                 done[sub_env_id],\n",
    "                                                 new_state[sub_env_id])\n",
    "\n",
    "                if self.agent.replay_buffer.size() > training_param.MIN_OBSERVATION:\n",
    "                    s_batch, a_batch, r_batch, d_batch, s2_batch = self.agent.replay_buffer.sample(training_param.MINIBATCH_SIZE)\n",
    "                    isfinite = self.agent.deep_q.train(s_batch, a_batch, r_batch, d_batch, s2_batch, observation_num)\n",
    "                    self.agent.deep_q.target_train()\n",
    "\n",
    "                    if not isfinite:\n",
    "                        # if the loss is not finite i stop the learning\n",
    "                        print(\"ERROR INFINITE LOSS\")\n",
    "                        break\n",
    "\n",
    "\n",
    "                # Save the network every 10000 iterations\n",
    "                if observation_num % 10000 == 9999 or observation_num == num_frames-1:\n",
    "                    print(\"Saving Network\")\n",
    "                    if self.name is None:\n",
    "                        self.agent.deep_q.save_network(\"saved_notebook6.h5\")\n",
    "                    else:\n",
    "                        self.agent.deep_q.save_network(\"saved_notebook6_{}\".format(self.name))\n",
    "\n",
    "                observation_num += 1\n",
    "                pbar.update(1)\n",
    "            \n",
    "        if close_env:\n",
    "            print(\"closing env\")\n",
    "            self.env.close()\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We redifine the class used to train the agent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully constructed networks.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a9ca69ec05a8402ea5a1d140a8502e46",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For env with id 4\n",
      "\tLived with maximum time  6\n",
      "\tEarned a total of reward equal to  1062.252197265625\n",
      "For env with id 3\n",
      "\tLived with maximum time  10\n",
      "\tEarned a total of reward equal to  2167.105224609375\n",
      "For env with id 6\n",
      "\tLived with maximum time  12\n",
      "\tEarned a total of reward equal to  1000.6795654296875\n",
      "For env with id 1\n",
      "\tLived with maximum time  14\n",
      "\tEarned a total of reward equal to  3311.049072265625\n",
      "For env with id 7\n",
      "\tLived with maximum time  15\n",
      "\tEarned a total of reward equal to  -150.0\n",
      "For env with id 4\n",
      "\tLived with maximum time  10\n",
      "\tEarned a total of reward equal to  1053.3250732421875\n",
      "For env with id 2\n",
      "\tLived with maximum time  19\n",
      "\tEarned a total of reward equal to  2067.565185546875\n",
      "For env with id 4\n",
      "\tLived with maximum time  2\n",
      "\tEarned a total of reward equal to  1115.4794921875\n",
      "For env with id 6\n",
      "\tLived with maximum time  26\n",
      "\tEarned a total of reward equal to  952.8309326171875\n",
      "For env with id 4\n",
      "\tLived with maximum time  20\n",
      "\tEarned a total of reward equal to  2162.169921875\n",
      "For env with id 4\n",
      "\tLived with maximum time  2\n",
      "\tEarned a total of reward equal to  -20.0\n",
      "For env with id 0\n",
      "\tLived with maximum time  47\n",
      "\tEarned a total of reward equal to  785.864501953125\n",
      "For env with id 7\n",
      "\tLived with maximum time  39\n",
      "\tEarned a total of reward equal to  3232.6942138671875\n",
      "For env with id 3\n",
      "\tLived with maximum time  48\n",
      "\tEarned a total of reward equal to  2020.0274658203125\n",
      "For env with id 1\n",
      "\tLived with maximum time  50\n",
      "\tEarned a total of reward equal to  4354.7083740234375\n",
      "For env with id 1\n",
      "\tLived with maximum time  7\n",
      "\tEarned a total of reward equal to  1052.818603515625\n",
      "For env with id 2\n",
      "\tLived with maximum time  55\n",
      "\tEarned a total of reward equal to  4237.5467529296875\n",
      "For env with id 0\n",
      "\tLived with maximum time  28\n",
      "\tEarned a total of reward equal to  -280.0\n",
      "For env with id 5\n",
      "\tLived with maximum time  88\n",
      "\tEarned a total of reward equal to  33391.75183105469\n",
      "For env with id 1\n",
      "\tLived with maximum time  21\n",
      "\tEarned a total of reward equal to  960.6181640625\n",
      "For env with id 3\n",
      "\tLived with maximum time  37\n",
      "\tEarned a total of reward equal to  -370.0\n",
      "For env with id 6\n",
      "\tLived with maximum time  57\n",
      "\tEarned a total of reward equal to  12161.2880859375\n",
      "Saving Network\n",
      "Successfully saved network.\n",
      "\n",
      "closing env\n"
     ]
    }
   ],
   "source": [
    "agent_name = \"sac_1e5\"\n",
    "my_agent = DeepQAgent(env.action_space, mode=\"SAC\", training_param=TrainingParam())\n",
    "trainer = TrainAgentMultiEnv(agent=my_agent, env=env, nb_process=NUM_CORE, name=agent_name)\n",
    "# trainer = TrainAgent(agent=my_agent, env=env)\n",
    "trainer.train(TRAINING_STEP)\n",
    "trainer.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x1440 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.figure(figsize=(30,20))\n",
    "plt.plot(my_agent.deep_q.qvalue_evolution)\n",
    "plt.axhline(y=0, linewidth=3, color='red')\n",
    "_ = plt.xlim(0, len(my_agent.deep_q.qvalue_evolution))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A loss trained for 100000 iterations on 8 cores, for a ddqn agent and default parameters can look like:\n",
    "![](img/qvalue.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### II c) Assess the performance of the trained agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we evaluate the performance of a baseline, in this case the \"do nothing\" agent.\n",
    "\n",
    "**NB** The use of a Runner (see the first notebook) is particurlaly suited for that purpose. We are showing here how to quickly assess the performances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bf7d2f1a6cf84602bbad581f5f9dc5f1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, description='episode', max=2.0, style=ProgressStyle(description_width=…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bf760e0fc772490c9662f2876fa58e3f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='episode', max=1.0, style=ProgressStyle(…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7c8611fb0c2d49318dbaedfdf5d36cbc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='episode', max=1.0, style=ProgressStyle(…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "The results for the DoNothing agent are:\n",
      "\tFor chronics with id 000\n",
      "\t\t - cumulative reward: 122885.140625\n",
      "\t\t - number of time steps completed: 100 / 100\n",
      "\tFor chronics with id 001\n",
      "\t\t - cumulative reward: 122958.148438\n",
      "\t\t - number of time steps completed: 100 / 100\n"
     ]
    }
   ],
   "source": [
    "NB_EPISODE = 2\n",
    "max_iter = 100\n",
    "# tun the do nothing for the whole episode\n",
    "dn_agent = grid2op.Agent.DoNothingAgent(env.action_space)\n",
    "runner = Runner(**env.get_params_for_runner(), agentInstance=dn_agent, agentClass=None)\n",
    "res = runner.run(nb_episode=NB_EPISODE, max_iter=max_iter, pbar=tqdm)\n",
    "print(\"The results for the DoNothing agent are:\")\n",
    "for _, chron_id, cum_reward, nb_time_step, max_ts in res:\n",
    "    msg_tmp = \"\\tFor chronics with id {}\\n\".format(chron_id)\n",
    "    msg_tmp += \"\\t\\t - cumulative reward: {:.6f}\\n\".format(cum_reward)\n",
    "    msg_tmp += \"\\t\\t - number of time steps completed: {:.0f} / {:.0f}\".format(nb_time_step, max_ts)\n",
    "    print(msg_tmp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we load the saved neural network, and we can now evaluate the fixed policy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully constructed networks.\n",
      "Succesfully loaded network.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "50ad9742ff3f4863856407e5b16352c6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, description='episode', max=2.0, style=ProgressStyle(description_width=…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f2913a5679b74791ac30890815d2671f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='episode', max=1.0, style=ProgressStyle(…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8fb9ca66d4724478b892edbd871a67c8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='episode', max=1.0, style=ProgressStyle(…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "The results for the DoNothing agent are:\n",
      "\tFor chronics with id 000\n",
      "\t\t - cumulative reward: 122885.140625\n",
      "\t\t - number of time steps completed: 100 / 100\n",
      "\tFor chronics with id 001\n",
      "\t\t - cumulative reward: 122958.148438\n",
      "\t\t - number of time steps completed: 100 / 100\n"
     ]
    }
   ],
   "source": [
    "obs = env.reset()\n",
    "trained_agent = DeepQAgent(env.action_space, mode=\"DDQN\", training_param=TrainingParam())\n",
    "trained_agent.init_deep_q(trained_agent.convert_obs(obs))\n",
    "trained_agent.load_network(\"saved_notebook6_{}\".format(agent_name))\n",
    "runner = Runner(**env.get_params_for_runner(),\n",
    "                agentInstance=trained_agent, agentClass=None)\n",
    "res = runner.run(nb_episode=NB_EPISODE,\n",
    "                 max_iter=max_iter, pbar=tqdm)\n",
    "print(\"The results for the DoNothing agent are:\")\n",
    "for _, chron_id, cum_reward, nb_time_step, max_ts in res:\n",
    "    msg_tmp = \"\\tFor chronics with id {}\\n\".format(chron_id)\n",
    "    msg_tmp += \"\\t\\t - cumulative reward: {:.6f}\\n\".format(cum_reward)\n",
    "    msg_tmp += \"\\t\\t - number of time steps completed: {:.0f} / {:.0f}\".format(nb_time_step, max_ts)\n",
    "    print(msg_tmp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A default DDQN agent trained on 8 cores on 1000000 steps (so 8e6 steps in total), 24h of training on a laptop achieved to perform 5637 steps, largely outperforming the \"do nothing\" agent (which did only 2180 steps on the same 2 environment)."
   ]
  }
 ],
 "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}