Merge pull request #21 from jajupmochi/v0.2

Add ged module.

Author: jajupmochi

.coveragerc

@@ -1,2 +1,4 @@
 [run]
-omit = gklearn/tests/*
+omit = 
+	gklearn/tests/*
+	gklearn/examples/*

gklearn/examples/compute_graph_edit_distance.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+"""compute_graph_edit_distance.ipynb
+
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/1Wfgn7WVuyOQQgwOvdUQBz0BzEVdp0YM3
+
+**This script demonstrates how to compute a graph edit distance.**
+---
+
+**0.   Install `graphkit-learn`.**
+"""
+
+"""**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)
+graph1 = dataset.graphs[0]
+graph2 = dataset.graphs[1]
+print(graph1, graph2)
+
+"""**2.  Compute graph edit distance.**"""
+
+from gklearn.ged.env import GEDEnv
+
+
+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.
+					  )  
+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 = {'initialization_method': 'RANDOM', # or 'NODE', etc.
+           'threads': 1 # parallel threads.
+		   }
+ged_env.set_method('BIPARTITE', # GED method.
+                   options # options for GED method.
+				   )
+ged_env.init_method() # initialize GED method.
+
+ged_env.run_method(listID[0], listID[1]) # run.
+
+pi_forward = ged_env.get_forward_map(listID[0], listID[1]) # forward map.
+pi_backward = ged_env.get_backward_map(listID[0], listID[1]) # backward map.
+dis = ged_env.get_upper_bound(listID[0], listID[1])	# GED bewteen two graphs.
+print(pi_forward)
+print(pi_backward)
+print(dis)

gklearn/ged/edit_costs/__init__.py

@@ -0,0 +1,2 @@
+from gklearn.ged.edit_costs.edit_cost import EditCost
+from gklearn.ged.edit_costs.constant import Constant

gklearn/ged/edit_costs/constant.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Jun 17 17:52:23 2020
+
+@author: ljia
+"""
+from gklearn.ged.edit_costs import EditCost
+
+
+class Constant(EditCost):
+	"""Implements constant edit cost functions.
+	"""
+
+	
+	def __init__(self, node_ins_cost=1, node_del_cost=1, node_rel_cost=1, edge_ins_cost=1, edge_del_cost=1, edge_rel_cost=1):
+		self.__node_ins_cost = node_ins_cost
+		self.__node_del_cost = node_del_cost
+		self.__node_rel_cost = node_rel_cost
+		self.__edge_ins_cost = edge_ins_cost
+		self.__edge_del_cost = edge_del_cost
+		self.__edge_rel_cost = edge_rel_cost
+		
+		
+	def node_ins_cost_fun(self, node_label):
+		return self.__node_ins_cost
+	
+	
+	def node_del_cost_fun(self, node_label):
+		return self.__node_del_cost
+	
+	
+	def node_rel_cost_fun(self, node_label_1, node_label_2):
+		if node_label_1 != node_label_2:
+			return self.__node_rel_cost
+		return 0
+	
+	
+	def edge_ins_cost_fun(self, edge_label):
+		return self.__edge_ins_cost
+	
+	
+	def edge_del_cost_fun(self, edge_label):
+		return self.__edge_del_cost
+	
+	
+	def edge_rel_cost_fun(self, edge_label_1, edge_label_2):
+		if edge_label_1 != edge_label_2:
+			return self.__edge_rel_cost
+		return 0

gklearn/ged/edit_costs/edit_cost.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Jun 17 17:49:24 2020
+
+@author: ljia
+"""
+
+
+class EditCost(object):
+	
+	
+	def __init__(self):
+		pass
+	
+	
+	def node_ins_cost_fun(self, node_label):
+		"""
+	/*!
+	 * @brief Node insertions cost function.
+	 * @param[in] node_label A node label.
+	 * @return The cost of inserting a node with label @p node_label.
+	 * @note Must be implemented by derived classes of ged::EditCosts.
+	 */		
+		"""
+		return 0
+
+	
+	def node_del_cost_fun(self, node_label):
+		"""
+	/*!
+	 * @brief Node deletion cost function.
+	 * @param[in] node_label A node label.
+	 * @return The cost of deleting a node with label @p node_label.
+	 * @note Must be implemented by derived classes of ged::EditCosts.
+	 */		
+		"""
+		return 0
+
+	
+	def node_rel_cost_fun(self, node_label_1, node_label_2):
+		"""
+	/*!
+	 * @brief Node relabeling cost function.
+	 * @param[in] node_label_1 A node label.
+	 * @param[in] node_label_2 A node label.
+	 * @return The cost of changing a node's label from @p node_label_1 to @p node_label_2.
+	 * @note Must be implemented by derived classes of ged::EditCosts.
+	 */		
+		"""
+		return 0
+
+	
+	def edge_ins_cost_fun(self, edge_label):
+		"""
+	/*!
+	 * @brief Edge insertion cost function.
+	 * @param[in] edge_label An edge label.
+	 * @return The cost of inserting an edge with label @p edge_label.
+	 * @note Must be implemented by derived classes of ged::EditCosts.
+	 */		
+		"""
+		return 0
+
+	
+	def edge_del_cost_fun(self, edge_label):
+		"""
+	/*!
+	 * @brief Edge deletion cost function.
+	 * @param[in] edge_label An edge label.
+	 * @return The cost of deleting an edge with label @p edge_label.
+	 * @note Must be implemented by derived classes of ged::EditCosts.
+	 */		
+		"""
+		return 0
+
+	
+	def edge_rel_cost_fun(self, edge_label_1, edge_label_2):
+		"""
+	/*!
+	 * @brief Edge relabeling cost function.
+	 * @param[in] edge_label_1 An edge label.
+	 * @param[in] edge_label_2 An edge label.
+	 * @return The cost of changing an edge's label from @p edge_label_1 to @p edge_label_2.
+	 * @note Must be implemented by derived classes of ged::EditCosts.
+	 */		
+		"""
+		return 0

gklearn/ged/env/__init__.py

@@ -1,2 +1,4 @@
-from gklearn.ged.env.common_types import AlgorithmState
+from gklearn.ged.env.common_types import Options, OptionsStringMap, AlgorithmState
+from gklearn.ged.env.ged_data import GEDData
+from gklearn.ged.env.ged_env import GEDEnv
 from gklearn.ged.env.node_map import NodeMap

gklearn/ged/env/common_types.py

@@ -8,11 +8,152 @@
 
 from enum import Enum, unique
 
+
+class Options(object):
+	"""Contains enums for options employed by ged::GEDEnv.
+	"""
+
+
+	@unique
+	class GEDMethod(Enum):
+		"""Selects the method.
+		"""
+# @todo: what is this? #ifdef GUROBI
+		F1 = 1                  # Selects ged::F1.
+		F2 = 2                 # Selects ged::F2.
+		COMPACT_MIP = 3         # Selects ged::CompactMIP.
+		BLP_NO_EDGE_LABELS = 4  # Selects ged::BLPNoEdgeLabels.
+#endif /* GUROBI */
+		BRANCH = 5              # Selects ged::Branch.
+		BRANCH_FAST = 6         # Selects ged::BranchFast.
+		BRANCH_TIGHT = 7        # Selects ged::BranchTight.
+		BRANCH_UNIFORM = 8      # Selects ged::BranchUniform.
+		BRANCH_COMPACT = 9      # Selects ged::BranchCompact.
+		PARTITION = 10           # Selects ged::Partition.
+		HYBRID = 11              # Selects ged::Hybrid.
+		RING = 12                # Selects ged::Ring.
+		ANCHOR_AWARE_GED = 13    # Selects ged::AnchorAwareGED.
+		WALKS = 14               # Selects ged::Walks.
+		IPFP = 15                # Selects ged::IPFP
+		BIPARTITE = 16           # Selects ged::Bipartite.
+		SUBGRAPH = 17            # Selects ged::Subgraph.
+		NODE = 18                # Selects ged::Node.
+		RING_ML = 19             # Selects ged::RingML.
+		BIPARTITE_ML = 20        # Selects ged::BipartiteML.
+		REFINE = 21              # Selects ged::Refine.
+		BP_BEAM = 22             # Selects ged::BPBeam.
+		SIMULATED_ANNEALING = 23 # Selects ged::SimulatedAnnealing.
+		HED = 24				 # Selects ged::HED.
+		STAR = 25				 # Selects ged::Star.
+
+
+	@unique
+	class EditCosts(Enum):
+		"""Selects the edit costs.
+		"""
+		CHEM_1 = 1      # Selects ged::CHEM1.
+		CHEM_2 = 2      # Selects ged::CHEM2.
+		CMU = 3         # Selects ged::CMU.
+		GREC_1 = 4      # Selects ged::GREC1.
+		GREC_2 = 5      # Selects ged::GREC2.
+		PROTEIN = 6     # Selects ged::Protein.
+		FINGERPRINT = 7 # Selects ged::Fingerprint.
+		LETTER = 8      # Selects ged::Letter.
+		LETTER2 = 9     # Selects ged:Letter2.
+		NON_SYMBOLIC = 10 # Selects ged:NonSymbolic.
+		CONSTANT = 11    # Selects ged::Constant.
+		
+		
+	@unique
+	class InitType(Enum):
+		"""@brief Selects the initialization type of the environment.
+		* @details If eager initialization is selected, all edit costs are pre-computed when initializing the environment.
+		* Otherwise, they are computed at runtime. If initialization with shuffled copies is selected, shuffled copies of
+		* all graphs are created. These copies are used when calling ged::GEDEnv::run_method() with two identical graph IDs.
+		* In this case, one of the IDs is internally replaced by the ID of the shuffled copy and the graph is hence
+		* compared to an isomorphic but non-identical graph. If initialization without shuffled copies is selected, no shuffled copies
+		* are created and calling ged::GEDEnv::run_method() with two identical graph IDs amounts to comparing a graph to itself.
+		"""
+		LAZY_WITHOUT_SHUFFLED_COPIES = 1  # Lazy initialization, no shuffled graph copies are constructed.
+		EAGER_WITHOUT_SHUFFLED_COPIES = 2 # Eager initialization, no shuffled graph copies are constructed.
+		LAZY_WITH_SHUFFLED_COPIES = 3     # Lazy initialization, shuffled graph copies are constructed.
+		EAGER_WITH_SHUFFLED_COPIES = 4    # Eager initialization, shuffled graph copies are constructed.	
+	
+	
+	@unique
+	class AlgorithmState(Enum):
+		"""can be used to specify the state of an algorithm.
+		"""
+		CALLED = 1 # The algorithm has been called.
+		INITIALIZED = 2 # The algorithm has been initialized.
+		CONVERGED = 3 # The algorithm has converged.
+		TERMINATED = 4 # The algorithm has terminated.	
+
+
+class OptionsStringMap(object):
+	
+	
+	# Map of available computation methods between enum type and string. 
+	GEDMethod = {
+		"BRANCH": Options.GEDMethod.BRANCH,
+		"BRANCH_FAST": Options.GEDMethod.BRANCH_FAST,
+		"BRANCH_TIGHT": Options.GEDMethod.BRANCH_TIGHT,
+		"BRANCH_UNIFORM": Options.GEDMethod.BRANCH_UNIFORM,
+		"BRANCH_COMPACT": Options.GEDMethod.BRANCH_COMPACT,
+		"PARTITION": Options.GEDMethod.PARTITION,
+		"HYBRID": Options.GEDMethod.HYBRID,
+		"RING": Options.GEDMethod.RING,
+		"ANCHOR_AWARE_GED": Options.GEDMethod.ANCHOR_AWARE_GED,
+		"WALKS": Options.GEDMethod.WALKS,
+		"IPFP": Options.GEDMethod.IPFP,
+		"BIPARTITE": Options.GEDMethod.BIPARTITE,
+		"SUBGRAPH": Options.GEDMethod.SUBGRAPH,
+		"NODE": Options.GEDMethod.NODE,
+		"RING_ML": Options.GEDMethod.RING_ML,
+		"BIPARTITE_ML": Options.GEDMethod.BIPARTITE_ML,
+		"REFINE": Options.GEDMethod.REFINE,
+		"BP_BEAM": Options.GEDMethod.BP_BEAM,
+		"SIMULATED_ANNEALING": Options.GEDMethod.SIMULATED_ANNEALING,
+		"HED": Options.GEDMethod.HED,
+		"STAR": Options.GEDMethod.STAR,
+		# ifdef GUROBI
+		"F1": Options.GEDMethod.F1,
+		"F2": Options.GEDMethod.F2,
+		"COMPACT_MIP": Options.GEDMethod.COMPACT_MIP,
+		"BLP_NO_EDGE_LABELS": Options.GEDMethod.BLP_NO_EDGE_LABELS
+	}
+
+	
+	# Map of available edit cost functions between enum type and string.
+	EditCosts = {
+		"CHEM_1": Options.EditCosts.CHEM_1,
+		"CHEM_2": Options.EditCosts.CHEM_2,
+		"CMU": Options.EditCosts.CMU,
+		"GREC_1": Options.EditCosts.GREC_1,
+		"GREC_2": Options.EditCosts.GREC_2,
+		"LETTER": Options.EditCosts.LETTER,
+		"LETTER2": Options.EditCosts.LETTER2,
+		"NON_SYMBOLIC": Options.EditCosts.NON_SYMBOLIC,
+		"FINGERPRINT": Options.EditCosts.FINGERPRINT,
+		"PROTEIN": Options.EditCosts.PROTEIN,
+		"CONSTANT": Options.EditCosts.CONSTANT
+	}
+	
+	# Map of available initialization types of the environment between enum type and string.
+	InitType = {
+		"LAZY_WITHOUT_SHUFFLED_COPIES": Options.InitType.LAZY_WITHOUT_SHUFFLED_COPIES,
+		"EAGER_WITHOUT_SHUFFLED_COPIES": Options.InitType.EAGER_WITHOUT_SHUFFLED_COPIES,
+		"LAZY_WITH_SHUFFLED_COPIES": Options.InitType.LAZY_WITH_SHUFFLED_COPIES,
+		"LAZY_WITH_SHUFFLED_COPIES": Options.InitType.LAZY_WITH_SHUFFLED_COPIES
+	}
+	
+
 @unique
 class AlgorithmState(Enum):
-    """can be used to specify the state of an algorithm.
-    """
-    CALLED = 1 # The algorithm has been called.
-    INITIALIZED = 2 # The algorithm has been initialized.
-    CONVERGED = 3 # The algorithm has converged.
-    TERMINATED = 4 # The algorithm has terminated.
+	"""can be used to specify the state of an algorithm.
+	"""
+	CALLED = 1 # The algorithm has been called.
+	INITIALIZED = 2 # The algorithm has been initialized.
+	CONVERGED = 3 # The algorithm has converged.
+	TERMINATED = 4 # The algorithm has terminated.
+