Label perturbation (#110)

* Adapt print_graph to labels

* Add labels for perturbation_resistant

* Add PR labels in tests

* Add PR labels in test inputs

* Solve Codacy issues

Author: martinateruzzi

grape/fault_diagnosis.py

@@ -73,7 +73,7 @@ def check_input_with_gephi(self):
         self.edges_df.to_csv('check_import_edges.csv', index=False)
 
     def fitness_iteration_parallel(self, out_queue, ichunk, chunk_length,
-        individuals, perturbed_nodes, initial_condition):
+        individuals, perturbed_nodes, initial_condition, origin):
         """
 
         Parallel iteration for fitness evaluation. We append to the
@@ -96,11 +96,11 @@ def fitness_iteration_parallel(self, out_queue, ichunk, chunk_length,
         for iter_ind in range(len(individuals)):
             ind_fit = (ichunk*chunk_length + iter_ind, individuals[iter_ind],
                 self.fitness_evaluation(individuals[iter_ind], perturbed_nodes,
-                initial_condition))
+                initial_condition, origin))
             out_queue.put(ind_fit)
 
     def fitness_evaluation_parallel(self, pop, perturbed_nodes,
-        initial_condition):
+        initial_condition, origin):
         """
 
         Wrapper for fitness evaluation. This methods spawns the processes for
@@ -125,7 +125,7 @@ def fitness_evaluation_parallel(self, pop, perturbed_nodes,
         processes = [
             mp.Process( target=self.fitness_iteration_parallel,
             args=( out_queue, p, len(ind_chunks[0]), ind_chunks[p],
-                perturbed_nodes, initial_condition ))
+                perturbed_nodes, initial_condition, origin ))
                 for p in range(n_procs) ]
 
         for proc in processes:
@@ -143,7 +143,7 @@ def fitness_evaluation_parallel(self, pop, perturbed_nodes,
         return fitnesses_tuples
 
     def fitness_evaluation(self, individual, perturbed_nodes,
-        initial_condition):
+        initial_condition, origin):
         """
 
         Evaluation of fitness on individual.
@@ -181,7 +181,7 @@ def fitness_evaluation(self, individual, perturbed_nodes,
         for node in perturbed_nodes:
             if node in T.nodes():
 
-                _, broken_nodes = self.rm_nodes(node, T)
+                _, broken_nodes = self.rm_nodes(node, T, origin)
                 broken_nodes = list(set(broken_nodes))
 
                 for n in broken_nodes: T.remove_node(n)
@@ -200,7 +200,7 @@ def fitness_evaluation(self, individual, perturbed_nodes,
             len(usr_with_serv.keys()), sum(dist_from_avg.values()))
 
     def optimizer(self, perturbed_nodes, initial_condition, params, weights,
-        parallel):
+        parallel, origin):
         """
 
         Genetic algorithm to optimize switches conditions, using DEAP.
@@ -253,10 +253,10 @@ def optimizer(self, perturbed_nodes, initial_condition, params, weights,
         # Evaluate the entire population
         if (not parallel) or (len(pop) < mp.cpu_count()):
             fitnesses = [toolbox.evaluate(ind, perturbed_nodes,
-                initial_condition) for ind in pop]
+                initial_condition, origin) for ind in pop]
         else:
             res_par = self.fitness_evaluation_parallel(pop, perturbed_nodes,
-                initial_condition)
+                initial_condition, origin)
             res_par.sort(key=lambda x:x[0])
             fitnesses = [x[2] for x in res_par]
 
@@ -305,10 +305,10 @@ def optimizer(self, perturbed_nodes, initial_condition, params, weights,
             # Evaluate the individuals with an invalid fitness
             if (not parallel) or (len(invalid_ind) < mp.cpu_count()):
                 fitnesses = [toolbox.evaluate(ind, perturbed_nodes,
-                    initial_condition) for ind in invalid_ind]
+                    initial_condition, origin) for ind in invalid_ind]
             else:
                 res_par = self.fitness_evaluation_parallel(invalid_ind,
-                    perturbed_nodes, initial_condition)
+                    perturbed_nodes, initial_condition, origin)
                 res_par.sort(key=lambda x:x[0])
                 fitnesses = [x[2] for x in res_par]
 
@@ -389,7 +389,7 @@ def check_paths_and_measures(self, prefix=None):
                 self.paths_df = pd.merge(self.paths_df, df,
                     on=['from', 'to', 'ids', 'area'], how='outer')
 
-    def rm_nodes(self, node, graph, visited=None, broken_nodes=None):
+    def rm_nodes(self, node, graph, origin, visited=None, broken_nodes=None):
         """
 
         Remove nodes from the graph in a depth first search way to
@@ -416,51 +416,51 @@ def rm_nodes(self, node, graph, visited=None, broken_nodes=None):
         logging.debug(f'Node: {node}')
 
 
-        if bool(graph.perturbation_resistant[node]):
+        if origin in graph.perturbation_resistant[node]:
             logging.debug(f'Node {node} visited, fault resistant node')
+            logging.debug('Perturbation origin: %s', origin)
             return visited, broken_nodes
 
-        else:
-            fathers = {'AND': set(), 'OR': set(), 'SINGLE': set() }
-            predecessors = list(graph.predecessors(node))
-            logging.debug(f'Predecessors: {predecessors}')
+        fathers = {'AND': set(), 'OR': set(), 'SINGLE': set() }
+        predecessors = list(graph.predecessors(node))
+        logging.debug(f'Predecessors: {predecessors}')
 
-            if len(visited) == 1:
-                broken_nodes.append(node)
-                logging.debug(f'Broken: {broken_nodes}')
+        if len(visited) == 1:
+            broken_nodes.append(node)
+            logging.debug(f'Broken: {broken_nodes}')
 
-            elif predecessors:
-                for p in predecessors:
-                    fathers[graph.father_condition[(p, node)]].add(p)
+        elif predecessors:
+            for p in predecessors:
+                fathers[graph.father_condition[(p, node)]].add(p)
 
-                if fathers['AND'] & set(broken_nodes):
-                    broken_nodes.append(node)
-                    logging.debug(f'Broken {node}, AND predecessor broken.')
-                    logging.debug(f'Nodes broken so far: {broken_nodes}')
+            if fathers['AND'] & set(broken_nodes):
+                broken_nodes.append(node)
+                logging.debug(f'Broken {node}, AND predecessor broken.')
+                logging.debug(f'Nodes broken so far: {broken_nodes}')
+
+            #'SINGLE' treated as 'AND'
+            elif fathers['SINGLE'] & set(broken_nodes):
+                broken_nodes.append(node)
+                logging.debug(f'Broken {node}, SINGLE predecessor broken.')
+                logging.debug(f'Nodes broken so far: {broken_nodes}')
 
-                #'SINGLE' treated as 'AND'
-                elif fathers['SINGLE'] & set(broken_nodes):
+            else:
+                if (fathers['OR'] & set(broken_nodes)) == set(predecessors):
+                    #all my 'OR' predecessors are dead
                     broken_nodes.append(node)
-                    logging.debug(f'Broken {node}, SINGLE predecessor broken.')
+                    logging.debug(f'Broken {node}, no more fathers')
                     logging.debug(f'Nodes broken so far: {broken_nodes}')
-
                 else:
-                    if (fathers['OR'] & set(broken_nodes)) == set(predecessors):
-                        #all my 'OR' predecessors are dead
-                        broken_nodes.append(node)
-                        logging.debug(f'Broken {node}, no more fathers')
-                        logging.debug(f'Nodes broken so far: {broken_nodes}')
-                    else:
-                        logging.debug(f'Surviving fathers: {fathers}')
-                        logging.debug(f'Nodes broken so far: {broken_nodes}')
-                        return 0
-            else:
-                broken_nodes.append(node)
-                logging.debug(f'Node: {node} has no more predecessors')
-                logging.debug(f'Nodes broken so far: {broken_nodes}')
+                    logging.debug(f'Surviving fathers: {fathers}')
+                    logging.debug(f'Nodes broken so far: {broken_nodes}')
+                    return 0
+        else:
+            broken_nodes.append(node)
+            logging.debug(f'Node: {node} has no more predecessors')
+            logging.debug(f'Nodes broken so far: {broken_nodes}')
 
         for next_node in set(graph[node]) - visited:
-            self.rm_nodes(next_node, graph, visited, broken_nodes)
+            self.rm_nodes(next_node, graph, origin, visited, broken_nodes)
 
         return visited, broken_nodes
 
@@ -502,7 +502,7 @@ def update_status_areas(self, damaged_areas):
         for area in damaged_areas:
             self.df.loc[self.df.area == area, 'status_area'] = 'DAMAGED'
 
-    def delete_a_node(self, node):
+    def delete_a_node(self, node, origin):
         """
 
         Delete a node in the graph.
@@ -513,15 +513,15 @@ def delete_a_node(self, node):
             No check is done within this function.
         """
 
-        _ , broken_nodes = self.rm_nodes(node, self.G)
+        _ , broken_nodes = self.rm_nodes(node, self.G, origin)
         broken_nodes = list(set(broken_nodes))
 
         for n in broken_nodes:
             self.damaged_areas.add(self.G.area[n])
             self.G.remove_node(n)
 
     def apply_perturbation(self, perturbed_nodes, params, weights, parallel,
-        verbose, kind='element'):
+        verbose, origin, kind='element'):
         """
 
         Perturbation simulator, actually applying the perturbation
@@ -562,7 +562,7 @@ def apply_perturbation(self, perturbed_nodes, params, weights, parallel,
         if self.G.switches:
 
             res = self.optimizer(perturbed_nodes, self.G.init_status, params,
-                weights, parallel)
+                weights, parallel, origin)
             w = np.asarray(list(weights.values()))
 
             if verbose:
@@ -623,7 +623,8 @@ def apply_perturbation(self, perturbed_nodes, params, weights, parallel,
             self.G.final_status = best
 
         for node in perturbed_nodes:
-            if node in self.G.nodes(): self.delete_a_node(node)
+            if node in self.G.nodes():
+                self.delete_a_node(node, origin)
 
         self.check_paths_and_measures(prefix='final_')
         self.paths_df.to_csv('service_paths_' + str(kind)+ '_perturbation.csv',
@@ -638,7 +639,7 @@ def apply_perturbation(self, perturbed_nodes, params, weights, parallel,
     def simulate_element_perturbation(self, perturbed_nodes,
         params={'npop': 300, 'ngen': 100, 'indpb': 0.6, 'tresh': 0.5,
         'nsel': 5}, weights={'w1': 1.0, 'w2': -1.0, 'w3': -1.0, 'w4': -1.0,
-        'w5': 2.0}, parallel=False, verbose=True):
+        'w5': 2.0}, parallel=False, verbose=True, origin=None):
         """
 
         Simulate a perturbation of one or multiple nodes.
@@ -666,7 +667,7 @@ def simulate_element_perturbation(self, perturbed_nodes,
         :param parallel: flag for parallel fitness evaluation of
             initial population, default to False
         :type parallel: bool, optional
-        :param verbose: flag for verbose outputi, default to True
+        :param verbose: flag for verbose output, default to True
         :type verbose: bool, optional
 
         .. note:: A perturbation, depending on the considered system,
@@ -685,12 +686,12 @@ def simulate_element_perturbation(self, perturbed_nodes,
                 sys.exit()
 
         self.apply_perturbation(perturbed_nodes, params, weights, parallel,
-            verbose, kind='element')
+            verbose, origin, kind='element')
 
     def simulate_area_perturbation(self, perturbed_areas, params={'npop': 300,
         'ngen': 100, 'indpb': 0.6, 'tresh': 0.5, 'nsel': 5},
         weights={'w1': 1.0, 'w2': -1.0, 'w3': -1.0, 'w4': -1.0, 'w5': 2.0},
-        parallel=False, verbose=True):
+        parallel=False, verbose=True, origin=None):
         """
 
         Simulate a perturbation in one or multiple areas.
@@ -740,7 +741,7 @@ def simulate_area_perturbation(self, perturbed_areas, params={'npop': 300,
                     if idx_area == area: nodes_in_area.append(idx)
 
         self.apply_perturbation(nodes_in_area, params, weights, parallel,
-            verbose, kind='area')
+            verbose, origin, kind='area')
 
     def graph_characterization_to_file(self, filename):
         """

grape/general_graph.py

@@ -47,13 +47,12 @@ def load(self, filename):
         :rtype: pandas.DataFrame, pandas.DataFrame
         """
 
-        conv = {'mark' : str, 'father_mark' : str, }
+        conv = {'mark' : str, 'father_mark' : str,
+            'perturbation_resistant' : str}
         graph_df = pd.read_csv(filename, converters=conv, keep_default_na=False)
-        cols_to_num = ['perturbation_resistant', 'init_status']
+        cols_to_num = ['init_status']
         graph_df[cols_to_num] = graph_df[cols_to_num].apply(pd.to_numeric,
             errors='coerce', axis=1)
-        cols_to_int = ['perturbation_resistant']
-        graph_df[cols_to_int] = graph_df[cols_to_int].astype('int64')
 
         for index, row in graph_df.iterrows():
 
@@ -77,8 +76,15 @@ def load(self, filename):
         graph_df.set_index('mark', inplace=True)
 
         self._final_status = {}
-        nx.set_node_attributes(self, 'AVAILABLE', 'status_area')
-        nx.set_node_attributes(self, 'ACTIVE', 'mark_status')
+        nx.set_node_attributes(self, 'AVAILABLE', name='status_area')
+        nx.set_node_attributes(self, 'ACTIVE', name='mark_status')
+
+        perts = nx.get_node_attributes(self, 'perturbation_resistant')
+        split_perts = {node: perts[node].split("/")
+            for node in self.nodes}
+        strip_perts = {node: [x.strip() for x in split_perts[node]]
+            for node in self.nodes}
+        nx.set_node_attributes(self, strip_perts, name='perturbation_resistant')
 
         return graph_df, graph_edges_df
 
@@ -1342,7 +1348,7 @@ def print_graph(self, radius=None, initial_pos=None, fixed_nodes=None,
                 edgecolors=border, alpha=0.5)
 
         pert_resistant = [node for node in self.perturbation_resistant.keys()
-             if self.perturbation_resistant[node] == 1]
+             if self.perturbation_resistant[node][0]]
 
         for node in pert_resistant:
             col = mymap(area_indices[self.area[node]])

tests/TOY_graph.csv

@@ -1,30 +1,30 @@
 mark,father_condition,father_mark,area,perturbation_resistant,init_status,description,type,weight,initial_service
-"1","ORPHAN","NULL","area1",0,,,"SOURCE",1.0,1.0
-"2","SINGLE","1","area1",1,1,,"SWITCH",1.0,0.0
-"3","SINGLE","1","area1",1,1,,"SWITCH",1.0,0.0
-"4","SINGLE","2","area1",1,,,"HUB",1.0,0.0
-"5","SINGLE","3","area1",1,,,"HUB",1.0,0.0
-"6","SINGLE","4","area4",0,,,"HUB",1.0,0.0
-"6","SINGLE","7","area4",0,,,"HUB",1.0,0.0
-"7","SINGLE","6","area4",0,,,"HUB",1.0,0.0
-"8","SINGLE","6","area4",0,,,"HUB",1.0,0.0
-"6","SINGLE","8","area4",0,,,"HUB",1.0,0.0
-"9","OR","8","area3",0,,,"HUB",1.0,0.0
-"9","OR","15","area3",0,,,"HUB",1.0,0.0
-"15","ORPHAN","NULL","area3",0,,,"SOURCE",1.0,2.0
-"16","SINGLE","9","area3",0,,,"HUB",1.0,0.0
-"16","SINGLE","17","area3",0,,,"HUB",1.0,0.0
-"17","SINGLE","16","area3",0,,,"HUB",1.0,0.0
-"10","SINGLE","17","area3",0,,,"HUB",1.0,0.0
-"11","AND","10","area2",0,,,"HUB",1.0,0.0
-"11","AND","5","area2",0,,,"HUB",1.0,0.0
-"19","SINGLE","11","area2",0,,,"HUB",1.0,0.0
-"19","SINGLE","12","area2",0,,,"HUB",1.0,0.0
-"19","SINGLE","14","area2",0,,,"HUB",1.0,0.0
-"12","SINGLE","19","area2",0,,,"HUB",1.0,0.0
-"12","SINGLE","13","area2",0,,,"HUB",1.0,0.0
-"13","SINGLE","14","area2",0,,,"HUB",1.0,0.0
-"13","SINGLE","12","area2",0,,,"HUB",1.0,0.0
-"14","SINGLE","19","area2",0,,,"HUB",1.0,0.0
-"14","SINGLE","13","area2",0,,,"HUB",1.0,0.0
-"18","SINGLE","14","area2",0,,,"USER",1.0,0.0
+"1","ORPHAN","NULL","area1",,,,"SOURCE",1.0,1.0
+"2","SINGLE","1","area1",perturbation1,1,,"SWITCH",1.0,0.0
+"3","SINGLE","1","area1",perturbation1,1,,"SWITCH",1.0,0.0
+"4","SINGLE","2","area1",perturbation1,,,"HUB",1.0,0.0
+"5","SINGLE","3","area1",perturbation1,,,"HUB",1.0,0.0
+"6","SINGLE","4","area4",,,,"HUB",1.0,0.0
+"6","SINGLE","7","area4",,,,"HUB",1.0,0.0
+"7","SINGLE","6","area4",,,,"HUB",1.0,0.0
+"8","SINGLE","6","area4",,,,"HUB",1.0,0.0
+"6","SINGLE","8","area4",,,,"HUB",1.0,0.0
+"9","OR","8","area3",,,,"HUB",1.0,0.0
+"9","OR","15","area3",,,,"HUB",1.0,0.0
+"15","ORPHAN","NULL","area3",,,,"SOURCE",1.0,2.0
+"16","SINGLE","9","area3",,,,"HUB",1.0,0.0
+"16","SINGLE","17","area3",,,,"HUB",1.0,0.0
+"17","SINGLE","16","area3",,,,"HUB",1.0,0.0
+"10","SINGLE","17","area3",,,,"HUB",1.0,0.0
+"11","AND","10","area2",,,,"HUB",1.0,0.0
+"11","AND","5","area2",,,,"HUB",1.0,0.0
+"19","SINGLE","11","area2",,,,"HUB",1.0,0.0
+"19","SINGLE","12","area2",,,,"HUB",1.0,0.0
+"19","SINGLE","14","area2",,,,"HUB",1.0,0.0
+"12","SINGLE","19","area2",,,,"HUB",1.0,0.0
+"12","SINGLE","13","area2",,,,"HUB",1.0,0.0
+"13","SINGLE","14","area2",,,,"HUB",1.0,0.0
+"13","SINGLE","12","area2",,,,"HUB",1.0,0.0
+"14","SINGLE","19","area2",,,,"HUB",1.0,0.0
+"14","SINGLE","13","area2",,,,"HUB",1.0,0.0
+"18","SINGLE","14","area2",,,,"USER",1.0,0.0