Exp: test renewed GEDModel with fixed parallel.

jajupmochi · jajupmochi · commit 4fe2acbdcdaa · 2025-05-22T16:16:29.000+02:00
diff --git a/gklearn/experiments/ged/__init__.py b/gklearn/experiments/ged/__init__.py
@@ -0,0 +1,6 @@
+"""
+__init__
+
+@Author: jajupmochi
+@Date: May 22 2025
+"""
diff --git a/gklearn/experiments/ged/ged_model/__init__.py b/gklearn/experiments/ged/ged_model/__init__.py
@@ -0,0 +1,6 @@
+"""
+__init__.py
+
+@Author: jajupmochi
+@Date: May 22 2025
+"""
diff --git a/gklearn/experiments/ged/ged_model/fit_ged_model.py b/gklearn/experiments/ged/ged_model/fit_ged_model.py
@@ -0,0 +1,188 @@
+"""
+fit_ged_model
+
+@Author: jajupmochi
+@Date: May 22 2025
+"""
+from typing import List
+
+import networkx as nx
+import numpy as np
+
+ISSUE_TAG = "\033[91m[issue]\033[0m "  # Red
+INFO_TAG = "\033[94m[info]\033[0m "  # Blue
+SUCCESS_TAG = "\033[92m[success]\033[0m "  # Green
+
+
+def fit_model_ged(
+		graphs_X: List[nx.Graph],
+		graphs_Y: List[nx.Graph] = None,
+		ged_options: dict = None,
+		parallel: bool = None,
+		n_jobs: int = None,
+		chunksize: int = None,
+		copy_graphs: bool = True,
+		read_resu_from_file: int = 1,
+		output_dir: str = None,
+		params_idx: str = None,
+		reorder_graphs: bool = False,
+		verbose: int = 2,
+		**kwargs
+):
+	# if read_resu_from_file >= 1:
+	#     fn_model = os.path.join(
+	#         output_dir, 'metric_model.params_{}.pkl'.format(
+	#             params_idx
+	#         )
+	#     )
+	#     # Load model from file if it exists:
+	#     if os.path.exists(fn_model) and os.path.getsize(fn_model) > 0:
+	#         print('\nLoading model from file...')
+	#         resu = pickle.load(open(fn_model, 'rb'))
+	#         return resu['model'], resu['history'], resu['model'].dis_matrix
+
+	# Reorder graphs if specified:
+	if reorder_graphs:
+		graphs_X = reorder_graphs_by_index(graphs_X, idx_key='id')
+		if graphs_Y is not None:
+			graphs_Y = reorder_graphs_by_index(graphs_Y, idx_key='id')
+
+	# Compute metric matrix otherwise:
+	print(f'{INFO_TAG}Computing metric matrix...')
+	all_graphs = graphs_X + graphs_Y if graphs_Y else graphs_X
+	nl_names = list(
+		all_graphs[0].nodes[list(all_graphs[0].nodes)[0]].keys()
+	) if graphs_X else []
+	if not all_graphs:
+		el_names = []
+	else:
+		idx_edge = (
+			np.where(np.array([nx.number_of_edges(g) for g in all_graphs]) > 0)[0]
+		)
+		if len(idx_edge) == 0:
+			el_names = []
+		else:
+			el_names = list(
+				all_graphs[idx_edge[0]].edges[
+					list(all_graphs[idx_edge[0]].edges)[0]].keys()
+			)
+
+	from .parallel_version import GEDModel
+
+	if parallel is False:
+		parallel = None
+	elif parallel is True:
+		parallel = 'imap_unordered'
+
+	model = GEDModel(
+		ed_method=ged_options['method'],
+		edit_cost_fun=ged_options['edit_cost_fun'],
+		init_edit_cost_constants=ged_options['edit_costs'],
+		optim_method=ged_options['optim_method'],
+		node_labels=nl_names, edge_labels=el_names,
+		parallel=parallel,
+		n_jobs=n_jobs,
+		chunksize=chunksize,
+		copy_graphs=copy_graphs,
+		# make sure it is a full deep copy. and faster!
+		verbose=verbose
+	)
+
+	# Train model.
+	try:
+		if graphs_Y is None:
+			# Compute the distance matrix for the same set of graphs:
+			matrix = model.fit_transform(
+				graphs_X, y=graphs_Y,
+				save_dm_train=True, repeats=ged_options['repeats'],
+			)
+		else:
+			model.fit(graphs_X, repeats=ged_options['repeats'])
+			matrix = model.transform(
+				graphs_Y,
+				save_dm_test=True, repeats=ged_options['repeats'],
+			)
+
+	except OSError as exception:
+		if 'GLIBC_2.23' in exception.args[0]:
+			msg = \
+				'This error is very likely due to the low version of GLIBC ' \
+				'on your system. ' \
+				'The required version of GLIBC is 2.23. This may happen on the ' \
+				'CentOS 7 system, where the highest version of GLIBC is 2.17. ' \
+				'You may check your CLIBC version by bash command `rpm -q glibc`. ' \
+				'The `graphkit-learn` library comes with GLIBC_2.23, which you can ' \
+				'install by enable the `--build-gedlib` option: ' \
+				'`python3 setup.py install --build-gedlib`. This will compile the C++ ' \
+				'module `gedlib`, which requires a C++ compiler and CMake.'
+			raise AssertionError(msg) from exception
+		else:
+			assert False, exception
+	except Exception as exception:
+		assert False, exception
+
+	# Save history:
+	# For graph kernels it is n * (n - 1) / 2:
+	if graphs_Y is None:
+		n_pairs = len(graphs_X) * (len(graphs_X) - 1) / 2
+	else:
+		n_pairs = len(graphs_X) * len(graphs_Y)
+	# history = {'run_time': AverageMeter()}
+	# history['run_time'].update(model.run_time / n_pairs, n_pairs)
+
+	# # Save model and history to file:
+	# if read_resu_from_file >= 1:
+	#     os.makedirs(os.path.dirname(fn_model), exist_ok=True)
+	#     pickle.dump({'model': model, 'history': history}, open(fn_model, 'wb'))
+
+	# Print out the information:
+	params_msg = f' for parameters {params_idx}' if params_idx else ''
+	print(
+		f'{SUCCESS_TAG}Computed metric matrix of size {matrix.shape} in {model.run_time:.3f} '
+		f'seconds ({(model.run_time / n_pairs):.9f} s per pair){params_msg}.'
+	)
+
+	stats = {
+		'n_pairs': n_pairs,
+		'matrix_shape': matrix.shape,
+		'run_time': model.run_time,
+		'run_time_per_pair': model.run_time / n_pairs,
+	}
+
+	return model, matrix, stats
+
+
+def fit_model_ged_test():
+	# Example usage:
+	from gklearn.experiments.ged.ged_model.graph_generator import GraphGenerator
+	generator = GraphGenerator(
+		num_graphs=10,
+		max_num_nodes=5,
+		min_num_nodes=3,
+		max_num_edges=10,
+		min_num_edges=5,
+		with_discrete_n_features=True,
+		with_discrete_e_features=True,
+		with_continuous_n_features=True,
+		with_continuous_e_features=True,
+		# 	node_features=['color', 'shape'],
+		# 	edge_features=['weight'],
+		# 	node_feature_values={'color': ['red', 'blue'], 'shape': ['circle', 'square']},
+		# 	edge_feature_values={'weight': [1, 2, 3]},
+	)
+	graphs = generator.generate_graphs()
+	ged_options = {
+		'method': 'ged',
+		'edit_cost_fun': 'NON_SYMBOLIC',
+		'edit_costs': [3, 3, 1, 3, 3, 1],
+		'optim_method': 'init',
+		'repeats': 1
+	}
+	model, matrix, stats = fit_model_ged(graphs, ged_options)
+	print("Model:", model)
+	print("Matrix shape:", matrix.shape)
+
+
+if __name__ == '__main__':
+	# Test the class
+	fit_model_ged_test()
diff --git a/gklearn/experiments/ged/ged_model/graph_generator.py b/gklearn/experiments/ged/ged_model/graph_generator.py
@@ -0,0 +1,166 @@
+"""
+graph_generator
+
+@Author: jajupmochi
+@Date: May 22 2025
+"""
+
+
+class GraphGenerator:
+	"""
+	A class to generate random graphs for the Graph Edit Distance (GED) model with given
+	constraints.
+
+	Attributes:
+		- num_graphs: Number of graphs to generate.
+		- max_num_nodes: Maximum number of nodes in each graph.
+		- min_num_nodes: Minimum number of nodes in each graph.
+		- max_num_edges: Maximum number of edges in each graph.
+		- min_num_edges: Minimum number of edges in each graph.
+		- with_discrete_n_features: Whether to include discrete node features.
+		- with_discrete_e_features: Whether to include discrete edge features.
+		- with_continuous_n_features: Whether to include continuous node features.
+		- with_continuous_e_features: Whether to include continuous edge features.
+		- node_features: List of node feature names. Optional.
+		- edge_features: List of edge feature names. Optional.
+		- node_feature_values: Dictionary mapping node feature names to their possible values. Optional.
+		- edge_feature_values: Dictionary mapping edge feature names to their possible values. Optional.
+		- seed: Random seed for reproducibility. Default is None.
+	"""
+
+
+	def __init__(
+			self,
+			num_graphs: int,
+			max_num_nodes: int,
+			min_num_nodes: int,
+			max_num_edges: int,
+			min_num_edges: int,
+			with_discrete_n_features: bool = False,
+			with_discrete_e_features: bool = False,
+			with_continuous_n_features: bool = False,
+			with_continuous_e_features: bool = False,
+			continuous_n_feature_dim: int = 10,
+			continuous_e_feature_dim: int = 10,
+			node_features: list = None,
+			edge_features: list = None,
+			node_feature_values: dict = None,
+			edge_feature_values: dict = None,
+			seed: int = None
+	):
+		self.num_graphs = num_graphs
+		self.max_num_nodes = max_num_nodes
+		self.min_num_nodes = min_num_nodes
+		self.max_num_edges = max_num_edges
+		self.min_num_edges = min_num_edges
+		self.with_discrete_n_features = with_discrete_n_features
+		self.with_discrete_e_features = with_discrete_e_features
+		self.with_continuous_n_features = with_continuous_n_features
+		self.with_continuous_e_features = with_continuous_e_features
+		self.continuous_n_feature_dim = continuous_n_feature_dim
+		self.continuous_e_feature_dim = continuous_e_feature_dim
+		self.node_features = node_features if node_features else []
+		self.edge_features = edge_features if edge_features else []
+		self.node_feature_values = node_feature_values if node_feature_values else {}
+		self.edge_feature_values = edge_feature_values if edge_feature_values else {}
+		self.seed = seed
+		if with_discrete_n_features and node_features is None:
+			self.discrete_n_features = [str(i) for i in range(1, 100)]
+		if with_discrete_e_features and edge_features is None:
+			import string
+			self.discrete_e_features = list(string.ascii_lowercase)
+
+
+	def generate_graphs(self):
+		"""
+		Generates a list of random graphs based on the specified constraints.
+
+		Returns:
+			List of generated graphs.
+		"""
+		import numpy as np
+		import networkx as nx
+		import random
+
+		rng = np.random.default_rng(self.seed)
+
+		graphs = []
+
+		for _ in range(self.num_graphs):
+			num_nodes = rng.integers(self.min_num_nodes, self.max_num_nodes + 1)
+			num_edges = rng.integers(self.min_num_edges, self.max_num_edges + 1)
+
+			G = nx.Graph()
+			G.add_nodes_from(range(num_nodes))
+
+			if num_edges > 0:
+				while G.number_of_edges() < num_edges:
+					u = rng.integers(0, num_nodes)
+					v = rng.integers(0, num_nodes)
+					if u != v and not G.has_edge(u, v):
+						G.add_edge(u, v)
+
+			if self.with_discrete_n_features:
+				if self.node_feature_values is None:
+					for node in G.nodes():
+						for feature in self.node_features:
+							G.nodes[node][feature] = rng.choice(
+								self.discrete_n_features
+							)
+
+				else:
+					pass
+			# for node in G.nodes():
+			# 	for feature in self.node_features:
+			# 		G.nodes[node][feature] = random.choice(
+			# 			self.node_feature_values.get(feature, [0])
+			# 		)
+
+			if self.with_discrete_e_features:
+				if self.edge_feature_values is None:
+					for edge in G.edges():
+						for feature in self.edge_features:
+							G.edges[edge][feature] = rng.choice(
+								self.discrete_e_features
+							)
+				else:
+					pass
+			# for edge in G.edges():
+			# 	for feature in self.edge_features:
+			# 		G.edges[edge][feature] = random.choice(
+			# 			self.edge_feature_values.get(feature, [0])
+			# 		)
+
+			if self.with_continuous_n_features:
+				if self.node_feature_values is None:
+					for node in G.nodes():
+						feature = rng.random(self.continuous_n_feature_dim)
+						G.nodes[node]['feature'] = feature
+
+				else:
+					pass
+			# for node in G.nodes():
+			# 	for feature in self.node_features:
+			# 		G.nodes[node][feature] = random.uniform(
+			# 			self.node_feature_values.get(feature, (0, 1))[0],
+			# 			self.node_feature_values.get(feature, (0, 1))[1]
+			# 		)
+
+			if self.with_continuous_e_features:
+				if self.edge_feature_values is None:
+					for edge in G.edges():
+						feature = rng.random(self.continuous_e_feature_dim)
+						G.edges[edge]['feature'] = feature
+
+				else:
+					pass
+			# for edge in G.edges():
+			# 	for feature in self.edge_features:
+			# 		G.edges[edge][feature] = random.uniform(
+			# 			self.edge_feature_values.get(feature, (0, 1))[0],
+			# 			self.edge_feature_values.get(feature, (0, 1))[1]
+			# 		)
+
+			graphs.append(G)
+
+		return graphs
diff --git a/gklearn/experiments/ged/ged_model/parallel_version.py b/gklearn/experiments/ged/ged_model/parallel_version.py
