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: 2248a1308e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2248a1308e'
${ noResults }
graphkit-learn/gklearn/preimage/experiments/xp_median_preimage.py

1257 lines
46 kB
Raw Blame History 

  1. #!/usr/bin/env python3

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

  3. """

  4. Created on Tue Jan 14 15:39:29 2020

  5. 

  6. @author: ljia

  7. """

  8. import multiprocessing

  9. import functools

  10. from gklearn.utils.kernels import deltakernel, gaussiankernel, kernelproduct

  11. from gklearn.preimage.utils import generate_median_preimages_by_class

  12. from gklearn.utils import compute_gram_matrices_by_class

  13. 

  14. 

  15. def xp_median_preimage_9_1():

  16. 	"""xp 9_1: MAO, StructuralSP, using CONSTANT, symbolic only.

  17. 	"""

  18. 	# set parameters.

  19. 	ds_name = 'MAO' #

  20. 	mpg_options = {'fit_method': 'k-graphs',

  21. 				   'init_ecc': [4, 4, 2, 1, 1, 1], #

  22. 				   'ds_name': ds_name,

  23. 				   'parallel': True, # False

  24. 				   'time_limit_in_sec': 0,

  25. 				   'max_itrs': 100, # 

  26. 				   'max_itrs_without_update': 3,

  27. 				   'epsilon_residual': 0.01,

  28. 				   'epsilon_ec': 0.1,

  29. 				   'verbose': 2}

  30. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  31. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  32. 	kernel_options = {'name': 'StructuralSP',

  33. 					  'edge_weight': None,

  34. 					  'node_kernels': sub_kernels,

  35. 					  'edge_kernels': sub_kernels, 

  36. 					  'compute_method': 'naive',

  37.  					  'parallel': 'imap_unordered', 

  38.                       # 'parallel': None, 

  39. 					  'n_jobs': multiprocessing.cpu_count(),

  40. 					  'normalize': True,

  41. 					  'verbose': 2}

  42. 	ged_options = {'method': 'IPFP',

  43. 				   'initialization_method': 'RANDOM', # 'NODE'

  44. 				   'initial_solutions': 10, # 1

  45. 				   'edit_cost': 'CONSTANT', # 

  46. 				   'attr_distance': 'euclidean',

  47. 				   'ratio_runs_from_initial_solutions': 1,

  48. 				   'threads': multiprocessing.cpu_count(),

  49. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  50. 	mge_options = {'init_type': 'MEDOID',

  51. 				   'random_inits': 10,

  52. 				   'time_limit': 600,

  53. 				   'verbose': 2,

  54. 				   'refine': False}

  55. 	save_results = True

  56. 	dir_save='../results/xp_median_preimage/'

  57. 	irrelevant_labels = {'node_attrs': ['x', 'y', 'z'], 'edge_labels': ['bond_stereo']} #

  58. 	edge_required = False #

  59. 	

  60. 	# print settings.

  61. 	print('parameters:')

  62. 	print('dataset name:', ds_name)

  63. 	print('mpg_options:', mpg_options)

  64. 	print('kernel_options:', kernel_options)

  65. 	print('ged_options:', ged_options)

  66. 	print('mge_options:', mge_options)

  67. 	print('save_results:', save_results)

  68. 	print('irrelevant_labels:', irrelevant_labels)

  69. 	print()

  70. 	

  71. 	# generate preimages.

  72. 	for fit_method in ['k-graphs', 'expert'] + ['random'] * 10:

  73. 		print('\n-------------------------------------')

  74. 		print('fit method:', fit_method, '\n')

  75. 		mpg_options['fit_method'] = fit_method

  76. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  77. 		

  78. 		

  79. def xp_median_preimage_9_2():

  80. 	"""xp 9_2: MAO, PathUpToH, using CONSTANT, symbolic only.

  81. 	"""

  82. 	# set parameters.

  83. 	ds_name = 'MAO' #

  84. 	mpg_options = {'fit_method': 'k-graphs',

  85. 				   'init_ecc': [4, 4, 2, 1, 1, 1], #

  86. 				   'ds_name': ds_name,

  87. 				   'parallel': True, # False

  88. 				   'time_limit_in_sec': 0,

  89. 				   'max_itrs': 100, # 

  90. 				   'max_itrs_without_update': 3,

  91. 				   'epsilon_residual': 0.01,

  92. 				   'epsilon_ec': 0.1,

  93. 				   'verbose': 2}

  94. 	kernel_options = {'name': 'PathUpToH',

  95. 					  'depth': 9, #

  96. 					  'k_func': 'MinMax', #

  97. 					  'compute_method': 'trie',

  98.  					  'parallel': 'imap_unordered', 

  99.                       # 'parallel': None, 

  100. 					  'n_jobs': multiprocessing.cpu_count(),

  101. 					  'normalize': True,

  102. 					  'verbose': 2}

  103. 	ged_options = {'method': 'IPFP',

  104. 				   'initialization_method': 'RANDOM', # 'NODE'

  105. 				   'initial_solutions': 10, # 1

  106. 				   'edit_cost': 'CONSTANT', # 

  107. 				   'attr_distance': 'euclidean',

  108. 				   'ratio_runs_from_initial_solutions': 1,

  109. 				   'threads': multiprocessing.cpu_count(),

  110. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  111. 	mge_options = {'init_type': 'MEDOID',

  112. 				   'random_inits': 10,

  113. 				   'time_limit': 600,

  114. 				   'verbose': 2,

  115. 				   'refine': False}

  116. 	save_results = True

  117. 	dir_save='../results/xp_median_preimage/'

  118. 	irrelevant_labels = {'node_attrs': ['x', 'y', 'z'], 'edge_labels': ['bond_stereo']} #

  119. 	edge_required = False #

  120. 	

  121. 	# print settings.

  122. 	print('parameters:')

  123. 	print('dataset name:', ds_name)

  124. 	print('mpg_options:', mpg_options)

  125. 	print('kernel_options:', kernel_options)

  126. 	print('ged_options:', ged_options)

  127. 	print('mge_options:', mge_options)

  128. 	print('save_results:', save_results)

  129. 	print('irrelevant_labels:', irrelevant_labels)

  130. 	print()

  131. 	

  132. 	# generate preimages.

  133. 	for fit_method in ['k-graphs', 'expert'] + ['random'] * 10:

  134. 		print('\n-------------------------------------')

  135. 		print('fit method:', fit_method, '\n')

  136. 		mpg_options['fit_method'] = fit_method

  137. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  138. 

  139. 

  140. def xp_median_preimage_8_1():

  141. 	"""xp 8_1: Monoterpenoides, StructuralSP, using CONSTANT.

  142. 	"""

  143. 	# set parameters.

  144. 	ds_name = 'Monoterpenoides' #

  145. 	mpg_options = {'fit_method': 'k-graphs',

  146. 				   'init_ecc': [3, 3, 1, 3, 3, 1], #

  147. 				   'ds_name': ds_name,

  148. 				   'parallel': True, # False

  149. 				   'time_limit_in_sec': 0,

  150. 				   'max_itrs': 100, # 

  151. 				   'max_itrs_without_update': 3,

  152. 				   'epsilon_residual': 0.01,

  153. 				   'epsilon_ec': 0.1,

  154. 				   'verbose': 2}

  155. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  156. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  157. 	kernel_options = {'name': 'StructuralSP',

  158. 					  'edge_weight': None,

  159. 					  'node_kernels': sub_kernels,

  160. 					  'edge_kernels': sub_kernels, 

  161. 					  'compute_method': 'naive',

  162.  					  'parallel': 'imap_unordered', 

  163.                       # 'parallel': None, 

  164. 					  'n_jobs': multiprocessing.cpu_count(),

  165. 					  'normalize': True,

  166. 					  'verbose': 2}

  167. 	ged_options = {'method': 'IPFP',

  168. 				   'initialization_method': 'RANDOM', # 'NODE'

  169. 				   'initial_solutions': 10, # 1

  170. 				   'edit_cost': 'CONSTANT', # 

  171. 				   'attr_distance': 'euclidean',

  172. 				   'ratio_runs_from_initial_solutions': 1,

  173. 				   'threads': multiprocessing.cpu_count(),

  174. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  175. 	mge_options = {'init_type': 'MEDOID',

  176. 				   'random_inits': 10,

  177. 				   'time_limit': 600,

  178. 				   'verbose': 2,

  179. 				   'refine': False}

  180. 	save_results = True

  181. 	dir_save='../results/xp_median_preimage/'

  182. 	irrelevant_labels = None #

  183. 	edge_required = False #

  184. 	

  185. 	# print settings.

  186. 	print('parameters:')

  187. 	print('dataset name:', ds_name)

  188. 	print('mpg_options:', mpg_options)

  189. 	print('kernel_options:', kernel_options)

  190. 	print('ged_options:', ged_options)

  191. 	print('mge_options:', mge_options)

  192. 	print('save_results:', save_results)

  193. 	print('irrelevant_labels:', irrelevant_labels)

  194. 	print()

  195. 	

  196. 	# generate preimages.

  197. 	for fit_method in ['k-graphs', 'expert'] + ['random'] * 10:

  198. 		print('\n-------------------------------------')

  199. 		print('fit method:', fit_method, '\n')

  200. 		mpg_options['fit_method'] = fit_method

  201. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  202. 		

  203. 		

  204. def xp_median_preimage_8_2():

  205. 	"""xp 8_2: Monoterpenoides, PathUpToH, using CONSTANT.

  206. 	"""

  207. 	# set parameters.

  208. 	ds_name = 'Monoterpenoides' #

  209. 	mpg_options = {'fit_method': 'k-graphs',

  210. 				   'init_ecc': [4, 4, 2, 1, 1, 1], #

  211. 				   'ds_name': ds_name,

  212. 				   'parallel': True, # False

  213. 				   'time_limit_in_sec': 0,

  214. 				   'max_itrs': 100, # 

  215. 				   'max_itrs_without_update': 3,

  216. 				   'epsilon_residual': 0.01,

  217. 				   'epsilon_ec': 0.1,

  218. 				   'verbose': 2}

  219. 	kernel_options = {'name': 'PathUpToH',

  220. 					  'depth': 7, #

  221. 					  'k_func': 'MinMax', #

  222. 					  'compute_method': 'trie',

  223.  					  'parallel': 'imap_unordered', 

  224.                       # 'parallel': None, 

  225. 					  'n_jobs': multiprocessing.cpu_count(),

  226. 					  'normalize': True,

  227. 					  'verbose': 2}

  228. 	ged_options = {'method': 'IPFP',

  229. 				   'initialization_method': 'RANDOM', # 'NODE'

  230. 				   'initial_solutions': 10, # 1

  231. 				   'edit_cost': 'CONSTANT', # 

  232. 				   'attr_distance': 'euclidean',

  233. 				   'ratio_runs_from_initial_solutions': 1,

  234. 				   'threads': multiprocessing.cpu_count(),

  235. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  236. 	mge_options = {'init_type': 'MEDOID',

  237. 				   'random_inits': 10,

  238. 				   'time_limit': 600,

  239. 				   'verbose': 2,

  240. 				   'refine': False}

  241. 	save_results = True

  242. 	dir_save='../results/xp_median_preimage/'

  243. 	irrelevant_labels = None #

  244. 	edge_required = False #

  245. 	

  246. 	# print settings.

  247. 	print('parameters:')

  248. 	print('dataset name:', ds_name)

  249. 	print('mpg_options:', mpg_options)

  250. 	print('kernel_options:', kernel_options)

  251. 	print('ged_options:', ged_options)

  252. 	print('mge_options:', mge_options)

  253. 	print('save_results:', save_results)

  254. 	print('irrelevant_labels:', irrelevant_labels)

  255. 	print()

  256. 	

  257. 	# generate preimages.

  258. 	for fit_method in ['k-graphs', 'expert'] + ['random'] * 10:

  259. 		print('\n-------------------------------------')

  260. 		print('fit method:', fit_method, '\n')

  261. 		mpg_options['fit_method'] = fit_method

  262. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  263. 		

  264. 

  265. def xp_median_preimage_7_1():

  266. 	"""xp 7_1: MUTAG, StructuralSP, using CONSTANT.

  267. 	"""

  268. 	# set parameters.

  269. 	ds_name = 'MUTAG' #

  270. 	mpg_options = {'fit_method': 'k-graphs',

  271. 				   'init_ecc': [4, 4, 2, 1, 1, 1], #

  272. 				   'ds_name': ds_name,

  273. 				   'parallel': True, # False

  274. 				   'time_limit_in_sec': 0,

  275. 				   'max_itrs': 100, # 

  276. 				   'max_itrs_without_update': 3,

  277. 				   'epsilon_residual': 0.01,

  278. 				   'epsilon_ec': 0.1,

  279. 				   'verbose': 2}

  280. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  281. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  282. 	kernel_options = {'name': 'StructuralSP',

  283. 					  'edge_weight': None,

  284. 					  'node_kernels': sub_kernels,

  285. 					  'edge_kernels': sub_kernels, 

  286. 					  'compute_method': 'naive',

  287.  					  'parallel': 'imap_unordered', 

  288.                       # 'parallel': None, 

  289. 					  'n_jobs': multiprocessing.cpu_count(),

  290. 					  'normalize': True,

  291. 					  'verbose': 2}

  292. 	ged_options = {'method': 'IPFP',

  293. 				   'initialization_method': 'RANDOM', # 'NODE'

  294. 				   'initial_solutions': 10, # 1

  295. 				   'edit_cost': 'CONSTANT', # 

  296. 				   'attr_distance': 'euclidean',

  297. 				   'ratio_runs_from_initial_solutions': 1,

  298. 				   'threads': multiprocessing.cpu_count(),

  299. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  300. 	mge_options = {'init_type': 'MEDOID',

  301. 				   'random_inits': 10,

  302. 				   'time_limit': 600,

  303. 				   'verbose': 2,

  304. 				   'refine': False}

  305. 	save_results = True

  306. 	dir_save='../results/xp_median_preimage/'

  307. 	irrelevant_labels = None #

  308. 	edge_required = False #

  309. 	

  310. 	# print settings.

  311. 	print('parameters:')

  312. 	print('dataset name:', ds_name)

  313. 	print('mpg_options:', mpg_options)

  314. 	print('kernel_options:', kernel_options)

  315. 	print('ged_options:', ged_options)

  316. 	print('mge_options:', mge_options)

  317. 	print('save_results:', save_results)

  318. 	print('irrelevant_labels:', irrelevant_labels)

  319. 	print()

  320. 	

  321. 	# generate preimages.

  322. 	for fit_method in ['k-graphs', 'expert'] + ['random'] * 10:

  323. 		print('\n-------------------------------------')

  324. 		print('fit method:', fit_method, '\n')

  325. 		mpg_options['fit_method'] = fit_method

  326. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  327. 		

  328. 		

  329. def xp_median_preimage_7_2():

  330. 	"""xp 7_2: MUTAG, PathUpToH, using CONSTANT.

  331. 	"""

  332. 	# set parameters.

  333. 	ds_name = 'MUTAG' #

  334. 	mpg_options = {'fit_method': 'k-graphs',

  335. 				   'init_ecc': [4, 4, 2, 1, 1, 1], #

  336. 				   'ds_name': ds_name,

  337. 				   'parallel': True, # False

  338. 				   'time_limit_in_sec': 0,

  339. 				   'max_itrs': 100, # 

  340. 				   'max_itrs_without_update': 3,

  341. 				   'epsilon_residual': 0.01,

  342. 				   'epsilon_ec': 0.1,

  343. 				   'verbose': 2}

  344. 	kernel_options = {'name': 'PathUpToH',

  345. 					  'depth': 2, #

  346. 					  'k_func': 'MinMax', #

  347. 					  'compute_method': 'trie',

  348.  					  'parallel': 'imap_unordered', 

  349.                       # 'parallel': None, 

  350. 					  'n_jobs': multiprocessing.cpu_count(),

  351. 					  'normalize': True,

  352. 					  'verbose': 2}

  353. 	ged_options = {'method': 'IPFP',

  354. 				   'initialization_method': 'RANDOM', # 'NODE'

  355. 				   'initial_solutions': 10, # 1

  356. 				   'edit_cost': 'CONSTANT', # 

  357. 				   'attr_distance': 'euclidean',

  358. 				   'ratio_runs_from_initial_solutions': 1,

  359. 				   'threads': multiprocessing.cpu_count(),

  360. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  361. 	mge_options = {'init_type': 'MEDOID',

  362. 				   'random_inits': 10,

  363. 				   'time_limit': 600,

  364. 				   'verbose': 2,

  365. 				   'refine': False}

  366. 	save_results = True

  367. 	dir_save='../results/xp_median_preimage/'

  368. 	irrelevant_labels = None #

  369. 	edge_required = False #

  370. 	

  371. 	# print settings.

  372. 	print('parameters:')

  373. 	print('dataset name:', ds_name)

  374. 	print('mpg_options:', mpg_options)

  375. 	print('kernel_options:', kernel_options)

  376. 	print('ged_options:', ged_options)

  377. 	print('mge_options:', mge_options)

  378. 	print('save_results:', save_results)

  379. 	print('irrelevant_labels:', irrelevant_labels)

  380. 	print()

  381. 	

  382. 	# generate preimages.

  383. 	for fit_method in ['k-graphs', 'expert'] + ['random'] * 10:

  384. 		print('\n-------------------------------------')

  385. 		print('fit method:', fit_method, '\n')

  386. 		mpg_options['fit_method'] = fit_method

  387. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  388. 

  389. 

  390. def xp_median_preimage_6_1():

  391. 	"""xp 6_1: COIL-RAG, StructuralSP, using NON_SYMBOLIC.

  392. 	"""

  393. 	# set parameters.

  394. 	ds_name = 'COIL-RAG' #

  395. 	mpg_options = {'fit_method': 'k-graphs',

  396. 				   'init_ecc': [3, 3, 1, 3, 3, 1], #

  397. 				   'ds_name': ds_name,

  398. 				   'parallel': True, # False

  399. 				   'time_limit_in_sec': 0,

  400. 				   'max_itrs': 100,

  401. 				   'max_itrs_without_update': 3,

  402. 				   'epsilon_residual': 0.01,

  403. 				   'epsilon_ec': 0.1,

  404. 				   'verbose': 2}

  405. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  406. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  407. 	kernel_options = {'name': 'StructuralSP',

  408. 					  'edge_weight': None,

  409. 					  'node_kernels': sub_kernels,

  410. 					  'edge_kernels': sub_kernels, 

  411. 					  'compute_method': 'naive',

  412.  					  'parallel': 'imap_unordered', 

  413.                       # 'parallel': None, 

  414. 					  'n_jobs': multiprocessing.cpu_count(),

  415. 					  'normalize': True,

  416. 					  'verbose': 2}

  417. 	ged_options = {'method': 'IPFP',

  418. 				   'initialization_method': 'RANDOM', # 'NODE'

  419. 				   'initial_solutions': 10, # 1

  420. 				   'edit_cost': 'NON_SYMBOLIC', # 

  421. 				   'attr_distance': 'euclidean',

  422. 				   'ratio_runs_from_initial_solutions': 1,

  423. 				   'threads': multiprocessing.cpu_count(),

  424. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  425. 	mge_options = {'init_type': 'MEDOID',

  426. 				   'random_inits': 10,

  427. 				   'time_limit': 600,

  428. 				   'verbose': 2,

  429. 				   'refine': False}

  430. 	save_results = True

  431. 	dir_save='../results/xp_median_preimage/'

  432. 	irrelevant_labels = None #

  433. 	edge_required = False #

  434. 	

  435. 	# print settings.

  436. 	print('parameters:')

  437. 	print('dataset name:', ds_name)

  438. 	print('mpg_options:', mpg_options)

  439. 	print('kernel_options:', kernel_options)

  440. 	print('ged_options:', ged_options)

  441. 	print('mge_options:', mge_options)

  442. 	print('save_results:', save_results)

  443. 	print('irrelevant_labels:', irrelevant_labels)

  444. 	print()

  445. 	

  446. 	# generate preimages.

  447. 	for fit_method in ['k-graphs'] + ['random'] * 10:

  448. 		print('\n-------------------------------------')

  449. 		print('fit method:', fit_method, '\n')

  450. 		mpg_options['fit_method'] = fit_method

  451. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  452. 		

  453. 		

  454. def xp_median_preimage_6_2():

  455. 	"""xp 6_2: COIL-RAG, ShortestPath, using NON_SYMBOLIC.

  456. 	"""

  457. 	# set parameters.

  458. 	ds_name = 'COIL-RAG' #

  459. 	mpg_options = {'fit_method': 'k-graphs',

  460. 				   'init_ecc': [3, 3, 1, 3, 3, 1], #

  461. 				   'ds_name': ds_name,

  462. 				   'parallel': True, # False

  463. 				   'time_limit_in_sec': 0,

  464. 				   'max_itrs': 100,

  465. 				   'max_itrs_without_update': 3,

  466. 				   'epsilon_residual': 0.01,

  467. 				   'epsilon_ec': 0.1,

  468. 				   'verbose': 2}

  469. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  470. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  471. 	kernel_options = {'name': 'ShortestPath',

  472. 					  'edge_weight': None,

  473. 					  'node_kernels': sub_kernels,

  474.  					  'parallel': 'imap_unordered', 

  475.                       # 'parallel': None, 

  476. 					  'n_jobs': multiprocessing.cpu_count(),

  477. 					  'normalize': True,

  478. 					  'verbose': 2}

  479. 	ged_options = {'method': 'IPFP',

  480. 				   'initialization_method': 'RANDOM', # 'NODE'

  481. 				   'initial_solutions': 10, # 1

  482. 				   'edit_cost': 'NON_SYMBOLIC', # 

  483. 				   'attr_distance': 'euclidean',

  484. 				   'ratio_runs_from_initial_solutions': 1,

  485. 				   'threads': multiprocessing.cpu_count(),

  486. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  487. 	mge_options = {'init_type': 'MEDOID',

  488. 				   'random_inits': 10,

  489. 				   'time_limit': 600,

  490. 				   'verbose': 2,

  491. 				   'refine': False}

  492. 	save_results = True

  493. 	dir_save='../results/xp_median_preimage/'

  494. 	irrelevant_labels = None #

  495. 	edge_required = True #

  496. 	

  497. 	# print settings.

  498. 	print('parameters:')

  499. 	print('dataset name:', ds_name)

  500. 	print('mpg_options:', mpg_options)

  501. 	print('kernel_options:', kernel_options)

  502. 	print('ged_options:', ged_options)

  503. 	print('mge_options:', mge_options)

  504. 	print('save_results:', save_results)

  505. 	print('irrelevant_labels:', irrelevant_labels)

  506. 	print()

  507. 	

  508. 	# generate preimages.

  509. 	for fit_method in ['k-graphs'] + ['random'] * 10:

  510. 		print('\n-------------------------------------')

  511. 		print('fit method:', fit_method, '\n')

  512. 		mpg_options['fit_method'] = fit_method

  513. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  514. 

  515. 

  516. def xp_median_preimage_5_1():

  517. 	"""xp 5_1: FRANKENSTEIN, StructuralSP, using NON_SYMBOLIC.

  518. 	"""

  519. 	# set parameters.

  520. 	ds_name = 'FRANKENSTEIN' #

  521. 	mpg_options = {'fit_method': 'k-graphs',

  522. 				   'init_ecc': [3, 3, 1, 3, 3, 0], #

  523. 				   'ds_name': ds_name,

  524. 				   'parallel': True, # False

  525. 				   'time_limit_in_sec': 0,

  526. 				   'max_itrs': 100,

  527. 				   'max_itrs_without_update': 3,

  528. 				   'epsilon_residual': 0.01,

  529. 				   'epsilon_ec': 0.1,

  530. 				   'verbose': 2}

  531. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  532. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  533. 	kernel_options = {'name': 'StructuralSP',

  534. 					  'edge_weight': None,

  535. 					  'node_kernels': sub_kernels,

  536. 					  'edge_kernels': sub_kernels, 

  537. 					  'compute_method': 'naive',

  538.  					  'parallel': 'imap_unordered', 

  539.                       # 'parallel': None, 

  540. 					  'n_jobs': multiprocessing.cpu_count(),

  541. 					  'normalize': True,

  542. 					  'verbose': 2}

  543. 	ged_options = {'method': 'IPFP',

  544. 				   'initialization_method': 'RANDOM', # 'NODE'

  545. 				   'initial_solutions': 10, # 1

  546. 				   'edit_cost': 'NON_SYMBOLIC',

  547. 				   'attr_distance': 'euclidean',

  548. 				   'ratio_runs_from_initial_solutions': 1,

  549. 				   'threads': multiprocessing.cpu_count(),

  550. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  551. 	mge_options = {'init_type': 'MEDOID',

  552. 				   'random_inits': 10,

  553. 				   'time_limit': 600,

  554. 				   'verbose': 2,

  555. 				   'refine': False}

  556. 	save_results = True

  557. 	dir_save='../results/xp_median_preimage/'

  558. 	irrelevant_labels = None #

  559. 	edge_required = False #

  560. 	

  561. 	# print settings.

  562. 	print('parameters:')

  563. 	print('dataset name:', ds_name)

  564. 	print('mpg_options:', mpg_options)

  565. 	print('kernel_options:', kernel_options)

  566. 	print('ged_options:', ged_options)

  567. 	print('mge_options:', mge_options)

  568. 	print('save_results:', save_results)

  569. 	print('irrelevant_labels:', irrelevant_labels)

  570. 	print()

  571. 	

  572. 	# generate preimages.

  573. 	for fit_method in ['k-graphs'] + ['random'] * 10:

  574. 		print('\n-------------------------------------')

  575. 		print('fit method:', fit_method, '\n')

  576. 		mpg_options['fit_method'] = fit_method

  577. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  578. 		

  579. 

  580. def xp_median_preimage_4_1():

  581. 	"""xp 4_1: COLORS-3, StructuralSP, using NON_SYMBOLIC.

  582. 	"""

  583. 	# set parameters.

  584. 	ds_name = 'COLORS-3' #

  585. 	mpg_options = {'fit_method': 'k-graphs',

  586. 				   'init_ecc': [3, 3, 1, 3, 3, 0], #

  587. 				   'ds_name': ds_name,

  588. 				   'parallel': True, # False

  589. 				   'time_limit_in_sec': 0,

  590. 				   'max_itrs': 100,

  591. 				   'max_itrs_without_update': 3,

  592. 				   'epsilon_residual': 0.01,

  593. 				   'epsilon_ec': 0.1,

  594. 				   'verbose': 2}

  595. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  596. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  597. 	kernel_options = {'name': 'StructuralSP',

  598. 					  'edge_weight': None,

  599. 					  'node_kernels': sub_kernels,

  600. 					  'edge_kernels': sub_kernels, 

  601. 					  'compute_method': 'naive',

  602.  					  'parallel': 'imap_unordered', 

  603.                       # 'parallel': None, 

  604. 					  'n_jobs': multiprocessing.cpu_count(),

  605. 					  'normalize': True,

  606. 					  'verbose': 2}

  607. 	ged_options = {'method': 'IPFP',

  608. 				   'initialization_method': 'RANDOM', # 'NODE'

  609. 				   'initial_solutions': 10, # 1

  610. 				   'edit_cost': 'NON_SYMBOLIC',

  611. 				   'attr_distance': 'euclidean',

  612. 				   'ratio_runs_from_initial_solutions': 1,

  613. 				   'threads': multiprocessing.cpu_count(),

  614. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  615. 	mge_options = {'init_type': 'MEDOID',

  616. 				   'random_inits': 10,

  617. 				   'time_limit': 600,

  618. 				   'verbose': 2,

  619. 				   'refine': False}

  620. 	save_results = True

  621. 	dir_save='../results/xp_median_preimage/'

  622. 	irrelevant_labels = None #

  623. 	edge_required = False #

  624. 	

  625. 	# print settings.

  626. 	print('parameters:')

  627. 	print('dataset name:', ds_name)

  628. 	print('mpg_options:', mpg_options)

  629. 	print('kernel_options:', kernel_options)

  630. 	print('ged_options:', ged_options)

  631. 	print('mge_options:', mge_options)

  632. 	print('save_results:', save_results)

  633. 	print('irrelevant_labels:', irrelevant_labels)

  634. 	print()

  635. 	

  636. 	# generate preimages.

  637. 	for fit_method in ['k-graphs'] + ['random'] * 10:

  638. 		print('\n-------------------------------------')

  639. 		print('fit method:', fit_method, '\n')

  640. 		mpg_options['fit_method'] = fit_method

  641. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  642. 		

  643. 		

  644. def xp_median_preimage_3_2():

  645. 	"""xp 3_2: Fingerprint, ShortestPath, using LETTER2, only node attrs.

  646. 	"""

  647. 	# set parameters.

  648. 	ds_name = 'Fingerprint' #

  649. 	mpg_options = {'fit_method': 'k-graphs',

  650. 				   'init_ecc': [0.525, 0.525, 0.001, 0.125, 0.125], #

  651. 				   'ds_name': ds_name,

  652. 				   'parallel': True, # False

  653. 				   'time_limit_in_sec': 0,

  654. 				   'max_itrs': 100,

  655. 				   'max_itrs_without_update': 3,

  656. 				   'epsilon_residual': 0.01,

  657. 				   'epsilon_ec': 0.1,

  658. 				   'verbose': 2}

  659. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  660. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  661. 	kernel_options = {'name': 'ShortestPath',

  662. 					  'edge_weight': None,

  663. 					  'node_kernels': sub_kernels,

  664.  					  'parallel': 'imap_unordered', 

  665.                       # 'parallel': None, 

  666. 					  'n_jobs': multiprocessing.cpu_count(),

  667. 					  'normalize': True,

  668. 					  'verbose': 2}

  669. 	ged_options = {'method': 'IPFP',

  670. 				   'initialization_method': 'RANDOM', # 'NODE'

  671. 				   'initial_solutions': 10, # 1

  672. 				   'edit_cost': 'LETTER2',

  673. 				   'attr_distance': 'euclidean',

  674. 				   'ratio_runs_from_initial_solutions': 1,

  675. 				   'threads': multiprocessing.cpu_count(),

  676. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  677. 	mge_options = {'init_type': 'MEDOID',

  678. 				   'random_inits': 10,

  679. 				   'time_limit': 600,

  680. 				   'verbose': 2,

  681. 				   'refine': False}

  682. 	save_results = True

  683. 	dir_save='../results/xp_median_preimage/'

  684. 	irrelevant_labels = {'edge_attrs': ['orient', 'angle']} #

  685. 	edge_required = True #

  686. 	

  687. 	# print settings.

  688. 	print('parameters:')

  689. 	print('dataset name:', ds_name)

  690. 	print('mpg_options:', mpg_options)

  691. 	print('kernel_options:', kernel_options)

  692. 	print('ged_options:', ged_options)

  693. 	print('mge_options:', mge_options)

  694. 	print('save_results:', save_results)

  695. 	print('irrelevant_labels:', irrelevant_labels)

  696. 	print()

  697. 	

  698. 	# generate preimages.

  699. 	for fit_method in ['k-graphs'] + ['random'] * 10:

  700. 		print('\n-------------------------------------')

  701. 		print('fit method:', fit_method, '\n')

  702. 		mpg_options['fit_method'] = fit_method

  703. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  704. 

  705. 

  706. def xp_median_preimage_3_1():

  707. 	"""xp 3_1: Fingerprint, StructuralSP, using LETTER2, only node attrs.

  708. 	"""

  709. 	# set parameters.

  710. 	ds_name = 'Fingerprint' #

  711. 	mpg_options = {'fit_method': 'k-graphs',

  712. 				   'init_ecc': [0.525, 0.525, 0.001, 0.125, 0.125], #

  713. 				   'ds_name': ds_name,

  714. 				   'parallel': True, # False

  715. 				   'time_limit_in_sec': 0,

  716. 				   'max_itrs': 100,

  717. 				   'max_itrs_without_update': 3,

  718. 				   'epsilon_residual': 0.01,

  719. 				   'epsilon_ec': 0.1,

  720. 				   'verbose': 2}

  721. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  722. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  723. 	kernel_options = {'name': 'StructuralSP',

  724. 					  'edge_weight': None,

  725. 					  'node_kernels': sub_kernels,

  726. 					  'edge_kernels': sub_kernels, 

  727. 					  'compute_method': 'naive',

  728.  					  'parallel': 'imap_unordered', 

  729.                       # 'parallel': None, 

  730. 					  'n_jobs': multiprocessing.cpu_count(),

  731. 					  'normalize': True,

  732. 					  'verbose': 2}

  733. 	ged_options = {'method': 'IPFP',

  734. 				   'initialization_method': 'RANDOM', # 'NODE'

  735. 				   'initial_solutions': 10, # 1

  736. 				   'edit_cost': 'LETTER2',

  737. 				   'attr_distance': 'euclidean',

  738. 				   'ratio_runs_from_initial_solutions': 1,

  739. 				   'threads': multiprocessing.cpu_count(),

  740. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  741. 	mge_options = {'init_type': 'MEDOID',

  742. 				   'random_inits': 10,

  743. 				   'time_limit': 600,

  744. 				   'verbose': 2,

  745. 				   'refine': False}

  746. 	save_results = True

  747. 	dir_save='../results/xp_median_preimage/'

  748. 	irrelevant_labels = {'edge_attrs': ['orient', 'angle']} #

  749. 	edge_required = False #

  750. 	

  751. 	# print settings.

  752. 	print('parameters:')

  753. 	print('dataset name:', ds_name)

  754. 	print('mpg_options:', mpg_options)

  755. 	print('kernel_options:', kernel_options)

  756. 	print('ged_options:', ged_options)

  757. 	print('mge_options:', mge_options)

  758. 	print('save_results:', save_results)

  759. 	print('irrelevant_labels:', irrelevant_labels)

  760. 	print()

  761. 	

  762. 	# generate preimages.

  763. 	for fit_method in ['k-graphs'] + ['random'] * 10:

  764. 		print('\n-------------------------------------')

  765. 		print('fit method:', fit_method, '\n')

  766. 		mpg_options['fit_method'] = fit_method

  767. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  768. 		

  769. 

  770. def xp_median_preimage_2_1():

  771. 	"""xp 2_1: COIL-DEL, StructuralSP, using LETTER2, only node attrs.

  772. 	"""

  773. 	# set parameters.

  774. 	ds_name = 'COIL-DEL' #

  775. 	mpg_options = {'fit_method': 'k-graphs',

  776. 				   'init_ecc': [3, 3, 1, 3, 3],

  777. 				   'ds_name': ds_name,

  778. 				   'parallel': True, # False

  779. 				   'time_limit_in_sec': 0,

  780. 				   'max_itrs': 100,

  781. 				   'max_itrs_without_update': 3,

  782. 				   'epsilon_residual': 0.01,

  783. 				   'epsilon_ec': 0.1,

  784. 				   'verbose': 2}

  785. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  786. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  787. 	kernel_options = {'name': 'StructuralSP',

  788. 					  'edge_weight': None,

  789. 					  'node_kernels': sub_kernels,

  790. 					  'edge_kernels': sub_kernels, 

  791. 					  'compute_method': 'naive',

  792.  					  'parallel': 'imap_unordered', 

  793.                       # 'parallel': None, 

  794. 					  'n_jobs': multiprocessing.cpu_count(),

  795. 					  'normalize': True,

  796. 					  'verbose': 2}

  797. 	ged_options = {'method': 'IPFP',

  798. 				   'initialization_method': 'RANDOM', # 'NODE'

  799. 				   'initial_solutions': 10, # 1

  800. 				   'edit_cost': 'LETTER2',

  801. 				   'attr_distance': 'euclidean',

  802. 				   'ratio_runs_from_initial_solutions': 1,

  803. 				   'threads': multiprocessing.cpu_count(),

  804. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  805. 	mge_options = {'init_type': 'MEDOID',

  806. 				   'random_inits': 10,

  807. 				   'time_limit': 600,

  808. 				   'verbose': 2,

  809. 				   'refine': False}

  810. 	save_results = True

  811. 	dir_save='../results/xp_median_preimage/'

  812. 	irrelevant_labels = {'edge_labels': ['valence']}

  813. 	

  814. 	# print settings.

  815. 	print('parameters:')

  816. 	print('dataset name:', ds_name)

  817. 	print('mpg_options:', mpg_options)

  818. 	print('kernel_options:', kernel_options)

  819. 	print('ged_options:', ged_options)

  820. 	print('mge_options:', mge_options)

  821. 	print('save_results:', save_results)

  822. 	print('irrelevant_labels:', irrelevant_labels)

  823. 	print()

  824. 	

  825. # 	# compute gram matrices for each class a priori.

  826. # 	print('Compute gram matrices for each class a priori.')

  827. # 	compute_gram_matrices_by_class(ds_name, kernel_options, save_results=True, dir_save=dir_save, irrelevant_labels=irrelevant_labels)

  828. 	

  829. 	# generate preimages.

  830. 	for fit_method in ['k-graphs'] + ['random'] * 10:

  831. 		print('\n-------------------------------------')

  832. 		print('fit method:', fit_method, '\n')

  833. 		mpg_options['fit_method'] = fit_method

  834. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels)

  835. 

  836. 

  837. def xp_median_preimage_1_1():

  838. 	"""xp 1_1: Letter-high, StructuralSP.

  839. 	"""

  840. 	# set parameters.

  841. 	ds_name = 'Letter-high'

  842. 	mpg_options = {'fit_method': 'k-graphs',

  843. 				   'init_ecc': [0.675, 0.675, 0.75, 0.425, 0.425],

  844. 				   'ds_name': ds_name,

  845. 				   'parallel': True, # False

  846. 				   'time_limit_in_sec': 0,

  847. 				   'max_itrs': 100,

  848. 				   'max_itrs_without_update': 3,

  849. 				   'epsilon_residual': 0.01,

  850. 				   'epsilon_ec': 0.1,

  851. 				   'verbose': 2}

  852. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  853. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  854. 	kernel_options = {'name': 'StructuralSP',

  855. 					  'edge_weight': None,

  856. 					  'node_kernels': sub_kernels,

  857. 					  'edge_kernels': sub_kernels, 

  858. 					  'compute_method': 'naive',

  859. 					  'parallel': 'imap_unordered', 

  860. # 						  'parallel': None, 

  861. 					  'n_jobs': multiprocessing.cpu_count(),

  862. 					  'normalize': True,

  863. 					  'verbose': 2}

  864. 	ged_options = {'method': 'IPFP',

  865. 				   'initialization_method': 'RANDOM', # 'NODE'

  866. 				   'initial_solutions': 10, # 1

  867. 				   'edit_cost': 'LETTER2',

  868. 				   'attr_distance': 'euclidean',

  869. 				   'ratio_runs_from_initial_solutions': 1,

  870. 				   'threads': multiprocessing.cpu_count(),

  871. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  872. 	mge_options = {'init_type': 'MEDOID',

  873. 				   'random_inits': 10,

  874. 				   'time_limit': 600,

  875. 				   'verbose': 2,

  876. 				   'refine': False}

  877. 	save_results = True

  878. 	

  879. 	# print settings.

  880. 	print('parameters:')

  881. 	print('dataset name:', ds_name)

  882. 	print('mpg_options:', mpg_options)

  883. 	print('kernel_options:', kernel_options)

  884. 	print('ged_options:', ged_options)

  885. 	print('mge_options:', mge_options)

  886. 	print('save_results:', save_results)

  887. 	

  888. 	# generate preimages.

  889. 	for fit_method in ['k-graphs', 'expert'] + ['random'] * 10:

  890. 		print('\n-------------------------------------')

  891. 		print('fit method:', fit_method, '\n')

  892. 		mpg_options['fit_method'] = fit_method

  893. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save='../results/xp_median_preimage/')

  894. 		

  895. 		

  896. def xp_median_preimage_1_2():

  897. 	"""xp 1_2: Letter-high, ShortestPath.

  898. 	"""

  899. 	# set parameters.

  900. 	ds_name = 'Letter-high'

  901. 	mpg_options = {'fit_method': 'k-graphs',

  902. 				   'init_ecc': [0.675, 0.675, 0.75, 0.425, 0.425],

  903. 				   'ds_name': ds_name,

  904. 				   'parallel': True, # False

  905. 				   'time_limit_in_sec': 0,

  906. 				   'max_itrs': 100,

  907. 				   'max_itrs_without_update': 3,

  908. 				   'epsilon_residual': 0.01,

  909. 				   'epsilon_ec': 0.1,

  910. 				   'verbose': 2}

  911. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  912. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  913. 	kernel_options = {'name': 'ShortestPath',

  914. 					  'edge_weight': None,

  915. 					  'node_kernels': sub_kernels,

  916. 					  'parallel': 'imap_unordered', 

  917. # 						  'parallel': None, 

  918. 					  'n_jobs': multiprocessing.cpu_count(),

  919. 					  'normalize': True,

  920. 					  'verbose': 2}

  921. 	ged_options = {'method': 'IPFP',

  922. 				   'initialization_method': 'RANDOM', # 'NODE'

  923. 				   'initial_solutions': 10, # 1

  924. 				   'edit_cost': 'LETTER2',

  925. 				   'attr_distance': 'euclidean',

  926. 				   'ratio_runs_from_initial_solutions': 1,

  927. 				   'threads': multiprocessing.cpu_count(),

  928. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  929. 	mge_options = {'init_type': 'MEDOID',

  930. 				   'random_inits': 10,

  931. 				   'time_limit': 600,

  932. 				   'verbose': 2,

  933. 				   'refine': False}

  934. 	save_results = True

  935. 	dir_save='../results/xp_median_preimage/'

  936. 	irrelevant_labels = None #

  937. 	edge_required = True #

  938. 	

  939. 	# print settings.

  940. 	print('parameters:')

  941. 	print('dataset name:', ds_name)

  942. 	print('mpg_options:', mpg_options)

  943. 	print('kernel_options:', kernel_options)

  944. 	print('ged_options:', ged_options)

  945. 	print('mge_options:', mge_options)

  946. 	print('save_results:', save_results)

  947. 	print('irrelevant_labels:', irrelevant_labels)

  948. 	print()

  949. 	

  950. 	# generate preimages.

  951. 	for fit_method in ['k-graphs', 'expert'] + ['random'] * 10:

  952. 		print('\n-------------------------------------')

  953. 		print('fit method:', fit_method, '\n')

  954. 		mpg_options['fit_method'] = fit_method

  955. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  956. 		

  957. 

  958. def xp_median_preimage_10_1():

  959. 	"""xp 10_1: Letter-med, StructuralSP.

  960. 	"""

  961. 	# set parameters.

  962. 	ds_name = 'Letter-med'

  963. 	mpg_options = {'fit_method': 'k-graphs',

  964. 				   'init_ecc': [0.525, 0.525, 0.75, 0.475, 0.475],

  965. 				   'ds_name': ds_name,

  966. 				   'parallel': True, # False

  967. 				   'time_limit_in_sec': 0,

  968. 				   'max_itrs': 100,

  969. 				   'max_itrs_without_update': 3,

  970. 				   'epsilon_residual': 0.01,

  971. 				   'epsilon_ec': 0.1,

  972. 				   'verbose': 2}

  973. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  974. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  975. 	kernel_options = {'name': 'StructuralSP',

  976. 					  'edge_weight': None,

  977. 					  'node_kernels': sub_kernels,

  978. 					  'edge_kernels': sub_kernels, 

  979. 					  'compute_method': 'naive',

  980. 					  'parallel': 'imap_unordered', 

  981. # 						  'parallel': None, 

  982. 					  'n_jobs': multiprocessing.cpu_count(),

  983. 					  'normalize': True,

  984. 					  'verbose': 2}

  985. 	ged_options = {'method': 'IPFP',

  986. 				   'initialization_method': 'RANDOM', # 'NODE'

  987. 				   'initial_solutions': 10, # 1

  988. 				   'edit_cost': 'LETTER2',

  989. 				   'attr_distance': 'euclidean',

  990. 				   'ratio_runs_from_initial_solutions': 1,

  991. 				   'threads': multiprocessing.cpu_count(),

  992. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  993. 	mge_options = {'init_type': 'MEDOID',

  994. 				   'random_inits': 10,

  995. 				   'time_limit': 600,

  996. 				   'verbose': 2,

  997. 				   'refine': False}

  998. 	save_results = True

  999. 	

  1000. 	# print settings.

  1001. 	print('parameters:')

  1002. 	print('dataset name:', ds_name)

  1003. 	print('mpg_options:', mpg_options)

  1004. 	print('kernel_options:', kernel_options)

  1005. 	print('ged_options:', ged_options)

  1006. 	print('mge_options:', mge_options)

  1007. 	print('save_results:', save_results)

  1008. 	

  1009. 	# generate preimages.

  1010. 	for fit_method in ['k-graphs', 'expert'] + ['random'] * 10:

  1011. 		print('\n-------------------------------------')

  1012. 		print('fit method:', fit_method, '\n')

  1013. 		mpg_options['fit_method'] = fit_method

  1014. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save='../results/xp_median_preimage/')

  1015. 		

  1016. 		

  1017. def xp_median_preimage_10_2():

  1018. 	"""xp 10_2: Letter-med, ShortestPath.

  1019. 	"""

  1020. 	# set parameters.

  1021. 	ds_name = 'Letter-med'

  1022. 	mpg_options = {'fit_method': 'k-graphs',

  1023. 				   'init_ecc': [0.525, 0.525, 0.75, 0.475, 0.475],

  1024. 				   'ds_name': ds_name,

  1025. 				   'parallel': True, # False

  1026. 				   'time_limit_in_sec': 0,

  1027. 				   'max_itrs': 100,

  1028. 				   'max_itrs_without_update': 3,

  1029. 				   'epsilon_residual': 0.01,

  1030. 				   'epsilon_ec': 0.1,

  1031. 				   'verbose': 2}

  1032. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  1033. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  1034. 	kernel_options = {'name': 'ShortestPath',

  1035. 					  'edge_weight': None,

  1036. 					  'node_kernels': sub_kernels,

  1037. 					  'parallel': 'imap_unordered', 

  1038. # 						  'parallel': None, 

  1039. 					  'n_jobs': multiprocessing.cpu_count(),

  1040. 					  'normalize': True,

  1041. 					  'verbose': 2}

  1042. 	ged_options = {'method': 'IPFP',

  1043. 				   'initialization_method': 'RANDOM', # 'NODE'

  1044. 				   'initial_solutions': 10, # 1

  1045. 				   'edit_cost': 'LETTER2',

  1046. 				   'attr_distance': 'euclidean',

  1047. 				   'ratio_runs_from_initial_solutions': 1,

  1048. 				   'threads': multiprocessing.cpu_count(),

  1049. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  1050. 	mge_options = {'init_type': 'MEDOID',

  1051. 				   'random_inits': 10,

  1052. 				   'time_limit': 600,

  1053. 				   'verbose': 2,

  1054. 				   'refine': False}

  1055. 	save_results = True

  1056. 	dir_save='../results/xp_median_preimage/'

  1057. 	irrelevant_labels = None #

  1058. 	edge_required = True #

  1059. 	

  1060. 	# print settings.

  1061. 	print('parameters:')

  1062. 	print('dataset name:', ds_name)

  1063. 	print('mpg_options:', mpg_options)

  1064. 	print('kernel_options:', kernel_options)

  1065. 	print('ged_options:', ged_options)

  1066. 	print('mge_options:', mge_options)

  1067. 	print('save_results:', save_results)

  1068. 	print('irrelevant_labels:', irrelevant_labels)

  1069. 	print()

  1070. 	

  1071. 	# generate preimages.

  1072. 	for fit_method in ['k-graphs', 'expert'] + ['random'] * 10:

  1073. 		print('\n-------------------------------------')

  1074. 		print('fit method:', fit_method, '\n')

  1075. 		mpg_options['fit_method'] = fit_method

  1076. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  1077. 

  1078. 

  1079. def xp_median_preimage_11_1():

  1080. 	"""xp 11_1: Letter-low, StructuralSP.

  1081. 	"""

  1082. 	# set parameters.

  1083. 	ds_name = 'Letter-low'

  1084. 	mpg_options = {'fit_method': 'k-graphs',

  1085. 				   'init_ecc': [0.075, 0.075, 0.25, 0.075, 0.075],

  1086. 				   'ds_name': ds_name,

  1087. 				   'parallel': True, # False

  1088. 				   'time_limit_in_sec': 0,

  1089. 				   'max_itrs': 100,

  1090. 				   'max_itrs_without_update': 3,

  1091. 				   'epsilon_residual': 0.01,

  1092. 				   'epsilon_ec': 0.1,

  1093. 				   'verbose': 2}

  1094. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  1095. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  1096. 	kernel_options = {'name': 'StructuralSP',

  1097. 					  'edge_weight': None,

  1098. 					  'node_kernels': sub_kernels,

  1099. 					  'edge_kernels': sub_kernels, 

  1100. 					  'compute_method': 'naive',

  1101. 					  'parallel': 'imap_unordered', 

  1102. # 						  'parallel': None, 

  1103. 					  'n_jobs': multiprocessing.cpu_count(),

  1104. 					  'normalize': True,

  1105. 					  'verbose': 2}

  1106. 	ged_options = {'method': 'IPFP',

  1107. 				   'initialization_method': 'RANDOM', # 'NODE'

  1108. 				   'initial_solutions': 10, # 1

  1109. 				   'edit_cost': 'LETTER2',

  1110. 				   'attr_distance': 'euclidean',

  1111. 				   'ratio_runs_from_initial_solutions': 1,

  1112. 				   'threads': multiprocessing.cpu_count(),

  1113. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  1114. 	mge_options = {'init_type': 'MEDOID',

  1115. 				   'random_inits': 10,

  1116. 				   'time_limit': 600,

  1117. 				   'verbose': 2,

  1118. 				   'refine': False}

  1119. 	save_results = True

  1120. 	

  1121. 	# print settings.

  1122. 	print('parameters:')

  1123. 	print('dataset name:', ds_name)

  1124. 	print('mpg_options:', mpg_options)

  1125. 	print('kernel_options:', kernel_options)

  1126. 	print('ged_options:', ged_options)

  1127. 	print('mge_options:', mge_options)

  1128. 	print('save_results:', save_results)

  1129. 	

  1130. 	# generate preimages.

  1131. 	for fit_method in ['k-graphs', 'expert'] + ['random'] * 10:

  1132. 		print('\n-------------------------------------')

  1133. 		print('fit method:', fit_method, '\n')

  1134. 		mpg_options['fit_method'] = fit_method

  1135. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save='../results/xp_median_preimage/')

  1136. 		

  1137. 		

  1138. def xp_median_preimage_11_2():

  1139. 	"""xp 11_2: Letter-low, ShortestPath.

  1140. 	"""

  1141. 	# set parameters.

  1142. 	ds_name = 'Letter-low'

  1143. 	mpg_options = {'fit_method': 'k-graphs',

  1144. 				   'init_ecc': [0.075, 0.075, 0.25, 0.075, 0.075],

  1145. 				   'ds_name': ds_name,

  1146. 				   'parallel': True, # False

  1147. 				   'time_limit_in_sec': 0,

  1148. 				   'max_itrs': 100,

  1149. 				   'max_itrs_without_update': 3,

  1150. 				   'epsilon_residual': 0.01,

  1151. 				   'epsilon_ec': 0.1,

  1152. 				   'verbose': 2}

  1153. 	mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel)

  1154. 	sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}

  1155. 	kernel_options = {'name': 'ShortestPath',

  1156. 					  'edge_weight': None,

  1157. 					  'node_kernels': sub_kernels,

  1158. 					  'parallel': 'imap_unordered', 

  1159. # 						  'parallel': None, 

  1160. 					  'n_jobs': multiprocessing.cpu_count(),

  1161. 					  'normalize': True,

  1162. 					  'verbose': 2}

  1163. 	ged_options = {'method': 'IPFP',

  1164. 				   'initialization_method': 'RANDOM', # 'NODE'

  1165. 				   'initial_solutions': 10, # 1

  1166. 				   'edit_cost': 'LETTER2',

  1167. 				   'attr_distance': 'euclidean',

  1168. 				   'ratio_runs_from_initial_solutions': 1,

  1169. 				   'threads': multiprocessing.cpu_count(),

  1170. 				   'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'}

  1171. 	mge_options = {'init_type': 'MEDOID',

  1172. 				   'random_inits': 10,

  1173. 				   'time_limit': 600,

  1174. 				   'verbose': 2,

  1175. 				   'refine': False}

  1176. 	save_results = True

  1177. 	dir_save='../results/xp_median_preimage/'

  1178. 	irrelevant_labels = None #

  1179. 	edge_required = True #

  1180. 	

  1181. 	# print settings.

  1182. 	print('parameters:')

  1183. 	print('dataset name:', ds_name)

  1184. 	print('mpg_options:', mpg_options)

  1185. 	print('kernel_options:', kernel_options)

  1186. 	print('ged_options:', ged_options)

  1187. 	print('mge_options:', mge_options)

  1188. 	print('save_results:', save_results)

  1189. 	print('irrelevant_labels:', irrelevant_labels)

  1190. 	print()

  1191. 	

  1192. 	# generate preimages.

  1193. 	for fit_method in ['k-graphs', 'expert'] + ['random'] * 10:

  1194. 		print('\n-------------------------------------')

  1195. 		print('fit method:', fit_method, '\n')

  1196. 		mpg_options['fit_method'] = fit_method

  1197. 		generate_median_preimages_by_class(ds_name, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, save_medians=True, plot_medians=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  1198. 

  1199. 

  1200. if __name__ == "__main__":

  1201. 	

  1202. 	#### xp 1_1: Letter-high, StructuralSP.

  1203.  	# xp_median_preimage_1_1()

  1204. 

  1205. 	#### xp 1_2: Letter-high, ShortestPath.

  1206. # 	xp_median_preimage_1_2()

  1207. 

  1208. 	#### xp 10_1: Letter-med, StructuralSP.

  1209.  	# xp_median_preimage_10_1()

  1210. 

  1211. 	#### xp 10_2: Letter-med, ShortestPath.

  1212.  	# xp_median_preimage_10_2()

  1213. 

  1214. 	#### xp 11_1: Letter-low, StructuralSP.

  1215.  	# xp_median_preimage_11_1()

  1216. 

  1217. 	#### xp 11_2: Letter-low, ShortestPath.

  1218. # 	xp_median_preimage_11_2()

  1219. 	

  1220. 	#### xp 2_1: COIL-DEL, StructuralSP, using LETTER2, only node attrs.

  1221. # 	xp_median_preimage_2_1()

  1222. 	

  1223. 	#### xp 3_1: Fingerprint, StructuralSP, using LETTER2, only node attrs.

  1224.  	# xp_median_preimage_3_1()

  1225. 

  1226. 	#### xp 3_2: Fingerprint, ShortestPath, using LETTER2, only node attrs.

  1227. # 	xp_median_preimage_3_2()

  1228. 

  1229. 	#### xp 4_1: COLORS-3, StructuralSP, using NON_SYMBOLIC.

  1230. # 	xp_median_preimage_4_1()

  1231. 	

  1232. 	#### xp 5_1: FRANKENSTEIN, StructuralSP, using NON_SYMBOLIC.

  1233. # 	xp_median_preimage_5_1()

  1234. 	

  1235. 	#### xp 6_1: COIL-RAG, StructuralSP, using NON_SYMBOLIC.

  1236.  	# xp_median_preimage_6_1()

  1237. 

  1238. 	#### xp 6_2: COIL-RAG, ShortestPath, using NON_SYMBOLIC.

  1239. # 	xp_median_preimage_6_2()

  1240. 

  1241. 	#### xp 7_1: MUTAG, StructuralSP, using CONSTANT.

  1242.  	# xp_median_preimage_7_1()

  1243. 

  1244. 	#### xp 7_2: MUTAG, PathUpToH, using CONSTANT.

  1245.  	xp_median_preimage_7_2()

  1246. 	 

  1247.     #### xp 8_1: Monoterpenoides, StructuralSP, using CONSTANT.

  1248. # 	xp_median_preimage_8_1()

  1249. 

  1250. 	#### xp 8_2: Monoterpenoides, PathUpToH, using CONSTANT.

  1251. # 	xp_median_preimage_8_2()

  1252. 

  1253. 	#### xp 9_1: MAO, StructuralSP, using CONSTANT, symbolic only.

  1254. # 	xp_median_preimage_9_1()

  1255. 

  1256. 	#### xp 9_2: MAO, PathUpToH, using CONSTANT, symbolic only.

  1257. # 	xp_median_preimage_9_2()