OpenI
/
graphkit-learn
Not watched
1
0
Fork 0
Code
Releases 2 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 5b0c3c158a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5b0c3c158a'
${ noResults }
graphkit-learn/lang/fr/gklearn/preimage/remove_best_graph.py

423 lines
19 kB
Raw Blame History 

  1. #!/usr/bin/env python3

  2. # -*- coding: utf-8 -*-

  3. """

  4. Created on Wen May 27 14:27:15 2020

  5. 

  6. @author: ljia

  7. """

  8. import numpy as np

  9. import csv

  10. import os

  11. import os.path

  12. from gklearn.utils import Dataset

  13. from gklearn.preimage import MedianPreimageGenerator

  14. from gklearn.utils import normalize_gram_matrix

  15. from gklearn.utils import split_dataset_by_target

  16. from gklearn.preimage.utils import compute_k_dis

  17. from gklearn.utils.graphfiles import saveGXL

  18. import networkx as nx

  19. 	

  20. 

  21. def remove_best_graph(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=True, save_medians=True, plot_medians=True, load_gm='auto', dir_save='', irrelevant_labels=None, edge_required=False, cut_range=None):

  22. 	"""Remove the best graph from the median set w.r.t. distance in kernel space, and to see if it is possible to generate the removed graph using the graphs left in the median set.

  23. 	"""

  24. 	# 1. get dataset.

  25. 	print('1. getting dataset...')

  26. 	dataset_all = Dataset()

  27. 	dataset_all.load_predefined_dataset(ds_name)

  28. 	dataset_all.trim_dataset(edge_required=edge_required)

  29. 	if irrelevant_labels is not None:

  30. 		dataset_all.remove_labels(**irrelevant_labels)

  31. 	if cut_range is not None:

  32. 		dataset_all.cut_graphs(cut_range)

  33. 	datasets = split_dataset_by_target(dataset_all)

  34. 

  35. 	if save_results:

  36. 		# create result files.

  37. 		print('creating output files...')

  38. 		fn_output_detail, fn_output_summary = __init_output_file(ds_name, kernel_options['name'], mpg_options['fit_method'], dir_save)

  39. 	else:

  40. 		fn_output_detail, fn_output_summary = None, None

  41. 		

  42. 	# 2. compute/load Gram matrix a priori.

  43. 	print('2. computing/loading Gram matrix...')

  44. 	gram_matrix_unnorm_list, time_precompute_gm_list = __get_gram_matrix(load_gm, dir_save, ds_name, kernel_options, datasets)

  45. 		

  46. 	sod_sm_list = []

  47. 	sod_gm_list = []

  48. 	dis_k_sm_list = []

  49. 	dis_k_gm_list = []

  50. 	dis_k_gi_min_list = []

  51. 	time_optimize_ec_list = []

  52. 	time_generate_list = []

  53. 	time_total_list = []

  54. 	itrs_list = []

  55. 	converged_list = []

  56. 	num_updates_ecc_list = []

  57. 	mge_decrease_order_list = []

  58. 	mge_increase_order_list = []

  59. 	mge_converged_order_list = []

  60. 	nb_sod_sm2gm = [0, 0, 0]

  61. 	nb_dis_k_sm2gm = [0, 0, 0]

  62. 	nb_dis_k_gi2sm = [0, 0, 0]

  63. 	nb_dis_k_gi2gm = [0, 0, 0]

  64. 	dis_k_max_list = []	

  65. 	dis_k_min_list = []

  66. 	dis_k_mean_list = []

  67. 	best_dis_list = []

  68. 	print('starting experiment for each class of target...')

  69. 	idx_offset = 0

  70. 	for idx, dataset in enumerate(datasets):

  71. 		target = dataset.targets[0]

  72. 		print('\ntarget =', target, '\n')

  73. #		if target != 1:

  74. # 			continue

  75. 		

  76. 		num_graphs = len(dataset.graphs)

  77. 		if num_graphs < 2:

  78. 			print('\nnumber of graphs = ', num_graphs, ', skip.\n')

  79. 			idx_offset += 1

  80. 			continue

  81. 

  82. 		# 3. get the best graph and remove it from median set.

  83. 		print('3. getting and removing the best graph...')

  84. 		gram_matrix_unnorm = gram_matrix_unnorm_list[idx - idx_offset]

  85. 		best_index, best_dis, best_graph = __get_best_graph([g.copy() for g in dataset.graphs], normalize_gram_matrix(gram_matrix_unnorm.copy()))

  86. 		median_set_new = [dataset.graphs[i] for i in range(len(dataset.graphs)) if i != best_index]

  87. 		num_graphs -= 1

  88. 		if num_graphs == 1:

  89. 			continue		

  90. 		best_dis_list.append(best_dis)

  91. 		

  92. 		dataset.load_graphs(median_set_new, targets=None)

  93. 		gram_matrix_unnorm_new = np.delete(gram_matrix_unnorm, best_index, axis=0)

  94. 		gram_matrix_unnorm_new = np.delete(gram_matrix_unnorm_new, best_index, axis=1)

  95. 			

  96. 		# 4. set parameters.

  97. 		print('4. initializing mpg and setting parameters...')	

  98. 		mpg_options['gram_matrix_unnorm'] = gram_matrix_unnorm_new

  99. 		mpg_options['runtime_precompute_gm'] = time_precompute_gm_list[idx - idx_offset]

  100. 		mpg = MedianPreimageGenerator()

  101. 		mpg.dataset = dataset

  102. 		mpg.set_options(**mpg_options.copy())

  103. 		mpg.kernel_options = kernel_options.copy()

  104. 		mpg.ged_options = ged_options.copy()

  105. 		mpg.mge_options = mge_options.copy()

  106. 

  107. 		# 5. compute median preimage.

  108. 		print('5. computing median preimage...')

  109. 		mpg.run()

  110. 		results = mpg.get_results()

  111. 		

  112. 		# 6. compute pairwise kernel distances.

  113. 		print('6. computing pairwise kernel distances...')

  114. 		_, dis_k_max, dis_k_min, dis_k_mean = mpg.graph_kernel.compute_distance_matrix()

  115. 		dis_k_max_list.append(dis_k_max)

  116. 		dis_k_min_list.append(dis_k_min)

  117. 		dis_k_mean_list.append(dis_k_mean)

  118. 		

  119. 		# 7. save results (and median graphs).

  120. 		print('7. saving results (and median graphs)...')

  121. 		# write result detail.

  122. 		if save_results:

  123. 			print('writing results to files...')

  124. 			sod_sm2gm = get_relations(np.sign(results['sod_gen_median'] - results['sod_set_median']))

  125. 			dis_k_sm2gm = get_relations(np.sign(results['k_dis_gen_median'] - results['k_dis_set_median']))

  126. 			dis_k_gi2sm = get_relations(np.sign(results['k_dis_set_median'] - results['k_dis_dataset']))

  127. 			dis_k_gi2gm = get_relations(np.sign(results['k_dis_gen_median'] - results['k_dis_dataset']))

  128. 

  129. 			f_detail = open(dir_save + fn_output_detail, 'a')

  130. 			csv.writer(f_detail).writerow([ds_name, kernel_options['name'], 

  131. 					  ged_options['edit_cost'], ged_options['method'], 

  132. 					  ged_options['attr_distance'], mpg_options['fit_method'], 

  133. 					  num_graphs, target, 1, 

  134. 					  results['sod_set_median'], results['sod_gen_median'],

  135. 					  results['k_dis_set_median'], results['k_dis_gen_median'], 

  136. 					  results['k_dis_dataset'], best_dis, best_index,

  137. 					  sod_sm2gm, dis_k_sm2gm, 

  138. 					  dis_k_gi2sm, dis_k_gi2gm,	results['edit_cost_constants'],

  139. 					  results['runtime_precompute_gm'], results['runtime_optimize_ec'], 

  140. 					  results['runtime_generate_preimage'], results['runtime_total'],

  141. 					  results['itrs'], results['converged'],

  142. 					  results['num_updates_ecc'],

  143. 					  results['mge']['num_decrease_order'] > 0, # @todo: not suitable for multi-start mge

  144. 					  results['mge']['num_increase_order'] > 0,

  145. 					  results['mge']['num_converged_descents'] > 0])

  146. 			f_detail.close()

  147. 		

  148. 			# compute result summary.

  149. 			sod_sm_list.append(results['sod_set_median'])

  150. 			sod_gm_list.append(results['sod_gen_median'])

  151. 			dis_k_sm_list.append(results['k_dis_set_median'])

  152. 			dis_k_gm_list.append(results['k_dis_gen_median'])

  153. 			dis_k_gi_min_list.append(results['k_dis_dataset'])

  154. 			time_precompute_gm_list.append(results['runtime_precompute_gm'])

  155. 			time_optimize_ec_list.append(results['runtime_optimize_ec'])

  156. 			time_generate_list.append(results['runtime_generate_preimage'])

  157. 			time_total_list.append(results['runtime_total'])

  158. 			itrs_list.append(results['itrs'])

  159. 			converged_list.append(results['converged'])

  160. 			num_updates_ecc_list.append(results['num_updates_ecc'])

  161. 			mge_decrease_order_list.append(results['mge']['num_decrease_order'] > 0)

  162. 			mge_increase_order_list.append(results['mge']['num_increase_order'] > 0)

  163. 			mge_converged_order_list.append(results['mge']['num_converged_descents'] > 0)

  164. 			# # SOD SM -> GM

  165. 			if results['sod_set_median'] > results['sod_gen_median']:

  166. 				nb_sod_sm2gm[0] += 1

  167. 	#			repeats_better_sod_sm2gm.append(1)

  168. 			elif results['sod_set_median'] == results['sod_gen_median']:

  169. 				nb_sod_sm2gm[1] += 1

  170. 			elif results['sod_set_median'] < results['sod_gen_median']:

  171. 				nb_sod_sm2gm[2] += 1

  172. 			# # dis_k SM -> GM

  173. 			if results['k_dis_set_median'] > results['k_dis_gen_median']:

  174. 				nb_dis_k_sm2gm[0] += 1

  175. 	#			repeats_better_dis_k_sm2gm.append(1)

  176. 			elif results['k_dis_set_median'] == results['k_dis_gen_median']:

  177. 				nb_dis_k_sm2gm[1] += 1

  178. 			elif results['k_dis_set_median'] < results['k_dis_gen_median']:

  179. 				nb_dis_k_sm2gm[2] += 1

  180. 			# # dis_k gi -> SM

  181. 			if results['k_dis_dataset'] > results['k_dis_set_median']:

  182. 				nb_dis_k_gi2sm[0] += 1

  183. 	#			repeats_better_dis_k_gi2sm.append(1)

  184. 			elif results['k_dis_dataset'] == results['k_dis_set_median']:

  185. 				nb_dis_k_gi2sm[1] += 1

  186. 			elif results['k_dis_dataset'] < results['k_dis_set_median']:

  187. 				nb_dis_k_gi2sm[2] += 1

  188. 			# # dis_k gi -> GM

  189. 			if results['k_dis_dataset'] > results['k_dis_gen_median']:

  190. 				nb_dis_k_gi2gm[0] += 1

  191. 	#			repeats_better_dis_k_gi2gm.append(1)

  192. 			elif results['k_dis_dataset'] == results['k_dis_gen_median']:

  193. 				nb_dis_k_gi2gm[1] += 1

  194. 			elif results['k_dis_dataset'] < results['k_dis_gen_median']:

  195. 				nb_dis_k_gi2gm[2] += 1

  196. 

  197. 			# write result summary for each letter.

  198. 			f_summary = open(dir_save + fn_output_summary, 'a')

  199. 			csv.writer(f_summary).writerow([ds_name, kernel_options['name'], 

  200. 					  ged_options['edit_cost'], ged_options['method'], 

  201. 					  ged_options['attr_distance'], mpg_options['fit_method'], 

  202. 					  num_graphs, target,

  203. 					  results['sod_set_median'], results['sod_gen_median'],

  204. 					  results['k_dis_set_median'], results['k_dis_gen_median'], 

  205. 					  results['k_dis_dataset'], best_dis, best_index,

  206. 					  sod_sm2gm, dis_k_sm2gm, 

  207. 					  dis_k_gi2sm, dis_k_gi2gm, 

  208. 					  results['runtime_precompute_gm'], results['runtime_optimize_ec'], 

  209. 					  results['runtime_generate_preimage'], results['runtime_total'],

  210. 					  results['itrs'], results['converged'],

  211. 					  results['num_updates_ecc'], 

  212. 					  results['mge']['num_decrease_order'] > 0, # @todo: not suitable for multi-start mge

  213. 					  results['mge']['num_increase_order'] > 0,

  214. 					  results['mge']['num_converged_descents'] > 0, 

  215. 					  nb_sod_sm2gm, 

  216. 					  nb_dis_k_sm2gm, nb_dis_k_gi2sm, nb_dis_k_gi2gm])

  217. 			f_summary.close()

  218. 			 

  219. 		# save median graphs.

  220. 		if save_medians:

  221. 			if not os.path.exists(dir_save + 'medians/'):

  222. 				os.makedirs(dir_save + 'medians/')

  223. 			print('Saving median graphs to files...')

  224. 			fn_pre_sm = dir_save + 'medians/set_median.' + mpg_options['fit_method'] + '.nbg' + str(num_graphs) + '.y' + str(target) + '.repeat' + str(1)

  225. 			saveGXL(mpg.set_median, fn_pre_sm + '.gxl', method='default', 

  226. 					node_labels=dataset.node_labels, edge_labels=dataset.edge_labels,	

  227. 					node_attrs=dataset.node_attrs, edge_attrs=dataset.edge_attrs)

  228. 			fn_pre_gm = dir_save + 'medians/gen_median.' + mpg_options['fit_method'] + '.nbg' + str(num_graphs) + '.y' + str(target) + '.repeat' + str(1)

  229. 			saveGXL(mpg.gen_median, fn_pre_gm + '.gxl', method='default',

  230. 		  			node_labels=dataset.node_labels, edge_labels=dataset.edge_labels,	

  231. 					node_attrs=dataset.node_attrs, edge_attrs=dataset.edge_attrs)

  232. 			fn_best_dataset = dir_save + 'medians/g_best_dataset.' + mpg_options['fit_method'] + '.nbg' + str(num_graphs) + '.y' + str(target) + '.repeat' + str(1)

  233. 			saveGXL(best_graph, fn_best_dataset + '.gxl', method='default',

  234. 		  			node_labels=dataset.node_labels, edge_labels=dataset.edge_labels,	

  235. 					node_attrs=dataset.node_attrs, edge_attrs=dataset.edge_attrs)

  236. 			fn_best_median_set = dir_save + 'medians/g_best_median_set.' + mpg_options['fit_method'] + '.nbg' + str(num_graphs) + '.y' + str(target) + '.repeat' + str(1)

  237. 			saveGXL(mpg.best_from_dataset, fn_best_median_set + '.gxl', method='default',

  238. 		  			node_labels=dataset.node_labels, edge_labels=dataset.edge_labels,	

  239. 					node_attrs=dataset.node_attrs, edge_attrs=dataset.edge_attrs)

  240. 		

  241. 		# plot median graphs.

  242. 		if plot_medians and save_medians:

  243. 			if ged_options['edit_cost'] == 'LETTER2' or ged_options['edit_cost'] == 'LETTER' or ds_name == 'Letter-high' or ds_name == 'Letter-med' or ds_name == 'Letter-low':			

  244. 				draw_Letter_graph(mpg.set_median, fn_pre_sm)

  245. 				draw_Letter_graph(mpg.gen_median, fn_pre_gm)

  246. 				draw_Letter_graph(mpg.best_from_dataset, fn_best_dataset)

  247. 

  248. 	# write result summary for each letter. 

  249. 	if save_results:

  250. 		sod_sm_mean = np.mean(sod_sm_list)

  251. 		sod_gm_mean = np.mean(sod_gm_list)

  252. 		dis_k_sm_mean = np.mean(dis_k_sm_list)

  253. 		dis_k_gm_mean = np.mean(dis_k_gm_list)

  254. 		dis_k_gi_min_mean = np.mean(dis_k_gi_min_list)

  255. 		best_dis_mean = np.mean(best_dis_list)

  256. 		time_precompute_gm_mean = np.mean(time_precompute_gm_list)

  257. 		time_optimize_ec_mean = np.mean(time_optimize_ec_list)

  258. 		time_generate_mean = np.mean(time_generate_list)

  259. 		time_total_mean = np.mean(time_total_list)

  260. 		itrs_mean = np.mean(itrs_list)

  261. 		num_converged = np.sum(converged_list)

  262. 		num_updates_ecc_mean = np.mean(num_updates_ecc_list)

  263. 		num_mge_decrease_order = np.sum(mge_decrease_order_list)

  264. 		num_mge_increase_order = np.sum(mge_increase_order_list)

  265. 		num_mge_converged = np.sum(mge_converged_order_list)

  266. 		sod_sm2gm_mean = get_relations(np.sign(sod_gm_mean - sod_sm_mean))

  267. 		dis_k_sm2gm_mean = get_relations(np.sign(dis_k_gm_mean - dis_k_sm_mean))

  268. 		dis_k_gi2sm_mean = get_relations(np.sign(dis_k_sm_mean - dis_k_gi_min_mean))

  269. 		dis_k_gi2gm_mean = get_relations(np.sign(dis_k_gm_mean - dis_k_gi_min_mean))

  270. 		f_summary = open(dir_save + fn_output_summary, 'a')

  271. 		csv.writer(f_summary).writerow([ds_name, kernel_options['name'], 

  272. 				  ged_options['edit_cost'], ged_options['method'], 

  273. 				  ged_options['attr_distance'], mpg_options['fit_method'], 

  274. 				  num_graphs, 'all',

  275. 				  sod_sm_mean, sod_gm_mean, dis_k_sm_mean, dis_k_gm_mean,

  276. 				  dis_k_gi_min_mean, best_dis_mean, '-', 

  277. 				  sod_sm2gm_mean, dis_k_sm2gm_mean, 

  278. 				  dis_k_gi2sm_mean, dis_k_gi2gm_mean,

  279. 				  time_precompute_gm_mean, time_optimize_ec_mean,

  280. 				  time_generate_mean, time_total_mean, itrs_mean, 

  281. 				  num_converged, num_updates_ecc_mean,

  282. 				  num_mge_decrease_order, num_mge_increase_order,

  283. 				  num_mge_converged])

  284. 		f_summary.close()

  285. 		

  286. 	# save total pairwise kernel distances.

  287. 	dis_k_max = np.max(dis_k_max_list)

  288. 	dis_k_min = np.min(dis_k_min_list)

  289. 	dis_k_mean = np.mean(dis_k_mean_list)

  290. 	print('The maximum pairwise distance in kernel space:', dis_k_max)

  291. 	print('The minimum pairwise distance in kernel space:', dis_k_min)

  292. 	print('The average pairwise distance in kernel space:', dis_k_mean)

  293. 

  294. 	print('\ncomplete.\n')	

  295. 

  296. 

  297. def __get_best_graph(Gn, gram_matrix):

  298. 	k_dis_list = []

  299. 	for idx in range(len(Gn)):

  300. 		k_dis_list.append(compute_k_dis(idx, range(0, len(Gn)), [1 / len(Gn)] * len(Gn), gram_matrix, withterm3=False))

  301. 	best_index = np.argmin(k_dis_list)

  302. 	best_dis = k_dis_list[best_index]

  303. 	best_graph = Gn[best_index].copy()

  304. 	return best_index, best_dis, best_graph 

  305. 

  306. 

  307. def get_relations(sign):

  308. 	if sign == -1:

  309. 		return 'better'

  310. 	elif sign == 0:

  311. 		return 'same'

  312. 	elif sign == 1:

  313. 		return 'worse'

  314. 

  315. 

  316. def __get_gram_matrix(load_gm, dir_save, ds_name, kernel_options, datasets):

  317. 	if load_gm == 'auto':

  318. 		gm_fname = dir_save + 'gram_matrix_unnorm.' + ds_name + '.' + kernel_options['name'] + '.gm.npz'

  319. 		gmfile_exist = os.path.isfile(os.path.abspath(gm_fname))

  320. 		if gmfile_exist:

  321. 			gmfile = np.load(gm_fname, allow_pickle=True) # @todo: may not be safe.

  322. 			gram_matrix_unnorm_list = [item for item in gmfile['gram_matrix_unnorm_list']]

  323. 			time_precompute_gm_list = gmfile['run_time_list'].tolist()

  324. 		else:

  325. 			gram_matrix_unnorm_list = []

  326. 			time_precompute_gm_list = []

  327. 			for dataset in datasets:

  328. 				gram_matrix_unnorm, time_precompute_gm = __compute_gram_matrix_unnorm(dataset, kernel_options)

  329. 				gram_matrix_unnorm_list.append(gram_matrix_unnorm)

  330. 				time_precompute_gm_list.append(time_precompute_gm)

  331. 			np.savez(dir_save + 'gram_matrix_unnorm.' + ds_name + '.' + kernel_options['name'] + '.gm', gram_matrix_unnorm_list=gram_matrix_unnorm_list, run_time_list=time_precompute_gm_list)

  332. 	elif not load_gm:

  333. 		gram_matrix_unnorm_list = []

  334. 		time_precompute_gm_list = []

  335. 		for dataset in datasets:

  336. 			gram_matrix_unnorm, time_precompute_gm = __compute_gram_matrix_unnorm(dataset, kernel_options)

  337. 			gram_matrix_unnorm_list.append(gram_matrix_unnorm)

  338. 			time_precompute_gm_list.append(time_precompute_gm)

  339. 		np.savez(dir_save + 'gram_matrix_unnorm.' + ds_name + '.' + kernel_options['name'] + '.gm', gram_matrix_unnorm_list=gram_matrix_unnorm_list, run_time_list=time_precompute_gm_list)

  340. 	else:

  341. 		gm_fname = dir_save + 'gram_matrix_unnorm.' + ds_name + '.' + kernel_options['name'] + '.gm.npz'

  342. 		gmfile = np.load(gm_fname, allow_pickle=True) # @todo: may not be safe.

  343. 		gram_matrix_unnorm_list = [item for item in gmfile['gram_matrix_unnorm_list']]

  344. 		time_precompute_gm_list = gmfile['run_time_list'].tolist()

  345. 		

  346. 	return gram_matrix_unnorm_list, time_precompute_gm_list

  347. 

  348. 

  349. def __get_graph_kernel(dataset, kernel_options):

  350. 	from gklearn.utils.utils import get_graph_kernel_by_name

  351. 	graph_kernel = get_graph_kernel_by_name(kernel_options['name'], 

  352. 				  node_labels=dataset.node_labels,

  353. 				  edge_labels=dataset.edge_labels, 

  354. 				  node_attrs=dataset.node_attrs,

  355. 				  edge_attrs=dataset.edge_attrs,

  356. 				  ds_infos=dataset.get_dataset_infos(keys=['directed']),

  357. 				  kernel_options=kernel_options)

  358. 	return graph_kernel

  359. 		

  360. 		

  361. def __compute_gram_matrix_unnorm(dataset, kernel_options):

  362. 	from gklearn.utils.utils import get_graph_kernel_by_name

  363. 	graph_kernel = get_graph_kernel_by_name(kernel_options['name'], 

  364. 				  node_labels=dataset.node_labels,

  365. 				  edge_labels=dataset.edge_labels, 

  366. 				  node_attrs=dataset.node_attrs,

  367. 				  edge_attrs=dataset.edge_attrs,

  368. 				  ds_infos=dataset.get_dataset_infos(keys=['directed']),

  369. 				  kernel_options=kernel_options)

  370. 	

  371. 	gram_matrix, run_time = graph_kernel.compute(dataset.graphs, **kernel_options)

  372. 	gram_matrix_unnorm = graph_kernel.gram_matrix_unnorm

  373. 		

  374. 	return gram_matrix_unnorm, run_time

  375. 		

  376. 		

  377. def __init_output_file(ds_name, gkernel, fit_method, dir_output):

  378. 	if not os.path.exists(dir_output):

  379. 		os.makedirs(dir_output)

  380. 	fn_output_detail = 'results_detail.' + ds_name + '.' + gkernel + '.csv'

  381. 	f_detail = open(dir_output + fn_output_detail, 'a')

  382. 	csv.writer(f_detail).writerow(['dataset', 'graph kernel', 'edit cost', 

  383. 			  'GED method', 'attr distance', 'fit method', 'num graphs', 

  384. 			  'target', 'repeat', 'SOD SM', 'SOD GM', 'dis_k SM', 'dis_k GM',

  385. 			  'min dis_k gi', 'best kernel dis', 'best graph index', 

  386. 			  'SOD SM -> GM', 'dis_k SM -> GM', 'dis_k gi -> SM', 

  387. 			  'dis_k gi -> GM', 'edit cost constants', 'time precompute gm',

  388. 			  'time optimize ec', 'time generate preimage', 'time total',

  389. 			  'itrs', 'converged', 'num updates ecc', 'mge decrease order', 

  390. 			  'mge increase order', 'mge converged'])

  391. 	f_detail.close()

  392. 	

  393. 	fn_output_summary = 'results_summary.' + ds_name + '.' + gkernel + '.csv'

  394. 	f_summary = open(dir_output + fn_output_summary, 'a')

  395. 	csv.writer(f_summary).writerow(['dataset', 'graph kernel', 'edit cost', 

  396. 			  'GED method', 'attr distance', 'fit method', 'num graphs', 

  397. 			  'target', 'SOD SM', 'SOD GM', 'dis_k SM', 'dis_k GM',

  398. 			  'min dis_k gi', 'best kernel dis', 'best graph index',

  399. 			  'SOD SM -> GM', 'dis_k SM -> GM', 'dis_k gi -> SM', 

  400. 			  'dis_k gi -> GM', 'time precompute gm', 'time optimize ec', 

  401. 			  'time generate preimage', 'time total', 'itrs', 'num converged', 

  402. 			  'num updates ecc', 'mge num decrease order', 'mge num increase order', 

  403. 			  'mge num converged', '# SOD SM -> GM', '# dis_k SM -> GM', 

  404. 			  '# dis_k gi -> SM', '# dis_k gi -> GM'])

  405. 	f_summary.close()

  406. 	

  407. 	return fn_output_detail, fn_output_summary

  408. 

  409. 

  410. #Dessin median courrant

  411. def draw_Letter_graph(graph, file_prefix):

  412. 	import matplotlib

  413. 	matplotlib.use('agg')

  414. 	import matplotlib.pyplot as plt

  415. 	plt.figure()

  416. 	pos = {}

  417. 	for n in graph.nodes:

  418. 		pos[n] = np.array([float(graph.nodes[n]['x']),float(graph.nodes[n]['y'])])

  419. 	nx.draw_networkx(graph, pos)

  420. 	plt.savefig(file_prefix + '.eps', format='eps', dpi=300)

  421. #	plt.show()

  422. 	plt.clf()

  423. 	plt.close()