{
 "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": [
    {
     "data": {
      "text/html": [
       "<div id=\"my_id_menu_nb\">run previous cell, wait for 2 seconds</div>\n",
       "<script>\n",
       "function repeat_indent_string(n){\n",
       "    var a = \"\" ;\n",
       "    for ( ; n > 0 ; --n)\n",
       "        a += \"    \";\n",
       "    return a;\n",
       "}\n",
       "// look up into all sections and builds an automated menu //\n",
       "var update_menu_string = function(begin, lfirst, llast, sformat, send, keep_item, begin_format, end_format) {\n",
       "    var anchors = document.getElementsByClassName(\"section\");\n",
       "    if (anchors.length == 0) {\n",
       "        anchors = document.getElementsByClassName(\"text_cell_render rendered_html\");\n",
       "    }\n",
       "    var i,t;\n",
       "    var text_menu = begin;\n",
       "    var text_memo = \"<pre>\\nlength:\" + anchors.length + \"\\n\";\n",
       "    var ind = \"\";\n",
       "    var memo_level = 1;\n",
       "    var href;\n",
       "    var tags = [];\n",
       "    var main_item = 0;\n",
       "    var format_open = 0;\n",
       "    for (i = 0; i <= llast; i++)\n",
       "        tags.push(\"h\" + i);\n",
       "\n",
       "    for (i = 0; i < anchors.length; i++) {\n",
       "        text_memo += \"**\" + anchors[i].id + \"--\\n\";\n",
       "\n",
       "        var child = null;\n",
       "        for(t = 0; t < tags.length; t++) {\n",
       "            var r = anchors[i].getElementsByTagName(tags[t]);\n",
       "            if (r.length > 0) {\n",
       "child = r[0];\n",
       "break;\n",
       "            }\n",
       "        }\n",
       "        if (child == null) {\n",
       "            text_memo += \"null\\n\";\n",
       "            continue;\n",
       "        }\n",
       "        if (anchors[i].hasAttribute(\"id\")) {\n",
       "            // when converted in RST\n",
       "            href = anchors[i].id;\n",
       "            text_memo += \"#1-\" + href;\n",
       "            // passer à child suivant (le chercher)\n",
       "        }\n",
       "        else if (child.hasAttribute(\"id\")) {\n",
       "            // in a notebook\n",
       "            href = child.id;\n",
       "            text_memo += \"#2-\" + href;\n",
       "        }\n",
       "        else {\n",
       "            text_memo += \"#3-\" + \"*\" + \"\\n\";\n",
       "            continue;\n",
       "        }\n",
       "        var title = child.textContent;\n",
       "        var level = parseInt(child.tagName.substring(1,2));\n",
       "\n",
       "        text_memo += \"--\" + level + \"?\" + lfirst + \"--\" + title + \"\\n\";\n",
       "\n",
       "        if ((level < lfirst) || (level > llast)) {\n",
       "            continue ;\n",
       "        }\n",
       "        if (title.endsWith('¶')) {\n",
       "            title = title.substring(0,title.length-1).replace(\"<\", \"&lt;\")\n",
       "         .replace(\">\", \"&gt;\").replace(\"&\", \"&amp;\");\n",
       "        }\n",
       "        if (title.length == 0) {\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        while (level < memo_level) {\n",
       "            text_menu += end_format + \"</ul>\\n\";\n",
       "            format_open -= 1;\n",
       "            memo_level -= 1;\n",
       "        }\n",
       "        if (level == lfirst) {\n",
       "            main_item += 1;\n",
       "        }\n",
       "        if (keep_item != -1 && main_item != keep_item + 1) {\n",
       "            // alert(main_item + \" - \" + level + \" - \" + keep_item);\n",
       "            continue;\n",
       "        }\n",
       "        while (level > memo_level) {\n",
       "            text_menu += \"<ul>\\n\";\n",
       "            memo_level += 1;\n",
       "        }\n",
       "        text_menu += repeat_indent_string(level-2);\n",
       "        text_menu += begin_format + sformat.replace(\"__HREF__\", href).replace(\"__TITLE__\", title);\n",
       "        format_open += 1;\n",
       "    }\n",
       "    while (1 < memo_level) {\n",
       "        text_menu += end_format + \"</ul>\\n\";\n",
       "        memo_level -= 1;\n",
       "        format_open -= 1;\n",
       "    }\n",
       "    text_menu += send;\n",
       "    //text_menu += \"\\n\" + text_memo;\n",
       "\n",
       "    while (format_open > 0) {\n",
       "        text_menu += end_format;\n",
       "        format_open -= 1;\n",
       "    }\n",
       "    return text_menu;\n",
       "};\n",
       "var update_menu = function() {\n",
       "    var sbegin = \"\";\n",
       "    var sformat = '<a href=\"#__HREF__\">__TITLE__</a>';\n",
       "    var send = \"\";\n",
       "    var begin_format = '<li>';\n",
       "    var end_format = '</li>';\n",
       "    var keep_item = -1;\n",
       "    var text_menu = update_menu_string(sbegin, 2, 4, sformat, send, keep_item,\n",
       "       begin_format, end_format);\n",
       "    var menu = document.getElementById(\"my_id_menu_nb\");\n",
       "    menu.innerHTML=text_menu;\n",
       "};\n",
       "window.setTimeout(update_menu,2000);\n",
       "            </script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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",
    "import sys\n",
    "import os\n",
    "import numpy as np\n",
    "TRAINING_STEP = 10"
   ]
  },
  {
   "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": [
    "## II) 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": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please read the above cell, it appears you don't have downloaded the dataset, or save it into an unknown repository. I will continue with only 2 sets.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/donnotben/Documents/Grid2Op_dev/getting_started/grid2op/MakeEnv.py:667: UserWarning:\n",
      "\n",
      "Your are using only 2 chronics for this environment. More can be download by running, from a command line:\n",
      "python -m grid2op.download --name \"case14_realistic\" --path_save PATH\\WHERE\\YOU\\WANT\\TO\\DOWNLOAD\\DATA\n",
      "\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    env = grid2op.make(name_env=\"case14_realistic\",\n",
    "                       chronics_path=os.path.expanduser(\"~/data_grid2op/case14_realistic\"))\n",
    "except Exception as exc :\n",
    "    print(\"Please read the above cell, it appears you don't have downloaded the dataset, \"\\\n",
    "          \"or save it into an unknown repository. \" \\\n",
    "          \"I will continue with only 2 sets.\")\n",
    "    env = grid2op.make(name_env=\"case14_realistic\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## III) 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.Observation.CompleteObservation.CompleteObservation object at 0x7f269e06b710>,\n",
       "       <grid2op.Observation.CompleteObservation.CompleteObservation object at 0x7f269e06b8d0>,\n",
       "       <grid2op.Observation.CompleteObservation.CompleteObservation object at 0x7f269e06b940>,\n",
       "       <grid2op.Observation.CompleteObservation.CompleteObservation object at 0x7f269e06bf98>,\n",
       "       <grid2op.Observation.CompleteObservation.CompleteObservation object at 0x7f269e06b908>,\n",
       "       <grid2op.Observation.CompleteObservation.CompleteObservation object at 0x7f269e06be10>,\n",
       "       <grid2op.Observation.CompleteObservation.CompleteObservation object at 0x7f269e06b860>,\n",
       "       <grid2op.Observation.CompleteObservation.CompleteObservation object at 0x7f26e5114fd0>],\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.Observation.CompleteObservation.CompleteObservation object at 0x7f26e511a8d0>,\n",
       "       <grid2op.Observation.CompleteObservation.CompleteObservation object at 0x7f26e511af98>,\n",
       "       <grid2op.Observation.CompleteObservation.CompleteObservation object at 0x7f26e511afd0>,\n",
       "       <grid2op.Observation.CompleteObservation.CompleteObservation object at 0x7f26e5124278>,\n",
       "       <grid2op.Observation.CompleteObservation.CompleteObservation object at 0x7f26e511af28>,\n",
       "       <grid2op.Observation.CompleteObservation.CompleteObservation object at 0x7f26e5124080>,\n",
       "       <grid2op.Observation.CompleteObservation.CompleteObservation object at 0x7f26e511af60>,\n",
       "       <grid2op.Observation.CompleteObservation.CompleteObservation object at 0x7f26e51242b0>],\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(TRAINING_STEP):\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 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",
    "        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",
    "            \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": "stderr",
     "output_type": "stream",
     "text": [
      "/home/donnotben/Documents/Grid2Op_dev/getting_started/grid2op/MakeEnv.py:667: UserWarning:\n",
      "\n",
      "Your are using only 2 chronics for this environment. More can be download by running, from a command line:\n",
      "python -m grid2op.download --name \"case14_realistic\" --path_save PATH\\WHERE\\YOU\\WANT\\TO\\DOWNLOAD\\DATA\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/donnotben/.local/lib/python3.6/site-packages/tensorflow/python/ops/resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From /home/donnotben/.local/lib/python3.6/site-packages/tensorflow/python/keras/utils/losses_utils.py:170: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n",
      "Successfully constructed networks.\n",
      "For env with id 1\n",
      "\tLived with maximum time  0\n",
      "\tEarned a total of reward equal to  0.0\n",
      "For env with id 2\n",
      "\tLived with maximum time  2\n",
      "\tEarned a total of reward equal to  2173.7099096977045\n",
      "For env with id 4\n",
      "\tLived with maximum time  2\n",
      "\tEarned a total of reward equal to  2173.7099096977045\n",
      "For env with id 6\n",
      "\tLived with maximum time  2\n",
      "\tEarned a total of reward equal to  2173.7099096977045\n",
      "For env with id 0\n",
      "\tLived with maximum time  3\n",
      "\tEarned a total of reward equal to  3262.123313523708\n",
      "WARNING:tensorflow:From /home/donnotben/.local/lib/python3.6/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n",
      "For env with id 2\n",
      "\tLived with maximum time  6\n",
      "\tEarned a total of reward equal to  6586.890989316329\n",
      "Saving Network\n",
      "Successfully saved network.\n",
      "closing env\n"
     ]
    }
   ],
   "source": [
    "agent_name = \"sac_1e5\"\n",
    "try:\n",
    "    env = grid2op.make(\"case14_realistic\",\n",
    "                       chronics_path = os.path.expanduser(\"~/data_grid2op/case14_realistic\")\n",
    "                      )\n",
    "except:\n",
    "    env = grid2op.make(\"case14_realistic\")\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)"
   ]
  },
  {
   "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": [
    "### III 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": "c35c1968cd1e48d094f55f3fa9f291c9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, description='do nothing', style=ProgressStyle(description_width='initi…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Time last by Do Nothing: 100\n"
     ]
    }
   ],
   "source": [
    "from tqdm.notebook import tqdm\n",
    "NB_EPISODE = 2\n",
    "nrow = 100  # 12*24*7*4*NB_EPISODE\n",
    "# tun the do nothing for the whole episode\n",
    "dn_agent = grid2op.Agent.DoNothingAgent(env.action_space)\n",
    "\n",
    "reward = env.reward_range[0]\n",
    "env.set_id(0)\n",
    "i = 0\n",
    "with tqdm(total=nrow, desc=\"do nothing\") as pbar:\n",
    "    for _ in range(NB_EPISODE):\n",
    "        obs = env.reset()\n",
    "        done= False\n",
    "        while not done:\n",
    "            act = dn_agent.act(obs, reward, done)\n",
    "            obs, reward, done, info = env.step(act)\n",
    "            i += 1\n",
    "            pbar.update(1)\n",
    "            if i >= nrow-1:\n",
    "                break\n",
    "print(\"Time last by Do Nothing: {}\".format(i))"
   ]
  },
  {
   "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": "a9315e6106be4219ace8622f0f3e2e40",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, description='trained agent', style=ProgressStyle(description_width='in…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Time last by the trained agent: 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",
    "\n",
    "reward = env.reward_range[0]\n",
    "env.set_id(0)\n",
    "i = 0\n",
    "with tqdm(total=nrow, desc=\"trained agent\") as pbar:\n",
    "    for _ in range(NB_EPISODE):\n",
    "        obs = env.reset()\n",
    "        done= False\n",
    "        while not done:\n",
    "            act = trained_agent.act(obs, reward, done)\n",
    "            obs, reward, done, info = env.step(act)\n",
    "            i += 1\n",
    "            pbar.update(1)\n",
    "            if i >= nrow-1:\n",
    "                break\n",
    "print(\"Time last by the trained agent: {}\".format(i))"
   ]
  },
  {
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}