graphkit-learn/gklearn/ged/methods/lsape_based_method.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Jun 18 16:01:24 2020

@author: ljia
"""
import numpy as np
import networkx as nx
from gklearn.ged.methods import GEDMethod
from gklearn.ged.util import LSAPESolver, misc
from gklearn.ged.env import NodeMap
	

class LSAPEBasedMethod(GEDMethod):
	
	
	def __init__(self, ged_data):
		super().__init__(ged_data)
		self._lsape_model = None # @todo: LSAPESolver::ECBP
		self._greedy_method = None # @todo: LSAPESolver::BASIC
		self._compute_lower_bound = True
		self._solve_optimally = True
		self._num_threads = 1
		self._centrality_method = 'NODE' # @todo
		self._centrality_weight = 0.7
		self._centralities = {}
		self._max_num_solutions = 1
		
		
	def populate_instance_and_run_as_util(self, g, h): #, lsape_instance):
		"""
	/*!
	 * @brief Runs the method with options specified by set_options() and provides access to constructed LSAPE instance.
	 * @param[in] g Input graph.
	 * @param[in] h Input graph.
	 * @param[out] result Result variable.
	 * @param[out] lsape_instance LSAPE instance.
	 */
		"""
		result = {'node_maps': [], 'lower_bound': 0, 'upper_bound': np.inf}
		
		# Populate the LSAPE instance and set up the solver.
		nb1, nb2 = nx.number_of_nodes(g), nx.number_of_nodes(h)
		lsape_instance = np.ones((nb1 + nb2, nb1 + nb2)) * np.inf
# 		lsape_instance = np.empty((nx.number_of_nodes(g) + 1, nx.number_of_nodes(h) + 1))
		self.populate_instance(g, h, lsape_instance)
		
# 		nb1, nb2 = nx.number_of_nodes(g), nx.number_of_nodes(h)
# 		lsape_instance_new = np.empty((nb1 + nb2, nb1 + nb2)) * np.inf
# 		lsape_instance_new[nb1:, nb2:] = 0
# 		lsape_instance_new[0:nb1, 0:nb2] = lsape_instance[0:nb1, 0:nb2]
# 		for i in range(nb1): # all u's neighbor
# 			lsape_instance_new[i, nb2 + i] = lsape_instance[i, nb2]
# 		for i in range(nb2): # all u's neighbor
# 			lsape_instance_new[nb1 + i, i] = lsape_instance[nb2, i]
# 		lsape_solver = LSAPESolver(lsape_instance_new)
		
		lsape_solver = LSAPESolver(lsape_instance)
		
		# Solve the LSAPE instance.
		if self._solve_optimally:
			lsape_solver.set_model(self._lsape_model)
		else:
			lsape_solver.set_greedy_method(self._greedy_method)
		lsape_solver.solve(self._max_num_solutions)
		
		# Compute and store lower and upper bound.
		if self._compute_lower_bound and self._solve_optimally:
			result['lower_bound'] = lsape_solver.minimal_cost() * self._lsape_lower_bound_scaling_factor(g, h) # @todo: test
		
		for solution_id in range(0, lsape_solver.num_solutions()):
			result['node_maps'].append(NodeMap(nx.number_of_nodes(g), nx.number_of_nodes(h)))
			misc.construct_node_map_from_solver(lsape_solver, result['node_maps'][-1], solution_id)
			self._ged_data.compute_induced_cost(g, h, result['node_maps'][-1])
			
		# Add centralities and reoptimize.
		if self._centrality_weight > 0 and self._centrality_method != 'NODE':
			print('This is not implemented.')
			pass # @todo
			
		# Sort the node maps and set the upper bound.
		if len(result['node_maps']) > 1 or len(result['node_maps']) > self._max_num_solutions:
			print('This is not implemented.') # @todo:
			pass
		if len(result['node_maps']) == 0:
			result['upper_bound'] = np.inf
		else:
			result['upper_bound'] = result['node_maps'][0].induced_cost()
					
		return result
			
		
	
	def populate_instance(self, g, h, lsape_instance):
		"""
	/*!
	 * @brief Populates the LSAPE instance.
	 * @param[in] g Input graph.
	 * @param[in] h Input graph.
	 * @param[out] lsape_instance LSAPE instance.
	 */
		"""
		if not self._initialized:
			pass
		# @todo: if (not this->initialized_) {
		self._lsape_populate_instance(g, h, lsape_instance)
		lsape_instance[nx.number_of_nodes(g):, nx.number_of_nodes(h):] = 0
# 		lsape_instance[nx.number_of_nodes(g), nx.number_of_nodes(h)] = 0
		
	
	###########################################################################
	# Member functions inherited from GEDMethod.
	###########################################################################
	
	
	def _ged_init(self):
		self._lsape_pre_graph_init(False)
		for graph in self._ged_data._graphs:
			self._init_graph(graph)
		self._lsape_init()
		
		
	def _ged_run(self, g, h):
# 		lsape_instance = np.empty((0, 0))
		result = self.populate_instance_and_run_as_util(g, h) # , lsape_instance)
		return result
		
		
	def _ged_parse_option(self, option, arg):
		is_valid_option = False
		
		if option == 'threads': # @todo: try.. catch...
			self._num_threads = arg
			is_valid_option = True
		elif option == 'lsape_model':
			self._lsape_model = arg # @todo
			is_valid_option = True
		elif option == 'greedy_method':
			self._greedy_method = arg # @todo
			is_valid_option = True
		elif option == 'optimal':
			self._solve_optimally = arg # @todo
			is_valid_option = True
		elif option == 'centrality_method':
			self._centrality_method = arg # @todo
			is_valid_option = True
		elif option == 'centrality_weight':
			self._centrality_weight = arg # @todo
			is_valid_option = True
		elif option == 'max_num_solutions':
			if arg == 'ALL':
				self._max_num_solutions = -1
			else:				
				self._max_num_solutions = arg # @todo
			is_valid_option = True
			
		is_valid_option = is_valid_option or self._lsape_parse_option(option, arg)
		is_valid_option = True # @todo: this is not in the C++ code.
		return is_valid_option
		
		
	def _ged_set_default_options(self):
		self._lsape_model = None # @todo: LSAPESolver::ECBP
		self._greedy_method = None # @todo: LSAPESolver::BASIC
		self._solve_optimally = True
		self._num_threads = 1
		self._centrality_method = 'NODE' # @todo
		self._centrality_weight = 0.7
		self._max_num_solutions = 1
		
		
	###########################################################################
	# Private helper member functions.
	###########################################################################
	
	
	def _init_graph(self, graph):
		if self._centrality_method != 'NODE':
			self._init_centralities(graph) # @todo
		self._lsape_init_graph(graph)
	
	
	###########################################################################
	# Virtual member functions to be overridden by derived classes.
	###########################################################################
	
	
	def _lsape_init(self):
		"""
	/*!
	 * @brief Initializes the method after initializing the global variables for the graphs.
	 * @note Must be overridden by derived classes of ged::LSAPEBasedMethod that require custom initialization.
	 */
		"""
		pass
		
		
	def _lsape_parse_option(self, option, arg):
		"""
	/*!
	 * @brief Parses one option that is not among the ones shared by all derived classes of ged::LSAPEBasedMethod.
	 * @param[in] option The name of the option.
	 * @param[in] arg The argument of the option.
	 * @return Returns true if @p option is a valid option name for the method and false otherwise.
	 * @note Must be overridden by derived classes of ged::LSAPEBasedMethod that have options that are not among the ones shared by all derived classes of ged::LSAPEBasedMethod.
	 */
		"""
		return False
		
		
	def _lsape_set_default_options(self):
		"""
	/*!
	 * @brief Sets all options that are not among the ones shared by all derived classes of ged::LSAPEBasedMethod to default values.
	 * @note Must be overridden by derived classes of ged::LSAPEBasedMethod that have options that are not among the ones shared by all derived classes of ged::LSAPEBasedMethod.
	 */
		"""
		pass
	
	
	def _lsape_populate_instance(self, g, h, lsape_instance):
		"""
	/*!
	 * @brief Populates the LSAPE instance.
	 * @param[in] g Input graph.
	 * @param[in] h Input graph.
	 * @param[out] lsape_instance LSAPE instance of size (n + 1) x (m + 1), where n and m are the number of nodes in @p g and @p h. The last row and the last column represent insertion and deletion.
	 * @note Must be overridden by derived classes of ged::LSAPEBasedMethod.
	 */
		"""
		pass
	
	
	def _lsape_init_graph(self, graph):
		"""
	/*!
	 * @brief Initializes global variables for one graph.
	 * @param[in] graph Graph for which the global variables have to be initialized.
	 * @note Must be overridden by derived classes of ged::LSAPEBasedMethod that require to initialize custom global variables.
	 */
		"""
		pass
	
	
	def _lsape_pre_graph_init(self, called_at_runtime):
		"""
	/*!
	 * @brief Initializes the method at runtime or during initialization before initializing the global variables for the graphs.
	 * @param[in] called_at_runtime Equals @p true if called at runtime and @p false if called during initialization.
	 * @brief Must be overridden by derived classes of ged::LSAPEBasedMethod that require default initialization at runtime before initializing the global variables for the graphs.
	 */
		"""
		pass