Merge pull request #23 from jajupmochi/v0.2

V0.2

Author: jajupmochi

gklearn/experiments/ged/check_results_of_ged_env.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jun 25 11:31:46 2020
+
+@author: ljia
+"""
+
+def xp_check_results_of_GEDEnv():
+	"""Compare results of GEDEnv to GEDLIB.
+	"""
+	"""**1.   Get dataset.**"""
+
+	from gklearn.utils import Dataset
+	
+	# Predefined dataset name, use dataset "MUTAG".
+	ds_name = 'MUTAG'
+	
+	# Initialize a Dataset.
+	dataset = Dataset()
+	# Load predefined dataset "MUTAG".
+	dataset.load_predefined_dataset(ds_name)
+
+	results1 = compute_geds_by_GEDEnv(dataset)
+	results2 = compute_geds_by_GEDLIB(dataset)
+	
+	# Show results.
+	import pprint
+	pp = pprint.PrettyPrinter(indent=4) # pretty print
+	print('Restuls using GEDEnv:')
+	pp.pprint(results1)
+	print()
+	print('Restuls using GEDLIB:')
+	pp.pprint(results2)
+	
+	return results1, results2
+	
+	
+def compute_geds_by_GEDEnv(dataset):
+	from gklearn.ged.env import GEDEnv		
+	import numpy as np
+	
+	graph1 = dataset.graphs[0]
+	graph2 = dataset.graphs[1]
+		
+	ged_env = GEDEnv() # initailize GED environment.
+	ged_env.set_edit_cost('CONSTANT', # GED cost type.
+	                      edit_cost_constants=[3, 3, 1, 3, 3, 1] # edit costs.
+						  )
+	for g in dataset.graphs[0:10]:
+		ged_env.add_nx_graph(g, '')
+# 	ged_env.add_nx_graph(graph1, '') # add graph1
+# 	ged_env.add_nx_graph(graph2, '') # add graph2
+	listID = ged_env.get_all_graph_ids() # get list IDs of graphs
+	ged_env.init(init_type='LAZY_WITHOUT_SHUFFLED_COPIES') # initialize GED environment.
+	options = {'threads': 1 # parallel threads.
+			   }
+	ged_env.set_method('BIPARTITE', # GED method.
+	                   options # options for GED method.
+					   )
+	ged_env.init_method() # initialize GED method.
+	
+	ged_mat = np.empty((10, 10))
+	for i in range(0, 10):
+		for j in range(i, 10):
+			ged_env.run_method(i, j) # run.
+			ged_mat[i, j] = ged_env.get_upper_bound(i, j)
+			ged_mat[j, i] = ged_mat[i, j]
+	
+	results = {}
+	results['pi_forward'] = ged_env.get_forward_map(listID[0], listID[1]) # forward map.
+	results['pi_backward'] = ged_env.get_backward_map(listID[0], listID[1]) # backward map.
+	results['upper_bound'] = ged_env.get_upper_bound(listID[0], listID[1])	# GED bewteen two graphs.
+	results['runtime'] = ged_env.get_runtime(listID[0], listID[1])
+	results['init_time'] = ged_env.get_init_time()
+	results['ged_mat'] = ged_mat
+	
+	return results
+
+
+def compute_geds_by_GEDLIB(dataset):
+	from gklearn.gedlib import librariesImport, gedlibpy	
+	from gklearn.ged.util import ged_options_to_string
+	import numpy as np
+	
+	graph1 = dataset.graphs[5]
+	graph2 = dataset.graphs[6]
+		
+	ged_env = gedlibpy.GEDEnv() # initailize GED environment.
+	ged_env.set_edit_cost('CONSTANT', # GED cost type.
+	                      edit_cost_constant=[3, 3, 1, 3, 3, 1] # edit costs.
+						  )  
+# 	ged_env.add_nx_graph(graph1, '') # add graph1
+# 	ged_env.add_nx_graph(graph2, '') # add graph2
+	for g in dataset.graphs[0:10]:
+		ged_env.add_nx_graph(g, '')
+	listID = ged_env.get_all_graph_ids() # get list IDs of graphs
+	ged_env.init(init_option='LAZY_WITHOUT_SHUFFLED_COPIES') # initialize GED environment.
+	options = {'initialization-method': 'RANDOM', # or 'NODE', etc.
+	           'threads': 1 # parallel threads.
+			   }
+	ged_env.set_method('BIPARTITE', # GED method.
+	                   ged_options_to_string(options) # options for GED method.
+					   )
+	ged_env.init_method() # initialize GED method.
+	
+	ged_mat = np.empty((10, 10))
+	for i in range(0, 10):
+		for j in range(i, 10):
+			ged_env.run_method(i, j) # run.
+			ged_mat[i, j] = ged_env.get_upper_bound(i, j)
+			ged_mat[j, i] = ged_mat[i, j]
+	
+	results = {}
+	results['pi_forward'] = ged_env.get_forward_map(listID[0], listID[1]) # forward map.
+	results['pi_backward'] = ged_env.get_backward_map(listID[0], listID[1]) # backward map.
+	results['upper_bound'] = ged_env.get_upper_bound(listID[0], listID[1])	# GED bewteen two graphs.
+	results['runtime'] = ged_env.get_runtime(listID[0], listID[1])
+	results['init_time'] = ged_env.get_init_time()
+	results['ged_mat'] = ged_mat
+	
+	return results
+		
+	
+if __name__ == '__main__':
+	results1, results2 = xp_check_results_of_GEDEnv()

gklearn/ged/env/ged_data.py

@@ -23,6 +23,8 @@ def __init__(self):
 		self._edit_cost = None
 		self._node_costs = None
 		self._edge_costs = None
+		self._node_label_costs = None
+		self._edge_label_costs = None
 		self._node_labels = []
 		self._edge_labels = []
 		self._init_type = Options.InitType.EAGER_WITHOUT_SHUFFLED_COPIES
@@ -41,6 +43,17 @@ def num_graphs(self):
 		return len(self._graphs)
 
 
+	def graph(self, graph_id):
+		"""
+	/*!
+	 * @brief Provides access to a graph.
+	 * @param[in] graph_id The ID of the graph.
+	 * @return Constant reference to the graph with ID @p graph_id.
+	 */
+		"""
+		return self._graphs[graph_id]
+	
+	
 	def shuffled_graph_copies_available(self):
 		"""
 	/*!
@@ -51,6 +64,16 @@ def shuffled_graph_copies_available(self):
 		return (self._init_type == Options.InitType.EAGER_WITH_SHUFFLED_COPIES or self._init_type == Options.InitType.LAZY_WITH_SHUFFLED_COPIES)
 
 
+	def num_graphs_without_shuffled_copies(self):
+		"""
+	/*!
+	 * @brief Returns the number of graphs in the instance without the shuffled copies.
+	 * @return Number of graphs without shuffled copies contained in the instance.
+	 */
+		"""
+		return self._num_graphs_without_shuffled_copies
+	
+	
 	def node_cost(self, label1, label2):
 		"""
 	/*!
@@ -63,15 +86,21 @@ def node_cost(self, label1, label2):
 	 * and 0 otherwise.
 	 */
 		"""
-		if self._eager_init(): # @todo: check if correct
-			return self._node_costs[label1, label2]
-		if label1 == label2:
-			return 0
-		if label1 == SpecialLabel.DUMMY: # @todo: check dummy
-			return self._edit_cost.node_ins_cost_fun(label2) # self._node_labels[label2 - 1]) # @todo: check
-		if label2 == SpecialLabel.DUMMY: # @todo: check dummy
-			return self._edit_cost.node_del_cost_fun(label1) # self._node_labels[label1 - 1])
-		return self._edit_cost.node_rel_cost_fun(label1, label2) # self._node_labels[label1 - 1], self._node_labels[label2 - 1])
+		if self._node_label_costs is None:
+			if self._eager_init(): # @todo: check if correct
+				return self._node_costs[label1, label2]
+			if label1 == label2:
+				return 0
+			if label1 == SpecialLabel.DUMMY: # @todo: check dummy
+				return self._edit_cost.node_ins_cost_fun(label2) # self._node_labels[label2 - 1]) # @todo: check
+			if label2 == SpecialLabel.DUMMY: # @todo: check dummy
+				return self._edit_cost.node_del_cost_fun(label1) # self._node_labels[label1 - 1])
+			return self._edit_cost.node_rel_cost_fun(label1, label2) # self._node_labels[label1 - 1], self._node_labels[label2 - 1])
+		# use pre-computed node label costs.
+		else:
+			id1 = 0 if label1 == SpecialLabel.DUMMY else self._node_label_to_id(label1) # @todo: this is slow.
+			id2 = 0 if label2 == SpecialLabel.DUMMY else self._node_label_to_id(label2)
+			return self._node_label_costs[id1, id2]
 
 
 	def edge_cost(self, label1, label2):
@@ -86,15 +115,22 @@ def edge_cost(self, label1, label2):
 	 * and 0 otherwise.
 	 */
 		"""
-		if self._eager_init(): # @todo: check if correct
-			return self._node_costs[label1, label2]
-		if label1 == label2:
-			return 0
-		if label1 == SpecialLabel.DUMMY:
-			return self._edit_cost.edge_ins_cost_fun(label2) # self._edge_labels[label2 - 1])
-		if label2 == SpecialLabel.DUMMY:
-			return self._edit_cost.edge_del_cost_fun(label1) # self._edge_labels[label1 - 1])
-		return self._edit_cost.edge_rel_cost_fun(label1, label2) # self._edge_labels[label1 - 1], self._edge_labels[label2 - 1])
+		if self._edge_label_costs is None:
+			if self._eager_init(): # @todo: check if correct
+				return self._node_costs[label1, label2]
+			if label1 == label2:
+				return 0
+			if label1 == SpecialLabel.DUMMY:
+				return self._edit_cost.edge_ins_cost_fun(label2) # self._edge_labels[label2 - 1])
+			if label2 == SpecialLabel.DUMMY:
+				return self._edit_cost.edge_del_cost_fun(label1) # self._edge_labels[label1 - 1])
+			return self._edit_cost.edge_rel_cost_fun(label1, label2) # self._edge_labels[label1 - 1], self._edge_labels[label2 - 1])
+		
+		# use pre-computed edge label costs.
+		else:
+			id1 = 0 if label1 == SpecialLabel.DUMMY else self._edge_label_to_id(label1) # @todo: this is slow.
+			id2 = 0 if label2 == SpecialLabel.DUMMY else self._edge_label_to_id(label2)
+			return self._edge_label_costs[id1, id2]
 
 
 	def compute_induced_cost(self, g, h, node_map):
@@ -177,5 +213,37 @@ def _set_edit_cost(self, edit_cost, edit_cost_constants):
 		self._delete_edit_cost = True
 
 
+	def id_to_node_label(self, label_id):
+		if label_id > len(self._node_labels) or label_id == 0:
+			raise Exception('Invalid node label ID', str(label_id), '.')
+		return self._node_labels[label_id - 1]
+		
+		
+	def _node_label_to_id(self, node_label):
+		n_id = 0
+		for n_l in self._node_labels:
+			if n_l == node_label:
+				return n_id + 1
+			n_id += 1
+		self._node_labels.append(node_label)
+		return n_id + 1
+
+
+	def id_to_edge_label(self, label_id):
+		if label_id > len(self._edge_labels) or label_id == 0:
+			raise Exception('Invalid edge label ID', str(label_id), '.')
+		return self._edge_labels[label_id - 1]
+
+
+	def _edge_label_to_id(self, edge_label):
+		e_id = 0
+		for e_l in self._edge_labels:
+			if e_l == edge_label:
+				return e_id + 1
+			e_id += 1
+		self._edge_labels.append(edge_label)
+		return e_id + 1
+		
+		
 	def _eager_init(self):
 		return (self._init_type == Options.InitType.EAGER_WITHOUT_SHUFFLED_COPIES or self._init_type == Options.InitType.EAGER_WITH_SHUFFLED_COPIES)