The Benchmarking platforme (Preliminary version)

Author: Mleyliabadi

.gitignore

@@ -127,3 +127,11 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+#custom ignore folders
+.vscode
+lips/Outputs/Scenario1/Data/*
+lips/Outputs/Scenario1/Benchmarks/*
+lips/Outputs/Scenario1_old
+lips/Outputs/Scenario2
+lips/Outputs/Scenario5

AUTHORS.txt

@@ -0,0 +1,6 @@
+Lead author :
+Milad LEYLI ABADI
+
+other contributors : 
+Benjamin Donnot
+Jérôme Picault

Notebook_Benchmark1.ipynb

@@ -0,0 +1,51 @@
+import numpy as np
+import grid2op
+from grid2op.Agent import BaseAgent
+
+class AgentTC1(BaseAgent):
+    """
+    The Topological Change One (TC1) agent will randomly switch the buses of one of the indicated elements. 
+    Only one substation is affected by the topological action returned after each call to the act function.
+    Contrary to RandomTC1, it does not reconnect the elements which are not affected by the topological change
+    to the first bus !
+
+    params
+    ______
+        action_space : Grid2op ``Environment`` ``action_space``
+
+        subsid_list : ``list``
+            a list of substation identifiers for which we would perform topological changes
+
+
+    """
+    def __init__(self, action_space, subsid_list):
+        super(AgentTC1, self).__init__(action_space)
+        if not "set_bus" in action_space.subtype.authorized_keys:
+            raise NotImplementedError("Impossible to have a TopoChange agent if you cannot set the bus")
+        #self.subsid_list = [1,3,4,5,8,12] 
+        
+        self.act_space = grid2op.Converter.IdToAct(action_space)
+        # generate only "set_topo" type of actions
+        self.act_space.init_converter(set_line_status=False, change_line_status=False, change_bus_vect=False, redispatch=False)
+        
+        # filter only the action at the relevant substations
+        def filter_fun(g2op_act):
+            l_imp, s_imp = g2op_act.get_topological_impact()
+            res = False
+            if np.any(s_imp[subsid_list]):
+                res = True
+            return res
+        
+        self.act_space.filter_action(filter_fun)
+
+        self.bus_switch_action_space_as_list = []
+        # generate bus switching actions that impact only one substation.
+        for act_ in self.act_space.all_actions:
+            self.bus_switch_action_space_as_list.append(act_)
+        self.actions_size = len(self.bus_switch_action_space_as_list)
+
+    def act(self, obs, reward, done):
+        # select and return randomly an action (at one substation) in the topological action list
+        id_ = self.space_prng.choice(self.actions_size)
+        # adding the reset action with an action which will change the buses at one substation
+        return self.bus_switch_action_space_as_list[id_]

img/Benchmarking.png

@@ -0,0 +1,72 @@
+import numpy as np
+import grid2op
+from grid2op.Agent import BaseAgent
+
+class AgentTC2(BaseAgent):
+    """
+    The Topological Change Two (TC2) agent will randomly switch the buses of two of the indicated elements. 
+    Two substations are affected by the topological action returned after each call to the act function.
+    Contrary to RandomTC2, it does not reconnect the elements which are not affected by the topological change
+    to the first bus !
+
+    params
+    ______
+        action_space : Grid2op ``Environment`` ``action_space``
+
+        subsid_list : ``list``
+            a list of substation identifiers for which we would perform topological changes
+
+    returns
+    -------
+        action : Grid2Op ``action``
+            an action which modifies the topology configuration of the network
+
+
+    """
+    def __init__(self, action_space, subsid_list):
+        super(AgentTC2, self).__init__(action_space)
+        if not "set_bus" in action_space.subtype.authorized_keys:
+            raise NotImplementedError("Impossible to have a TopoChange agent if you cannot set the bus vector")
+        #self.subsid_list = [1,3,4,5,8,12] 
+        
+        self.act_space = grid2op.Converter.IdToAct(action_space)
+        # generate only "set_topo" type of actions
+        self.act_space.init_converter(set_line_status=False, change_line_status=False, change_bus_vect=False, redispatch=False)
+        
+        # filter only the action at the relevant substations
+        def filter_fun(g2op_act):
+            l_imp, s_imp = g2op_act.get_topological_impact()
+            res = False
+            if np.any(s_imp[subsid_list]):
+                res = True
+            return res
+        
+        self.act_space.filter_action(filter_fun)
+
+        self.bus_switch_action_space_as_list = []
+        
+        for act1 in self.act_space.all_actions:
+            _, s_imp1 = act1.get_topological_impact()
+            s_id1 = np.where(s_imp1)[0]
+            if not s_id1:
+                # this is the do nothing action
+                continue
+            for act2 in self.act_space.all_actions:
+                _, s_imp2 = act2.get_topological_impact()
+                s_id2 = np.where(s_imp2)[0]
+                if not s_id2:
+                    # this is the do nothing action
+                    continue
+                if s_id2 <= s_id1: # To avoid duplicate actions.
+                    continue
+    
+                act_saved = action_space()
+                act_saved += act1
+                act_saved += act2
+                self.bus_switch_action_space_as_list.append(act_saved)
+        self.actions_size = len(self.bus_switch_action_space_as_list)
+
+    def act(self, obs, reward, done):
+        # select and return randomly an action (at two substations) in the topological action list
+        id_ = self.space_prng.choice(self.actions_size)
+        return self.bus_switch_action_space_as_list[id_]

img/Benchmarking_scheme.png

@@ -0,0 +1,42 @@
+from grid2op.Agent.BaseAgent import BaseAgent
+
+
+class DoNothingAgent(BaseAgent):
+    """
+    This is the most basic BaseAgent. It is purely passive, and does absolutely nothing.
+
+    As opposed to most reinforcement learning environments, in grid2op, doing nothing is often
+    the best solution.
+
+    """
+    def __init__(self, action_space):
+        BaseAgent.__init__(self, action_space)
+
+    def act(self, observation, reward, done=False):
+        """
+        As better explained in the document of :func:`grid2op.BaseAction.update` or
+        :func:`grid2op.BaseAction.ActionSpace.__call__`.
+
+        The preferred way to make an object of type action is to call :func:`grid2op.BaseAction.ActionSpace.__call__`
+        with the dictionary representing the action. In this case, the action is "do nothing" and it is represented by
+        the empty dictionary.
+
+        Parameters
+        ----------
+        observation: :class:`grid2op.Observation.Observation`
+            The current observation of the :class:`grid2op.Environment.Environment`
+
+        reward: ``float``
+            The current reward. This is the reward obtained by the previous action
+
+        done: ``bool``
+            Whether the episode has ended or not. Used to maintain gym compatibility
+
+        Returns
+        -------
+        res: :class:`grid2op.Action.Action`
+            The action chosen by the bot / controller / agent.
+
+        """
+        res = self.action_space({})
+        return res

img/DataGeneration.png

@@ -0,0 +1,37 @@
+# Copyright (c) 2019-2020, RTE (https://www.rte-france.com)
+# See AUTHORS.txt
+# This Source Code Form is subject to the terms of the Mozilla Public License, version 2.0.
+# If a copy of the Mozilla Public License, version 2.0 was not distributed with this file,
+# you can obtain one at http://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+# This file is part of leap_net, leap_net a keras implementation of the LEAP Net model.
+
+import numpy as np
+from grid2op.Agent import BaseAgent
+from grid2op.dtypes import dt_int, dt_float
+
+
+class RandomN1(BaseAgent):
+    """
+    This "agent" will randomly disconnect exactly 1 powerline from the grid.
+
+    **NB** Every powerline that is not chosen at random to be disconnected will be reconnected by force.
+    """
+
+    def __init__(self, action_space):
+        super(RandomN1, self).__init__(action_space)
+        if not "set_line_status" in action_space.subtype.authorized_keys:
+            raise NotImplementedError("Impossible to have a RandomN1 agent if you cannot set the status or powerline")
+
+        # represent the action "exactly one powerline is disconnected
+        self.powerline_actions = 1 - 2 * np.eye(action_space.n_line, dtype=dt_int)
+
+    def act(self, obs, reward, done):
+        id_ = self.space_prng.choice(self.action_space.n_line)
+        arr_ = self.powerline_actions[id_, :]
+        li_bus = [(i, el) for i, el in enumerate(arr_)]
+        return self.action_space({"set_line_status": arr_,
+                                  "set_bus": {"lines_or_id": li_bus,
+                                              "lines_ex_id": li_bus},
+                                  }
+                                 )

img/Evaluation.png

@@ -0,0 +1,47 @@
+# Copyright (c) 2019-2020, RTE (https://www.rte-france.com)
+# See AUTHORS.txt
+# This Source Code Form is subject to the terms of the Mozilla Public License, version 2.0.
+# If a copy of the Mozilla Public License, version 2.0 was not distributed with this file,
+# you can obtain one at http://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+# This file is part of leap_net, leap_net a keras implementation of the LEAP Net model.
+
+import numpy as np
+from grid2op.Agent import BaseAgent
+from grid2op.dtypes import dt_int, dt_float
+
+
+class RandomN2(BaseAgent):
+    """
+    This "agent" will randomly disconnect exactly 1 powerline from the grid.
+
+    **NB** Every powerline that is not chosen at random to be disconnected will be reconnected by force.
+
+    This agent will modify the status of all powerlines at every steps!
+    """
+
+    def __init__(self, action_space):
+        super(RandomN2, self).__init__(action_space)
+        if not "set_line_status" in action_space.subtype.authorized_keys:
+            raise NotImplementedError("Impossible to have a RandomN1 agent if you cannot set the status or powerline")
+
+        # represent the action "exactly one powerline is disconnected
+        self.powerline_actions = np.ones(action_space.n_line, dtype=dt_int)
+        self.tmp_arr = np.ones(action_space.n_line, dtype=dt_int)
+
+    def act(self, obs, reward, done):
+        id_1 = self.space_prng.choice(self.action_space.n_line)
+        id_2 = self.space_prng.choice(self.action_space.n_line - 1)
+        if id_2 >= id_1:
+            # this procedure is to be sure not to "disconnect twice" the same powerline
+            id_2 += 1
+        self.tmp_arr[:] = self.powerline_actions
+        self.tmp_arr[id_1] = -1
+        self.tmp_arr[id_2] = -1
+        li_bus = [(i, el) for i, el in enumerate(self.tmp_arr)]
+        act = self.action_space({"set_line_status": self.tmp_arr,
+                                 "set_bus": {"lines_or_id": li_bus,
+                                             "lines_ex_id": li_bus},
+                                 }
+                                )
+        return act

lips/__init__.py

@@ -0,0 +1,48 @@
+# Copyright (c) 2019-2020, RTE (https://www.rte-france.com)
+# See AUTHORS.txt
+# This Source Code Form is subject to the terms of the Mozilla Public License, version 2.0.
+# If a copy of the Mozilla Public License, version 2.0 was not distributed with this file,
+# you can obtain one at http://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+# This file is part of leap_net, leap_net a keras implementation of the LEAP Net model.
+
+import numpy as np
+from grid2op.Agent import BaseAgent
+from grid2op.dtypes import dt_int, dt_float
+import pdb
+
+
+class RandomNN1(BaseAgent):
+    """
+    This "agent" will randomly disconnect 0 or 1 powerline with probability 1-p to disconnect 1 powerline
+    and with probability p to disconnect randomly one powerline.
+    
+    **NB** the output distribution is heavily biased: all the powerline are connected with proba `1-p`, but if you
+    consider the odds of having powerline line `l` disconnected it's equal to `p / (nb_line)`.
+    """
+    def __init__(self, action_space, p):
+        super(RandomNN1, self).__init__(action_space)
+        if not "set_line_status" in action_space.subtype.authorized_keys:
+            raise NotImplementedError("Impossible to have a RandomN1 agent if you cannot set the status or powerline")
+        if p <= 0.:
+            raise RuntimeError("Impossible to have p lower than 0.")
+        self.p = dt_float(p)
+        self._1_p = 1. - self.p
+        # represent the action "no powerline are disconnected
+        self.reset_all = np.ones(action_space.n_line, dtype=dt_int)
+        # represent the action "exactly one powerline is disconnected
+        self.powerline_actions = 1 - 2*np.eye(action_space.n_line, dtype=dt_int)
+
+    def act(self, obs, reward, done):
+        ur = self.space_prng.uniform()
+        if ur < self._1_p:
+            arr_ = self.reset_all
+        else:
+            id_ = self.space_prng.choice(self.action_space.n_line)
+            arr_ = self.powerline_actions[id_, :]
+        li_bus = [(i, el) for i, el in enumerate(arr_)]
+        act = self.action_space({"set_line_status": arr_,
+                                 "set_bus": {"lines_or_id": li_bus,
+                                             "lines_ex_id": li_bus},
+                                 })
+        return act

lips/agents/AgentTC1.py

@@ -0,0 +1,44 @@
+import numpy as np
+import grid2op
+from grid2op.Agent import BaseAgent
+
+class RandomTC1(BaseAgent):
+    """
+    This agent will randomly switch the buses of some indicated elements. 
+    Only one substation is affected by the topological action returned after each call to the act function.
+    Contrary to the previous version, it will also ensure that all the elements are connected to the first bus before performing a new action
+    """
+    def __init__(self, action_space, subsid_list):
+        super(RandomTC1, self).__init__(action_space)
+        if not "set_bus" in action_space.subtype.authorized_keys:
+            raise NotImplementedError("Impossible to have a TopoChange agent if you cannot set the bus")
+        #self.subsid_list = [1,3,4,5,8,12] 
+        
+        # reset all the connections and connect all the elements to bus 1
+        self.set_buses = action_space({"set_bus": [(i,1) for i in range(action_space.dim_topo)]})
+        
+        self.act_space = grid2op.Converter.IdToAct(action_space)
+        # generate only "set_topo" type of actions
+        self.act_space.init_converter(set_line_status=False, change_line_status=False, change_bus_vect=False, redispatch=False)
+        
+        # filter only the action at the relevant substations
+        def filter_fun(g2op_act):
+            l_imp, s_imp = g2op_act.get_topological_impact()
+            res = False
+            if np.any(s_imp[subsid_list]):
+                res = True
+            return res
+        
+        self.act_space.filter_action(filter_fun)
+
+        self.bus_switch_action_space_as_list = []
+        # generate bus switching actions that impact only one substation.
+        for act_ in self.act_space.all_actions:
+            self.bus_switch_action_space_as_list.append(act_)
+        self.actions_size = len(self.bus_switch_action_space_as_list)
+
+    def act(self, obs, reward, done):
+        # select and return randomly an action (at one substation) in the topological action list
+        id_ = self.space_prng.choice(self.actions_size)
+        # adding the reset action with an action which will change the buses at one substation
+        return self.set_buses + self.bus_switch_action_space_as_list[id_]