Ml wip upgrade tests (#114)

* Setup file updated with sections for test and doc

* circleci config updated wrt updates in setup

* grid2op and lightsim versions updated

* setup package lists updated

* Am accelerated tau transform (#113)

* providing a faster transform_tau method if topologies are given in list

* adding back test for leap_net, accelerated_tau_transform especially

* Delete Test_extract_tau.py

* Update leap_net.py

* adding a warning for a probably very rare case that should later be able to deal with

* Update leap_net.py

* typo in variable name, tau instead of extract_tau

* no need to scale topo_vect as values revolve around 1, that it is about categorical variables, and that it is re-encoded afterwards

Co-authored-by: marota <antoine-marot@live.fr>

Author: Mleyliabadi

.circleci/config.yml

@@ -2,7 +2,7 @@ version: 2.1
 
 references:
   dep_key: &dep_key
-              deps2-{{ .Branch }}-{{ checksum "requirements.txt" }}
+              deps4-{{ .Branch }}-{{ checksum "requirements.txt" }}
 
 executors:
   docker-executor:
@@ -23,18 +23,8 @@ commands:
             python3 -m venv venv
             . venv/bin/activate
             pip install --upgrade pip
-            pip install -r requirements.txt
-            pip install -U .
-            pip install pytest
+            pip install -U .[test]
             pip install nbmake pytest-xdist
-            pip install ipykernel
-            pip install pylint
-            pip install pylint-exit
-            pip install jupytext --upgrade
-            pip install sphinx
-            pip install sphinx-rtd-theme
-            pip install sphinxcontrib_trio
-            pip install autodocsumm
       - change_owner
       - save_cache_dep
 
@@ -206,14 +196,6 @@ workflows:
             ignore:
               - gh-pages
 
-    - run_pylint:
-        requires:
-          - build_dep
-        filters:
-          branches:
-            ignore:
-              - gh-pages
-
     - run_notebook_test:
         requires:
           - run_python_tests

lips/augmented_simulators/tensorflow_models/leap_net.py

@@ -13,6 +13,7 @@
 from typing import Union
 import json
 import warnings
+import copy
 
 import numpy as np
 
@@ -25,12 +26,12 @@
 except ImportError as err:
     raise RuntimeError("You need to install the leap_net package to use this class") from err
 
-
 from ..tensorflow_simulator import TensorflowSimulator
 from ...logger import CustomLogger
 from ...config import ConfigManager
 from ...dataset import DataSet
 from ...dataset.scaler import Scaler
+import tensorflow as tf
 
 
 class LeapNet(TensorflowSimulator):
@@ -97,6 +98,8 @@ def __init__(self,
         # model parameters
         self.params = self.sim_config.get_options_dict()
         self.params.update(kwargs)
+        self.attr_tau=kwargs['attr_tau']
+
         # optimizer
         # optimizer
         if "optimizer" in kwargs:
@@ -122,7 +125,7 @@ def _create_proxy(self):
             train_batch_size=self.params["train_batch_size"],
             attr_x=self.bench_config.get_option("attr_x"),
             attr_y=self.bench_config.get_option("attr_y"),
-            attr_tau=self.bench_config.get_option("attr_tau"),
+            attr_tau=self.attr_tau,#self.bench_config.get_option("attr_tau"),
             sizes_enc=self.params["sizes_enc"],
             sizes_main=self.params["sizes_main"],
             sizes_out=self.params["sizes_out"],
@@ -137,6 +140,7 @@ def _create_proxy(self):
             scale_input_dec_layer=self.params["scale_input_dec_layer"],  # scale the input of the decoder
             scale_input_enc_layer=self.params["scale_input_enc_layer"],  # scale the input of the encoder
             layer_act=self.params["activation"]
+
         )
 
     def process_dataset(self, dataset: DataSet, training: bool=False) -> tuple:
@@ -169,14 +173,25 @@ def process_dataset(self, dataset: DataSet, training: bool=False) -> tuple:
                 (extract_x, extract_tau), extract_y = self.scaler.fit_transform(dataset)
             else:
                 (extract_x, extract_tau), extract_y = dataset.extract_data(concat=False)
-            extract_tau = self._transform_tau(dataset, extract_tau)
+
         else:
             if self.scaler is not None:
                 (extract_x, extract_tau), extract_y = self.scaler.transform(dataset)
             else:
                 (extract_x, extract_tau), extract_y = dataset.extract_data(concat=False)
+
+
+
+        is_given_topo_list = (len(self._leap_net_model.kwargs_tau) >= 1)
+        if (is_given_topo_list):
+            extract_tau = self._transform_tau_given_list(extract_tau)
+        else:
             extract_tau = self._transform_tau(dataset, extract_tau)
 
+        #if len(self._leap_net_model.attr_tau) > 1 :
+        #   extract_tau = np.concatenate((extract_tau[0], extract_tau[1]), axis=1)
+
+
         return (extract_x, extract_tau), extract_y
 
     def _post_process(self, dataset, predictions):
@@ -206,6 +221,76 @@ def _transform_tau(self, dataset, tau):
                             dtype=np.float32))
         return tau
 
+    def _transform_tau_given_list(self, tau,with_tf=True):
+        """Transform only the tau vector with respect to LeapNet encodings given a list of predefined topological actions
+                Parameters
+        ----------
+        tau : list of raw topology representations (line_status, topo_vect)
+
+        with_tf : transformation using tensorflow or numpy operations
+
+        Returns
+        -------
+        tau
+            list of encoded topology representations (line_status, topo_vect_encoded)
+        """
+        ##############
+        #WARNING: TO DO
+        # if we find two topology matches at a same substation, the current code attribute one bit for each
+        # But only one should be choosen in the end (we are not in a quantum state, or it does not make sense to combine topologies at a same substation in the encoding here
+        #This can happen when there are several lines disconnected at a substation on which we changed the topology, probably in benchmark 3, but probably not in benchmark 1 and 2
+
+        subs_index=self._leap_net_model.subs_index
+
+        list_topos=[]
+        sub_length=[]
+        for topo_action in self._leap_net_model.kwargs_tau:
+            topo_vect = np.zeros(tau[1].shape[1], dtype=np.int32)
+            sub_id=topo_action[0]
+            sub_topo=np.array(topo_action[1])
+            sub_index=subs_index[sub_id][0]
+            n_elements=len(sub_topo)
+            topo_vect[sub_index:sub_index+n_elements]=sub_topo
+            list_topos.append(topo_vect)
+            sub_length.append(n_elements)
+
+        list_topos=np.array(list_topos)
+
+        #we are here looking for the number of matches for every element of a substation topology in the predefined list for a new topo_vect observation
+        #if the count is equal to the number of element, then the predefined topology is present in topo_vect observation
+        #in that case, the binary encoding of that predefined topology is equal to 1, otherwise 0
+        if with_tf:
+            #count the number of disconnected lines for each substation of topologies in the prefdefined list.
+            #These lines could have been connected to either bus_bar1 or bus_bar2, we consider it as a match for that element
+            line_disconnected_sub = tf.linalg.matmul((list_topos >0).astype(np.int32),(np.transpose(tau[1]) < 0).astype(np.int32))
+
+            #we look at the number of elements on bus_bar1 that match, same for the number of elements on bus_bar2
+            match_tensor_bus_bar1=tf.linalg.matmul((list_topos==1).astype(np.int32),(np.transpose(tau[1])==1).astype(np.int32))
+            match_tensor_bus_bar2 =tf.linalg.matmul((list_topos==2).astype(np.int32), (np.transpose(tau[1])==2).astype(np.int32))
+
+            #the number of matches is equal to the sum of those 3 category of matches
+            match_tensor_adjusted=match_tensor_bus_bar1+match_tensor_bus_bar2+line_disconnected_sub
+
+            #we see if all elements match by dividing by the number of elements. If this proportion is equal to one, we found a topology match
+            normalised_tensor = match_tensor_adjusted / tf.reshape(np.array(sub_length).astype(np.int32), (-1, 1))
+
+        else:#with_numpy
+
+            line_disconnected_sub = np.matmul((list_topos >0),1*(np.transpose(tau[1]) < 0))
+
+            match_tensor_bus_bar1=np.matmul((list_topos==1),1*(np.transpose(tau[1])==1))
+            match_tensor_bus_bar2 =np.matmul((list_topos==2), 1*(np.transpose(tau[1])==2))
+
+            match_tensor_adjusted=match_tensor_bus_bar1+match_tensor_bus_bar2+line_disconnected_sub
+
+            normalised_tensor = match_tensor_adjusted / np.array(sub_length).reshape((-1, 1))
+
+        boolean_match_tensor = np.array(normalised_tensor == 1.0).astype(np.int8)
+
+        tau[1]=np.transpose(boolean_match_tensor)
+        return tau
+
+
     def _make_fake_obs(self, dataset: DataSet):
         """
         the underlying _leap_net_model requires some 'class' structure to work properly. This convert the
@@ -245,8 +330,9 @@ def write_history(self, history):
 
         self.train_losses = hist["loss"]
         self.val_losses = hist["val_loss"]
+        metrics=self.params["metrics"]
 
-        for metric in ["mae"]:
+        for metric in metrics:#["mae"]:
             tmp_train = []
             tmp_val = []
             for key in hist.keys():

lips/dataset/scaler/powergrid_scaler.py

@@ -55,7 +55,7 @@ def transform(self, dataset: PowerGridDataSet):
             if attr_nm == "line_status":
                 res_tau.append((all_data[attr_nm] - m_) / sd_)
             elif attr_nm == "topo_vect":
-                res_tau.append((all_data[attr_nm] - m_) / sd_)
+                res_tau.append(all_data[attr_nm])#(all_data[attr_nm] - m_) / sd_)
                 # if self.obss is None:
                 #     self.obss = self._make_fake_obs(dataset)
                 # res_tau.append(np.array([leap_net_model.topo_vect_handler(obs)

lips/tests/data/powergrid/l2rpn_case14_sandbox/Benchmark2/test/q_ex.npz

@@ -0,0 +1,138 @@
+import os
+import sys
+sys.path.insert(0, "../")
+
+import tensorflow as tf
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+
+gpus = tf.config.experimental.list_physical_devices('GPU')
+if gpus:
+  try:
+    tf.config.experimental.set_virtual_device_configuration(
+        gpus[0],[tf.config.experimental.VirtualDeviceConfiguration(memory_limit=5120)])
+  except RuntimeError as e:
+    print(e)
+
+from IPython.display import display
+import pandas as pd
+import warnings
+
+import numpy as np
+import grid2op
+import copy
+
+warnings.simplefilter(action='ignore', category=pd.errors.PerformanceWarning)
+pd.set_option('display.max_columns', None)
+import pathlib
+from lips.augmented_simulators.tensorflow_models import TfFullyConnected#, TfFullyConnectedTopoEncoding
+from lips.dataset.scaler import StandardScaler
+
+from pprint import pprint
+from matplotlib import pyplot as plt
+from lips.benchmark.powergridBenchmark import PowerGridBenchmark
+from lips.utils import get_path
+from lips.augmented_simulators.tensorflow_models import LeapNet
+from lips.dataset.scaler import PowerGridScaler, StandardScaler
+from sklearn.preprocessing import MinMaxScaler
+
+from lips.config import ConfigManager
+
+#from execution_jobs.utils import init_df_bench1, append_metrics_to_df_bench1, init_df_bench2, append_metrics_to_df_bench2, init_df_bench3, append_metrics_to_df_bench3, filter_bench1, filter_bench2_3
+
+# indicate required paths
+# indicate required paths
+LIPS_PATH = pathlib.Path(__file__).parent.parent.parent.absolute()
+DATA_PATH = LIPS_PATH / "lips" / "tests" / "data" / "powergrid" / "l2rpn_case14_sandbox"
+BENCH_CONFIG_PATH = LIPS_PATH / "lips" / "tests" / "configs" / "powergrid" / "benchmarks" / "l2rpn_case14_sandbox.ini"
+SIM_CONFIG_PATH = LIPS_PATH / "configurations" / "powergrid" / "simulators"
+BASELINES_PATH = LIPS_PATH / "trained_baselines" / "powergrid"
+TRAINED_MODEL_PATH = LIPS_PATH / "trained_models" / "powergrid"
+EVALUATION_PATH = LIPS_PATH / "evaluation_results" / "PowerGrid"
+LOG_PATH = LIPS_PATH / "lips_logs.log"
+
+benchmark1 = PowerGridBenchmark(benchmark_name="Benchmark1",
+                                benchmark_path=DATA_PATH,
+                                load_data_set=True,
+                                log_path=LOG_PATH,
+                                config_path=BENCH_CONFIG_PATH
+                               )
+
+from lips.augmented_simulators.tensorflow_models import LeapNet
+
+from lips.augmented_simulators.tensorflow_models import LeapNet
+
+def test_fast_transform_tau():
+
+    bench_config = ConfigManager(section_name="Benchmark1", path=BENCH_CONFIG_PATH)
+    topo_actions = bench_config.get_option("dataset_create_params")["reference_args"]["topo_actions"]
+
+    kwargs_tau = []
+    for el in topo_actions:
+         kwargs_tau.append(el["set_bus"]["substations_id"][0])
+
+    leap_net1 = LeapNet(name="tf_leapnet",
+
+                        bench_config_path=BENCH_CONFIG_PATH,
+                        bench_config_name="Benchmark1",
+                        sim_config_path=SIM_CONFIG_PATH / "tf_leapnet.ini",
+                        sim_config_name="DEFAULT",
+                        log_path=LOG_PATH,
+
+                        loss={"name": "mse"},
+                        lr=1e-4,
+                        activation=tf.keras.layers.LeakyReLU(alpha=0.01),
+
+                        sizes_enc=(),
+                        sizes_main=(150, 150),
+                        sizes_out=(),
+                        topo_vect_to_tau="given_list",
+                        is_topo_vect_input=False,
+                        kwargs_tau=kwargs_tau,
+                        layer="resnet",
+                        attr_tau=("line_status","topo_vect"),
+                        scale_main_layer=150,
+                        # scale_input_enc_layer = 40,
+                        #scale_input_dec_layer=200,
+                        # topo_vect_as_input = True,
+                        mult_by_zero_lines_pred=False,
+                        topo_vect_as_input=True,
+                        scaler=PowerGridScaler,
+
+                        )
+
+    ## add topo_vect (temporary ) in attr_x in benchmark config file
+
+
+    ## add topo_vect (temporary ) in attr_x in benchmark config file
+    ##############
+    nb_timesteps_to_test=1000
+    indices=[i for i in range(nb_timesteps_to_test)]
+    for key in benchmark1.train_dataset.data.keys():
+        benchmark1.train_dataset.data[key]=benchmark1.train_dataset.data[key][indices]
+
+    benchmark1.train_dataset.size=len(indices)
+
+    leap_net1._leap_net_model.max_row_training_set=len(indices)
+    dataset=benchmark1.train_dataset
+    obss = leap_net1._make_fake_obs(dataset)
+    leap_net1._leap_net_model.init(obss)
+
+
+    (extract_x, extract_tau), extract_y = leap_net1.scaler.fit_transform(dataset)
+
+    #####
+    #Launch two different mathods for transformation and check that they match
+    tau = copy.deepcopy(extract_tau)
+    import time
+    start = time.time()
+    extract_tau_1 = leap_net1._transform_tau(dataset, extract_tau)
+    end = time.time()
+    print(end - start) #3.9s pour 10 000 / Pour 100 000 35.63s
+
+    start = time.time()
+    extract_tau_bis = leap_net1._transform_tau_given_list(tau)
+    end = time.time()
+    print(end - start) #0.026s pour 10 000 => 150 fois plus rapide! Pour 100 000, 1,7s
+    #0.021s with int32, could we only work with boolean ? 0.32s for 100 000 (or 0.82s with numpy matmult, a bit faster with tensorflow then)
+
+    assert np.all(extract_tau_1[1].astype((np.bool_))==extract_tau_bis[1])

lips/tests/data/powergrid/l2rpn_case14_sandbox/Benchmark2/test/q_or.npz

@@ -1,6 +1,6 @@
-Grid2Op==1.6.5
+Grid2Op==1.7.1
 leap-net @ https://github.com/BDonnot/leap_net/tarball/master#egg=leap_net
-lightsim2grid==0.6.1.post2
+lightsim2grid==0.7.0
 numpy==1.21.5
 numba==0.55.1
 pandapower==2.7.0