From a54b8de5b3526bc9de7ed10f5c178f3616fe4758 Mon Sep 17 00:00:00 2001 From: jajupmochi Date: Fri, 16 Oct 2020 17:58:58 +0200 Subject: [PATCH] Refactor: deprecate the usage of "__" for the "private" members and methods, use "_" instead. --- gklearn/ged/env/ged_env.py | 254 ++++++++++++++++++++++---------------------- gklearn/ged/env/node_map.py | 50 ++++----- 2 files changed, 152 insertions(+), 152 deletions(-) diff --git a/gklearn/ged/env/ged_env.py b/gklearn/ged/env/ged_env.py index 60b671b..3d7644b 100644 --- a/gklearn/ged/env/ged_env.py +++ b/gklearn/ged/env/ged_env.py @@ -15,17 +15,17 @@ class GEDEnv(object): def __init__(self): - self.__initialized = False - self.__new_graph_ids = [] - self.__ged_data = GEDData() + self._initialized = False + self._new_graph_ids = [] + self._ged_data = GEDData() # Variables needed for approximating ged_instance_. - self.__lower_bounds = {} - self.__upper_bounds = {} - self.__runtimes = {} - self.__node_maps = {} - self.__original_to_internal_node_ids = [] - self.__internal_to_original_node_ids = [] - self.__ged_method = None + self._lower_bounds = {} + self._upper_bounds = {} + self._runtimes = {} + self._node_maps = {} + self._original_to_internal_node_ids = [] + self._internal_to_original_node_ids = [] + self._ged_method = None def set_edit_cost(self, edit_cost, edit_cost_constants=[]): @@ -36,7 +36,7 @@ class GEDEnv(object): * @param[in] edit_cost_constants Constants passed to the constructor of the edit cost class selected by @p edit_costs. */ """ - self.__ged_data._set_edit_cost(edit_cost, edit_cost_constants) + self._ged_data._set_edit_cost(edit_cost, edit_cost_constants) def add_graph(self, graph_name='', graph_class=''): @@ -49,17 +49,17 @@ class GEDEnv(object): */ """ # @todo: graphs are not uninitialized. - self.__initialized = False - graph_id = self.__ged_data._num_graphs_without_shuffled_copies - self.__ged_data._num_graphs_without_shuffled_copies += 1 - self.__new_graph_ids.append(graph_id) - self.__ged_data._graphs.append(nx.Graph()) - self.__ged_data._graph_names.append(graph_name) - self.__ged_data._graph_classes.append(graph_class) - self.__original_to_internal_node_ids.append({}) - self.__internal_to_original_node_ids.append({}) - self.__ged_data._strings_to_internal_node_ids.append({}) - self.__ged_data._internal_node_ids_to_strings.append({}) + self._initialized = False + graph_id = self._ged_data._num_graphs_without_shuffled_copies + self._ged_data._num_graphs_without_shuffled_copies += 1 + self._new_graph_ids.append(graph_id) + self._ged_data._graphs.append(nx.Graph()) + self._ged_data._graph_names.append(graph_name) + self._ged_data._graph_classes.append(graph_class) + self._original_to_internal_node_ids.append({}) + self._internal_to_original_node_ids.append({}) + self._ged_data._strings_to_internal_node_ids.append({}) + self._ged_data._internal_node_ids_to_strings.append({}) return graph_id @@ -70,14 +70,14 @@ class GEDEnv(object): * @param[in] graph_id ID of graph that has to be cleared. */ """ - if graph_id > self.__ged_data.num_graphs_without_shuffled_copies(): + if graph_id > self._ged_data.num_graphs_without_shuffled_copies(): raise Exception('The graph', self.get_graph_name(graph_id), 'has not been added to the environment.') - self.__ged_data._graphs[graph_id].clear() - self.__original_to_internal_node_ids[graph_id].clear() - self.__internal_to_original_node_ids[graph_id].clear() - self.__ged_data._strings_to_internal_node_ids[graph_id].clear() - self.__ged_data._internal_node_ids_to_strings[graph_id].clear() - self.__initialized = False + self._ged_data._graphs[graph_id].clear() + self._original_to_internal_node_ids[graph_id].clear() + self._internal_to_original_node_ids[graph_id].clear() + self._ged_data._strings_to_internal_node_ids[graph_id].clear() + self._ged_data._internal_node_ids_to_strings[graph_id].clear() + self._initialized = False def add_node(self, graph_id, node_id, node_label): @@ -90,15 +90,15 @@ class GEDEnv(object): */ """ # @todo: check ids. - self.__initialized = False - internal_node_id = nx.number_of_nodes(self.__ged_data._graphs[graph_id]) - self.__ged_data._graphs[graph_id].add_node(internal_node_id, label=node_label) - self.__original_to_internal_node_ids[graph_id][node_id] = internal_node_id - self.__internal_to_original_node_ids[graph_id][internal_node_id] = node_id - self.__ged_data._strings_to_internal_node_ids[graph_id][str(node_id)] = internal_node_id - self.__ged_data._internal_node_ids_to_strings[graph_id][internal_node_id] = str(node_id) - self.__ged_data._node_label_to_id(node_label) - label_id = self.__ged_data._node_label_to_id(node_label) + self._initialized = False + internal_node_id = nx.number_of_nodes(self._ged_data._graphs[graph_id]) + self._ged_data._graphs[graph_id].add_node(internal_node_id, label=node_label) + self._original_to_internal_node_ids[graph_id][node_id] = internal_node_id + self._internal_to_original_node_ids[graph_id][internal_node_id] = node_id + self._ged_data._strings_to_internal_node_ids[graph_id][str(node_id)] = internal_node_id + self._ged_data._internal_node_ids_to_strings[graph_id][internal_node_id] = str(node_id) + self._ged_data._node_label_to_id(node_label) + label_id = self._ged_data._node_label_to_id(node_label) # @todo: ged_data_.graphs_[graph_id].set_label @@ -114,10 +114,10 @@ class GEDEnv(object): */ """ # @todo: check everything. - self.__initialized = False + self._initialized = False # @todo: check ignore_duplicates. - self.__ged_data._graphs[graph_id].add_edge(self.__original_to_internal_node_ids[graph_id][nd_from], self.__original_to_internal_node_ids[graph_id][nd_to], label=edge_label) - label_id = self.__ged_data._edge_label_to_id(edge_label) + self._ged_data._graphs[graph_id].add_edge(self._original_to_internal_node_ids[graph_id][nd_from], self._original_to_internal_node_ids[graph_id][nd_to], label=edge_label) + label_id = self._ged_data._edge_label_to_id(edge_label) # @todo: ged_data_.graphs_[graph_id].set_label @@ -182,30 +182,30 @@ class GEDEnv(object): init_type = OptionsStringMap.InitType[init_type] # Throw an exception if no edit costs have been selected. - if self.__ged_data._edit_cost is None: + if self._ged_data._edit_cost is None: raise Exception('No edit costs have been selected. Call set_edit_cost() before calling init().') # Return if the environment is initialized. - if self.__initialized: + if self._initialized: return # Set initialization type. - self.__ged_data._init_type = init_type + self._ged_data._init_type = init_type # @todo: Construct shuffled graph copies if necessary. # Re-initialize adjacency matrices (also previously initialized graphs must be re-initialized because of possible re-allocation). # @todo: setup_adjacency_matrix, don't know if neccessary. - self.__ged_data._max_num_nodes = np.max([nx.number_of_nodes(g) for g in self.__ged_data._graphs]) - self.__ged_data._max_num_edges = np.max([nx.number_of_edges(g) for g in self.__ged_data._graphs]) + self._ged_data._max_num_nodes = np.max([nx.number_of_nodes(g) for g in self._ged_data._graphs]) + self._ged_data._max_num_edges = np.max([nx.number_of_edges(g) for g in self._ged_data._graphs]) # Initialize cost matrices if necessary. - if self.__ged_data._eager_init(): + if self._ged_data._eager_init(): pass # @todo: init_cost_matrices_: 1. Update node cost matrix if new node labels have been added to the environment; 2. Update edge cost matrix if new edge labels have been added to the environment. # Mark environment as initialized. - self.__initialized = True - self.__new_graph_ids.clear() + self._initialized = True + self._new_graph_ids.clear() def is_initialized(self): @@ -215,7 +215,7 @@ class GEDEnv(object): * @return True if the environment is initialized. */ """ - return self.__initialized + return self._initialized def get_init_type(self): @@ -225,16 +225,16 @@ class GEDEnv(object): * @return Initialization type. */ """ - return self.__ged_data._init_type + return self._ged_data._init_type def set_label_costs(self, node_label_costs=None, edge_label_costs=None): """Set the costs between labels. """ if node_label_costs is not None: - self.__ged_data._node_label_costs = node_label_costs + self._ged_data._node_label_costs = node_label_costs if edge_label_costs is not None: - self.__ged_data._edge_label_costs = edge_label_costs + self._ged_data._edge_label_costs = edge_label_costs def set_method(self, method, options=''): @@ -245,67 +245,67 @@ class GEDEnv(object): * @param[in] options An options string of the form @"[--@ @] [...]@" passed to the selected method. */ """ - del self.__ged_method + del self._ged_method if isinstance(method, str): method = OptionsStringMap.GEDMethod[method] if method == Options.GEDMethod.BRANCH: - self.__ged_method = Branch(self.__ged_data) + self._ged_method = Branch(self._ged_data) elif method == Options.GEDMethod.BRANCH_FAST: - self.__ged_method = BranchFast(self.__ged_data) + self._ged_method = BranchFast(self._ged_data) elif method == Options.GEDMethod.BRANCH_FAST: - self.__ged_method = BranchFast(self.__ged_data) + self._ged_method = BranchFast(self._ged_data) elif method == Options.GEDMethod.BRANCH_TIGHT: - self.__ged_method = BranchTight(self.__ged_data) + self._ged_method = BranchTight(self._ged_data) elif method == Options.GEDMethod.BRANCH_UNIFORM: - self.__ged_method = BranchUniform(self.__ged_data) + self._ged_method = BranchUniform(self._ged_data) elif method == Options.GEDMethod.BRANCH_COMPACT: - self.__ged_method = BranchCompact(self.__ged_data) + self._ged_method = BranchCompact(self._ged_data) elif method == Options.GEDMethod.PARTITION: - self.__ged_method = Partition(self.__ged_data) + self._ged_method = Partition(self._ged_data) elif method == Options.GEDMethod.HYBRID: - self.__ged_method = Hybrid(self.__ged_data) + self._ged_method = Hybrid(self._ged_data) elif method == Options.GEDMethod.RING: - self.__ged_method = Ring(self.__ged_data) + self._ged_method = Ring(self._ged_data) elif method == Options.GEDMethod.ANCHOR_AWARE_GED: - self.__ged_method = AnchorAwareGED(self.__ged_data) + self._ged_method = AnchorAwareGED(self._ged_data) elif method == Options.GEDMethod.WALKS: - self.__ged_method = Walks(self.__ged_data) + self._ged_method = Walks(self._ged_data) elif method == Options.GEDMethod.IPFP: - self.__ged_method = IPFP(self.__ged_data) + self._ged_method = IPFP(self._ged_data) elif method == Options.GEDMethod.BIPARTITE: from gklearn.ged.methods import Bipartite - self.__ged_method = Bipartite(self.__ged_data) + self._ged_method = Bipartite(self._ged_data) elif method == Options.GEDMethod.SUBGRAPH: - self.__ged_method = Subgraph(self.__ged_data) + self._ged_method = Subgraph(self._ged_data) elif method == Options.GEDMethod.NODE: - self.__ged_method = Node(self.__ged_data) + self._ged_method = Node(self._ged_data) elif method == Options.GEDMethod.RING_ML: - self.__ged_method = RingML(self.__ged_data) + self._ged_method = RingML(self._ged_data) elif method == Options.GEDMethod.BIPARTITE_ML: - self.__ged_method = BipartiteML(self.__ged_data) + self._ged_method = BipartiteML(self._ged_data) elif method == Options.GEDMethod.REFINE: - self.__ged_method = Refine(self.__ged_data) + self._ged_method = Refine(self._ged_data) elif method == Options.GEDMethod.BP_BEAM: - self.__ged_method = BPBeam(self.__ged_data) + self._ged_method = BPBeam(self._ged_data) elif method == Options.GEDMethod.SIMULATED_ANNEALING: - self.__ged_method = SimulatedAnnealing(self.__ged_data) + self._ged_method = SimulatedAnnealing(self._ged_data) elif method == Options.GEDMethod.HED: - self.__ged_method = HED(self.__ged_data) + self._ged_method = HED(self._ged_data) elif method == Options.GEDMethod.STAR: - self.__ged_method = STAR(self.__ged_data) + self._ged_method = STAR(self._ged_data) # #ifdef GUROBI elif method == Options.GEDMethod.F1: - self.__ged_method = F1(self.__ged_data) + self._ged_method = F1(self._ged_data) elif method == Options.GEDMethod.F2: - self.__ged_method = F2(self.__ged_data) + self._ged_method = F2(self._ged_data) elif method == Options.GEDMethod.COMPACT_MIP: - self.__ged_method = CompactMIP(self.__ged_data) + self._ged_method = CompactMIP(self._ged_data) elif method == Options.GEDMethod.BLP_NO_EDGE_LABELS: - self.__ged_method = BLPNoEdgeLabels(self.__ged_data) + self._ged_method = BLPNoEdgeLabels(self._ged_data) - self.__ged_method.set_options(options) + self._ged_method.set_options(options) def run_method(self, g_id, h_id): @@ -316,34 +316,34 @@ class GEDEnv(object): * @param[in] h_id ID of an input graph that has been added to the environment. */ """ - if g_id >= self.__ged_data.num_graphs(): + if g_id >= self._ged_data.num_graphs(): raise Exception('The graph with ID', str(g_id), 'has not been added to the environment.') - if h_id >= self.__ged_data.num_graphs(): + if h_id >= self._ged_data.num_graphs(): raise Exception('The graph with ID', str(h_id), 'has not been added to the environment.') - if not self.__initialized: + if not self._initialized: raise Exception('The environment is uninitialized. Call init() after adding all graphs to the environment.') - if self.__ged_method is None: + if self._ged_method is None: raise Exception('No method has been set. Call set_method() before calling run().') # Call selected GEDMethod and store results. - if self.__ged_data.shuffled_graph_copies_available() and (g_id == h_id): - self.__ged_method.run(g_id, self.__ged_data.id_shuffled_graph_copy(h_id)) # @todo: why shuffle? + if self._ged_data.shuffled_graph_copies_available() and (g_id == h_id): + self._ged_method.run(g_id, self._ged_data.id_shuffled_graph_copy(h_id)) # @todo: why shuffle? else: - self.__ged_method.run(g_id, h_id) - self.__lower_bounds[(g_id, h_id)] = self.__ged_method.get_lower_bound() - self.__upper_bounds[(g_id, h_id)] = self.__ged_method.get_upper_bound() - self.__runtimes[(g_id, h_id)] = self.__ged_method.get_runtime() - self.__node_maps[(g_id, h_id)] = self.__ged_method.get_node_map() + self._ged_method.run(g_id, h_id) + self._lower_bounds[(g_id, h_id)] = self._ged_method.get_lower_bound() + self._upper_bounds[(g_id, h_id)] = self._ged_method.get_upper_bound() + self._runtimes[(g_id, h_id)] = self._ged_method.get_runtime() + self._node_maps[(g_id, h_id)] = self._ged_method.get_node_map() def init_method(self): """Initializes the method specified by call to set_method(). """ - if not self.__initialized: + if not self._initialized: raise Exception('The environment is uninitialized. Call init() before calling init_method().') - if self.__ged_method is None: + if self._ged_method is None: raise Exception('No method has been set. Call set_method() before calling init_method().') - self.__ged_method.init() + self._ged_method.init() def get_num_node_labels(self): @@ -354,7 +354,7 @@ class GEDEnv(object): * @note If @p 1 is returned, the nodes are unlabeled. */ """ - return len(self.__ged_data._node_labels) + return len(self._ged_data._node_labels) def get_all_node_labels(self): @@ -365,7 +365,7 @@ class GEDEnv(object): * @note If @p 1 is returned, the nodes are unlabeled. */ """ - return self.__ged_data._node_labels + return self._ged_data._node_labels def get_node_label(self, label_id, to_dict=True): @@ -379,8 +379,8 @@ class GEDEnv(object): if label_id < 1 or label_id > self.get_num_node_labels(): raise Exception('The environment does not contain a node label with ID', str(label_id), '.') if to_dict: - return dict(self.__ged_data._node_labels[label_id - 1]) - return self.__ged_data._node_labels[label_id - 1] + return dict(self._ged_data._node_labels[label_id - 1]) + return self._ged_data._node_labels[label_id - 1] def get_num_edge_labels(self): @@ -391,7 +391,7 @@ class GEDEnv(object): * @note If @p 1 is returned, the edges are unlabeled. */ """ - return len(self.__ged_data._edge_labels) + return len(self._ged_data._edge_labels) def get_all_edge_labels(self): @@ -402,7 +402,7 @@ class GEDEnv(object): * @note If @p 1 is returned, the edges are unlabeled. */ """ - return self.__ged_data._edge_labels + return self._ged_data._edge_labels def get_edge_label(self, label_id, to_dict=True): @@ -416,8 +416,8 @@ class GEDEnv(object): if label_id < 1 or label_id > self.get_num_edge_labels(): raise Exception('The environment does not contain an edge label with ID', str(label_id), '.') if to_dict: - return dict(self.__ged_data._edge_labels[label_id - 1]) - return self.__ged_data._edge_labels[label_id - 1] + return dict(self._ged_data._edge_labels[label_id - 1]) + return self._ged_data._edge_labels[label_id - 1] def get_upper_bound(self, g_id, h_id): @@ -429,9 +429,9 @@ class GEDEnv(object): * @return Upper bound computed by the last call to run_method() with arguments @p g_id and @p h_id. */ """ - if (g_id, h_id) not in self.__upper_bounds: + if (g_id, h_id) not in self._upper_bounds: raise Exception('Call run(' + str(g_id) + ',' + str(h_id) + ') before calling get_upper_bound(' + str(g_id) + ',' + str(h_id) + ').') - return self.__upper_bounds[(g_id, h_id)] + return self._upper_bounds[(g_id, h_id)] def get_lower_bound(self, g_id, h_id): @@ -443,9 +443,9 @@ class GEDEnv(object): * @return Lower bound computed by the last call to run_method() with arguments @p g_id and @p h_id. */ """ - if (g_id, h_id) not in self.__lower_bounds: + if (g_id, h_id) not in self._lower_bounds: raise Exception('Call run(' + str(g_id) + ',' + str(h_id) + ') before calling get_lower_bound(' + str(g_id) + ',' + str(h_id) + ').') - return self.__lower_bounds[(g_id, h_id)] + return self._lower_bounds[(g_id, h_id)] def get_runtime(self, g_id, h_id): @@ -457,9 +457,9 @@ class GEDEnv(object): * @return Runtime of last call to run_method() with arguments @p g_id and @p h_id. */ """ - if (g_id, h_id) not in self.__runtimes: + if (g_id, h_id) not in self._runtimes: raise Exception('Call run(' + str(g_id) + ',' + str(h_id) + ') before calling get_runtime(' + str(g_id) + ',' + str(h_id) + ').') - return self.__runtimes[(g_id, h_id)] + return self._runtimes[(g_id, h_id)] def get_init_time(self): @@ -469,7 +469,7 @@ class GEDEnv(object): * @return Runtime of the last call to init_method(). */ """ - return self.__ged_method.get_init_time() + return self._ged_method.get_init_time() def get_node_map(self, g_id, h_id): @@ -481,9 +481,9 @@ class GEDEnv(object): * @return Node map computed by the last call to run_method() with arguments @p g_id and @p h_id. */ """ - if (g_id, h_id) not in self.__node_maps: + if (g_id, h_id) not in self._node_maps: raise Exception('Call run(' + str(g_id) + ',' + str(h_id) + ') before calling get_node_map(' + str(g_id) + ',' + str(h_id) + ').') - return self.__node_maps[(g_id, h_id)] + return self._node_maps[(g_id, h_id)] def get_forward_map(self, g_id, h_id) : @@ -531,7 +531,7 @@ class GEDEnv(object): * @param[in,out] node_map Node map whose induced edit cost is to be computed. */ """ - self.__ged_data.compute_induced_cost(self.__ged_data._graphs[g_id], self.__ged_data._graphs[h_id], node_map) + self._ged_data.compute_induced_cost(self._ged_data._graphs[g_id], self._ged_data._graphs[h_id], node_map) def get_nx_graph(self, graph_id): @@ -569,7 +569,7 @@ class GEDEnv(object): .. seealso:: get_graph_internal_id(), get_graph_num_nodes(), get_graph_num_edges(), get_original_node_ids(), get_graph_edges(), get_graph_adjacence_matrix() .. note:: These functions allow to collect all the graph's informations. """ - graph = self.__ged_data.graph(graph_id) + graph = self._ged_data.graph(graph_id) node_labels = [] for n in graph.nodes(): node_labels.append(graph.nodes[n]['label']) @@ -590,7 +590,7 @@ class GEDEnv(object): .. seealso::get_graph_internal_id(), get_graph_num_nodes(), get_graph_num_edges(), get_original_node_ids(), get_graph_node_labels(), get_graph_adjacence_matrix() .. note:: These functions allow to collect all the graph's informations. """ - graph = self.__ged_data.graph(graph_id) + graph = self._ged_data.graph(graph_id) if to_dict: edges = {} for n1, n2, attr in graph.edges(data=True): @@ -608,7 +608,7 @@ class GEDEnv(object): * @return Name of the input graph. */ """ - return self.__ged_data._graph_names[graph_id] + return self._ged_data._graph_names[graph_id] def get_graph_num_nodes(self, graph_id): @@ -619,7 +619,7 @@ class GEDEnv(object): * @return Number of nodes in the graph. */ """ - return nx.number_of_nodes(self.__ged_data.graph(graph_id)) + return nx.number_of_nodes(self._ged_data.graph(graph_id)) def get_original_node_ids(self, graph_id): @@ -634,11 +634,11 @@ class GEDEnv(object): .. seealso::get_graph_internal_id(), get_graph_num_nodes(), get_graph_num_edges(), get_graph_node_labels(), get_graph_edges(), get_graph_adjacence_matrix() .. note:: These functions allow to collect all the graph's informations. """ - return [i for i in self.__internal_to_original_node_ids[graph_id].values()] + return [i for i in self._internal_to_original_node_ids[graph_id].values()] def get_node_cost(self, node_label_1, node_label_2): - return self.__ged_data.node_cost(node_label_1, node_label_2) + return self._ged_data.node_cost(node_label_1, node_label_2) def get_node_rel_cost(self, node_label_1, node_label_2): @@ -654,7 +654,7 @@ class GEDEnv(object): node_label_1 = tuple(sorted(node_label_1.items(), key=lambda kv: kv[0])) if isinstance(node_label_2, dict): node_label_2 = tuple(sorted(node_label_2.items(), key=lambda kv: kv[0])) - return self.__ged_data._edit_cost.node_rel_cost_fun(node_label_1, node_label_2) # @todo: may need to use node_cost() instead (or change node_cost() and modify ged_method for pre-defined cost matrices.) + return self._ged_data._edit_cost.node_rel_cost_fun(node_label_1, node_label_2) # @todo: may need to use node_cost() instead (or change node_cost() and modify ged_method for pre-defined cost matrices.) def get_node_del_cost(self, node_label): @@ -667,7 +667,7 @@ class GEDEnv(object): """ if isinstance(node_label, dict): node_label = tuple(sorted(node_label.items(), key=lambda kv: kv[0])) - return self.__ged_data._edit_cost.node_del_cost_fun(node_label) + return self._ged_data._edit_cost.node_del_cost_fun(node_label) def get_node_ins_cost(self, node_label): @@ -680,11 +680,11 @@ class GEDEnv(object): """ if isinstance(node_label, dict): node_label = tuple(sorted(node_label.items(), key=lambda kv: kv[0])) - return self.__ged_data._edit_cost.node_ins_cost_fun(node_label) + return self._ged_data._edit_cost.node_ins_cost_fun(node_label) def get_edge_cost(self, edge_label_1, edge_label_2): - return self.__ged_data.edge_cost(edge_label_1, edge_label_2) + return self._ged_data.edge_cost(edge_label_1, edge_label_2) def get_edge_rel_cost(self, edge_label_1, edge_label_2): @@ -700,7 +700,7 @@ class GEDEnv(object): edge_label_1 = tuple(sorted(edge_label_1.items(), key=lambda kv: kv[0])) if isinstance(edge_label_2, dict): edge_label_2 = tuple(sorted(edge_label_2.items(), key=lambda kv: kv[0])) - return self.__ged_data._edit_cost.edge_rel_cost_fun(edge_label_1, edge_label_2) + return self._ged_data._edit_cost.edge_rel_cost_fun(edge_label_1, edge_label_2) def get_edge_del_cost(self, edge_label): @@ -713,7 +713,7 @@ class GEDEnv(object): """ if isinstance(edge_label, dict): edge_label = tuple(sorted(edge_label.items(), key=lambda kv: kv[0])) - return self.__ged_data._edit_cost.edge_del_cost_fun(edge_label) + return self._ged_data._edit_cost.edge_del_cost_fun(edge_label) def get_edge_ins_cost(self, edge_label): @@ -726,8 +726,8 @@ class GEDEnv(object): """ if isinstance(edge_label, dict): edge_label = tuple(sorted(edge_label.items(), key=lambda kv: kv[0])) - return self.__ged_data._edit_cost.edge_ins_cost_fun(edge_label) + return self._ged_data._edit_cost.edge_ins_cost_fun(edge_label) def get_all_graph_ids(self): - return [i for i in range(0, self.__ged_data._num_graphs_without_shuffled_copies)] \ No newline at end of file + return [i for i in range(0, self._ged_data._num_graphs_without_shuffled_copies)] \ No newline at end of file diff --git a/gklearn/ged/env/node_map.py b/gklearn/ged/env/node_map.py index 7ca4798..71b68d8 100644 --- a/gklearn/ged/env/node_map.py +++ b/gklearn/ged/env/node_map.py @@ -12,9 +12,9 @@ from gklearn.utils import dummy_node, undefined_node class NodeMap(object): def __init__(self, num_nodes_g, num_nodes_h): - self.__forward_map = [undefined_node()] * num_nodes_g - self.__backward_map = [undefined_node()] * num_nodes_h - self.__induced_cost = np.inf + self._forward_map = [undefined_node()] * num_nodes_g + self._backward_map = [undefined_node()] * num_nodes_h + self._induced_cost = np.inf def clear(self): @@ -23,29 +23,29 @@ class NodeMap(object): * @brief Clears the node map. */ """ - self.__forward_map = [undefined_node() for i in range(len(self.__forward_map))] - self.__backward_map = [undefined_node() for i in range(len(self.__backward_map))] + self._forward_map = [undefined_node() for i in range(len(self._forward_map))] + self._backward_map = [undefined_node() for i in range(len(self._backward_map))] def num_source_nodes(self): - return len(self.__forward_map) + return len(self._forward_map) def num_target_nodes(self): - return len(self.__backward_map) + return len(self._backward_map) def image(self, node): - if node < len(self.__forward_map): - return self.__forward_map[node] + if node < len(self._forward_map): + return self._forward_map[node] else: raise Exception('The node with ID ', str(node), ' is not contained in the source nodes of the node map.') return undefined_node() def pre_image(self, node): - if node < len(self.__backward_map): - return self.__backward_map[node] + if node < len(self._backward_map): + return self._backward_map[node] else: raise Exception('The node with ID ', str(node), ' is not contained in the target nodes of the node map.') return undefined_node() @@ -53,50 +53,50 @@ class NodeMap(object): def as_relation(self, relation): relation.clear() - for i in range(0, len(self.__forward_map)): - k = self.__forward_map[i] + for i in range(0, len(self._forward_map)): + k = self._forward_map[i] if k != undefined_node(): relation.append(tuple((i, k))) - for k in range(0, len(self.__backward_map)): - i = self.__backward_map[k] + for k in range(0, len(self._backward_map)): + i = self._backward_map[k] if i == dummy_node(): relation.append(tuple((i, k))) def add_assignment(self, i, k): if i != dummy_node(): - if i < len(self.__forward_map): - self.__forward_map[i] = k + if i < len(self._forward_map): + self._forward_map[i] = k else: raise Exception('The node with ID ', str(i), ' is not contained in the source nodes of the node map.') if k != dummy_node(): - if k < len(self.__backward_map): - self.__backward_map[k] = i + if k < len(self._backward_map): + self._backward_map[k] = i else: raise Exception('The node with ID ', str(k), ' is not contained in the target nodes of the node map.') def set_induced_cost(self, induced_cost): - self.__induced_cost = induced_cost + self._induced_cost = induced_cost def induced_cost(self): - return self.__induced_cost + return self._induced_cost @property def forward_map(self): - return self.__forward_map + return self._forward_map @forward_map.setter def forward_map(self, value): - self.__forward_map = value + self._forward_map = value @property def backward_map(self): - return self.__backward_map + return self._backward_map @backward_map.setter def backward_map(self, value): - self.__backward_map = value \ No newline at end of file + self._backward_map = value \ No newline at end of file