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

1193 lines
40 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. import sys

  11. import os

  12. import logging

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

  14. from gklearn.preimage import generate_random_preimages_by_class

  15. from gklearn.utils import compute_gram_matrices_by_class

  16. 

  17. 

  18. dir_root = '../results/xp_random_preimage/'

  19. 

  20. 

  21. def xp_median_preimage_15_1():

  22. 	"""xp 15_1: AIDS, StructuralSP, using CONSTANT, symbolic only.

  23. 	"""

  24. 	# set parameters.

  25. 	ds_name = 'AIDS' #

  26. 	rpg_options = {'k': 5,

  27. 				   'r_max': 10, #

  28. 				   'l': 500,

  29. 				   'alphas': None,

  30. 				   'parallel': True,

  31. 				   'verbose': 2}

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

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

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

  35. 					  'edge_weight': None,

  36. 					  'node_kernels': sub_kernels,

  37. 					  'edge_kernels': sub_kernels, 

  38. 					  'compute_method': 'naive',

  39.  					  'parallel': 'imap_unordered', 

  40.                       # 'parallel': None, 

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

  42. 					  'normalize': True,

  43. 					  'verbose': 0}

  44. 	save_results = True

  45. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.symb/'

  46. 	irrelevant_labels = {'node_attrs': ['chem', 'charge', 'x', 'y'], 'edge_labels': ['valence']} #

  47. 	edge_required = False #

  48. 	

  49. 	if not os.path.exists(dir_save):

  50. 		os.makedirs(dir_save)

  51. 	file_output = open(dir_save + 'output.txt', 'a')

  52. 	sys.stdout = file_output

  53. 

  54. 	# print settings.

  55. 	print('parameters:')

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

  57. 	print('kernel_options:', kernel_options)

  58. 	print('save_results:', save_results)

  59. 	print('irrelevant_labels:', irrelevant_labels)

  60. 	print()

  61. 	

  62. 	# generate preimages.

  63. 	try:

  64. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  65. 	except Exception as exp:

  66. 		print('An exception occured when running this experiment:')

  67. 		LOG_FILENAME = dir_save + 'error.txt'

  68. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  69. 		logging.exception('')

  70. 		print(repr(exp))

  71. 				

  72. 

  73. def xp_median_preimage_15_2():

  74. 	"""xp 15_2: AIDS, PathUpToH, using CONSTANT, symbolic only.

  75. 	"""

  76. 	# set parameters.

  77. 	ds_name = 'AIDS' #

  78. 	rpg_options = {'k': 5,

  79. 				   'r_max': 10, #

  80. 				   'l': 500,

  81. 				   'alphas': None,

  82. 				   'parallel': True,

  83. 				   'verbose': 2}

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

  85. 					  'depth': 1, #

  86. 					  'k_func': 'MinMax', #

  87. 					  'compute_method': 'trie',

  88.  					  'parallel': 'imap_unordered', 

  89.                       # 'parallel': None, 

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

  91. 					  'normalize': True,

  92. 					  'verbose': 0}

  93. 	save_results = True

  94. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.symb/' 

  95. 	irrelevant_labels = {'node_attrs': ['chem', 'charge', 'x', 'y'], 'edge_labels': ['valence']} #

  96. 	edge_required = False #

  97. 	

  98. 	if not os.path.exists(dir_save):

  99. 		os.makedirs(dir_save)

  100. 	file_output = open(dir_save + 'output.txt', 'a')

  101. 	sys.stdout = file_output

  102. 

  103. 	# print settings.

  104. 	print('parameters:')

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

  106. 	print('kernel_options:', kernel_options)

  107. 	print('save_results:', save_results)

  108. 	print('irrelevant_labels:', irrelevant_labels)

  109. 	print()

  110.  

  111. 	# generate preimages.

  112. 	try:

  113. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  114. 	except Exception as exp:

  115. 		print('An exception occured when running this experiment:')

  116. 		LOG_FILENAME = dir_save + 'error.txt'

  117. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  118. 		logging.exception('')

  119. 		print(repr(exp))

  120. 			

  121. 			

  122. def xp_median_preimage_15_3():

  123. 	"""xp 15_3: AIDS, Treelet, using CONSTANT, symbolic only.

  124. 	"""

  125. 	from gklearn.utils.kernels import polynomialkernel

  126. 	# set parameters.

  127. 	ds_name = 'AIDS' #

  128. 	rpg_options = {'k': 5,

  129. 				   'r_max': 10, #

  130. 				   'l': 500,

  131. 				   'alphas': None,

  132. 				   'parallel': True,

  133. 				   'verbose': 2}

  134. 	pkernel = functools.partial(polynomialkernel, d=1, c=1e+2)

  135. 	kernel_options = {'name': 'Treelet', #

  136. 				      'sub_kernel': pkernel,

  137.  					  'parallel': 'imap_unordered', 

  138.                       # 'parallel': None, 

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

  140. 					  'normalize': True,

  141. 					  'verbose': 0}

  142. 	save_results = True

  143. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.symb/' 

  144. 	irrelevant_labels = {'node_attrs': ['chem', 'charge', 'x', 'y'], 'edge_labels': ['valence']} #

  145. 	edge_required = False #

  146. 	

  147. 	if not os.path.exists(dir_save):

  148. 		os.makedirs(dir_save)

  149. 	file_output = open(dir_save + 'output.txt', 'a')

  150. 	sys.stdout = file_output

  151. 

  152. 	# print settings.

  153. 	print('parameters:')

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

  155. 	print('kernel_options:', kernel_options)

  156. 	print('save_results:', save_results)

  157. 	print('irrelevant_labels:', irrelevant_labels)

  158. 	print()

  159. 	

  160. 	# generate preimages.

  161. 	try:

  162. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  163. 	except Exception as exp:

  164. 		print('An exception occured when running this experiment:')

  165. 		LOG_FILENAME = dir_save + 'error.txt'

  166. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  167. 		logging.exception('')

  168. 		print(repr(exp))

  169. 			

  170. 			

  171. def xp_median_preimage_15_4():

  172. 	"""xp 15_4: AIDS, WeisfeilerLehman, using CONSTANT, symbolic only.

  173. 	"""

  174. 	# set parameters.

  175. 	ds_name = 'AIDS' #

  176. 	rpg_options = {'k': 5,

  177. 				   'r_max': 10, #

  178. 				   'l': 500,

  179. 				   'alphas': None,

  180. 				   'parallel': True,

  181. 				   'verbose': 2}

  182. 	kernel_options = {'name': 'WeisfeilerLehman',

  183. 				      'height': 10,

  184. 					  'base_kernel': 'subtree',

  185.  					  'parallel': 'imap_unordered', 

  186.                       # 'parallel': None, 

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

  188. 					  'normalize': True,

  189. 					  'verbose': 0}

  190. 	save_results = True

  191. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.symb/' 

  192. 	irrelevant_labels = {'node_attrs': ['chem', 'charge', 'x', 'y'], 'edge_labels': ['valence']} #

  193. 	edge_required = False #

  194. 	

  195. 	if not os.path.exists(dir_save):

  196. 		os.makedirs(dir_save)

  197. 	file_output = open(dir_save + 'output.txt', 'a')

  198. 	sys.stdout = file_output

  199. 

  200. 	# print settings.

  201. 	print('parameters:')

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

  203. 	print('kernel_options:', kernel_options)

  204. 	print('save_results:', save_results)

  205. 	print('irrelevant_labels:', irrelevant_labels)

  206. 	print()

  207. 	

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

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

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

  211. 	

  212. 	# generate preimages.

  213. 	try:

  214. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  215. 	except Exception as exp:

  216. 		print('An exception occured when running this experiment:')

  217. 		LOG_FILENAME = dir_save + 'error.txt'

  218. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  219. 		logging.exception('')

  220. 		print(repr(exp))

  221. 

  222. 

  223. def xp_median_preimage_14_1():

  224. 	"""xp 14_1: DD, PathUpToH, using CONSTANT.

  225. 	"""

  226. 	# set parameters.

  227. 	ds_name = 'DD' #

  228. 	rpg_options = {'k': 5,

  229. 				   'r_max': 10, #

  230. 				   'l': 500,

  231. 				   'alphas': None,

  232. 				   'parallel': True,

  233. 				   'verbose': 2}

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

  235. 					  'depth': 2, #

  236. 					  'k_func': 'MinMax', #

  237. 					  'compute_method': 'trie',

  238.  					  'parallel': 'imap_unordered', 

  239.                       # 'parallel': None, 

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

  241. 					  'normalize': True,

  242. 					  'verbose': 0}

  243. 	save_results = True

  244. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' 

  245. 	irrelevant_labels = None #

  246. 	edge_required = False #

  247. 

  248. 	if not os.path.exists(dir_save):

  249. 		os.makedirs(dir_save)

  250. 	file_output = open(dir_save + 'output.txt', 'a')

  251. 	sys.stdout = file_output

  252. 	

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

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

  255. # 	compute_gram_matrices_by_class(ds_name, kernel_options, save_results=save_results, dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  256. 	

  257. 	# print settings.

  258. 	print('parameters:')

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

  260. 	print('kernel_options:', kernel_options)

  261. 	print('save_results:', save_results)

  262. 	print('irrelevant_labels:', irrelevant_labels)

  263. 	print()

  264. 	

  265. 	# generate preimages.

  266. 	try:

  267. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  268. 	except Exception as exp:

  269. 		print('An exception occured when running this experiment:')

  270. 		LOG_FILENAME = dir_save + 'error.txt'

  271. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  272. 		logging.exception('')

  273. 		print(repr(exp))

  274. 

  275. 

  276. def xp_median_preimage_12_1():

  277. 	"""xp 12_1: PAH, StructuralSP, using NON_SYMBOLIC, unlabeled.

  278. 	"""

  279. 	# set parameters.

  280. 	ds_name = 'PAH' #

  281. 	rpg_options = {'k': 5,

  282. 				   'r_max': 10, #

  283. 				   'l': 500,

  284. 				   'alphas': None,

  285. 				   'parallel': True,

  286. 				   'verbose': 2}

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

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

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

  290. 					  'edge_weight': None,

  291. 					  'node_kernels': sub_kernels,

  292. 					  'edge_kernels': sub_kernels, 

  293. 					  'compute_method': 'naive',

  294.  					  'parallel': 'imap_unordered', 

  295.                       # 'parallel': None, 

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

  297. 					  'normalize': True,

  298. 					  'verbose': 0}

  299. 	save_results = True

  300. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.unlabeled/' 

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

  302. 	edge_required = False #

  303. 	

  304. 	if not os.path.exists(dir_save):

  305. 		os.makedirs(dir_save)

  306. 	file_output = open(dir_save + 'output.txt', 'a')

  307. 	sys.stdout = file_output

  308. 

  309. 	# print settings.

  310. 	print('parameters:')

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

  312. 	print('kernel_options:', kernel_options)

  313. 	print('save_results:', save_results)

  314. 	print('irrelevant_labels:', irrelevant_labels)

  315. 	print()

  316. 	

  317. 	# generate preimages.

  318. 	try:

  319. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  320. 	except Exception as exp:

  321. 		print('An exception occured when running this experiment:')

  322. 		LOG_FILENAME = dir_save + 'error.txt'

  323. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  324. 		logging.exception('')

  325. 		print(repr(exp))

  326. 		

  327. 		

  328. def xp_median_preimage_12_2():

  329. 	"""xp 12_2: PAH, PathUpToH, using CONSTANT, unlabeled.

  330. 	"""

  331. 	# set parameters.

  332. 	ds_name = 'PAH' #

  333. 	rpg_options = {'k': 5,

  334. 				   'r_max': 10, #

  335. 				   'l': 500,

  336. 				   'alphas': None,

  337. 				   'parallel': True,

  338. 				   'verbose': 2}

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

  340. 					  'depth': 1, #

  341. 					  'k_func': 'MinMax', #

  342. 					  'compute_method': 'trie',

  343.  					  'parallel': 'imap_unordered', 

  344.                       # 'parallel': None, 

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

  346. 					  'normalize': True,

  347. 					  'verbose': 0}

  348. 	save_results = True

  349. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.unlabeled/' 

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

  351. 	edge_required = False #

  352. 	

  353. 	if not os.path.exists(dir_save):

  354. 		os.makedirs(dir_save)

  355. 	file_output = open(dir_save + 'output.txt', 'a')

  356. 	sys.stdout = file_output

  357. 

  358. 	# print settings.

  359. 	print('parameters:')

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

  361. 	print('kernel_options:', kernel_options)

  362. 	print('save_results:', save_results)

  363. 	print('irrelevant_labels:', irrelevant_labels)

  364. 	print()

  365. 	

  366. 	# generate preimages.

  367. 	try:

  368. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  369. 	except Exception as exp:

  370. 		print('An exception occured when running this experiment:')

  371. 		LOG_FILENAME = dir_save + 'error.txt'

  372. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  373. 		logging.exception('')

  374. 		print(repr(exp))

  375. 		

  376. 

  377. def xp_median_preimage_12_3():

  378. 	"""xp 12_3: PAH, Treelet, using CONSTANT, unlabeled.

  379. 	"""

  380. 	from gklearn.utils.kernels import gaussiankernel

  381. 	# set parameters.

  382. 	ds_name = 'PAH' #

  383. 	rpg_options = {'k': 5,

  384. 				   'r_max': 10, #

  385. 				   'l': 500,

  386. 				   'alphas': None,

  387. 				   'parallel': True,

  388. 				   'verbose': 2}

  389. 	pkernel = functools.partial(gaussiankernel, gamma=None) # @todo

  390. 	kernel_options = {'name': 'Treelet', #

  391. 				      'sub_kernel': pkernel,

  392.  					  'parallel': 'imap_unordered', 

  393.                       # 'parallel': None, 

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

  395. 					  'normalize': True,

  396. 					  'verbose': 0}

  397. 	save_results = True

  398. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.unlabeled/' 

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

  400. 	edge_required = False #

  401. 

  402. 	if not os.path.exists(dir_save):

  403. 		os.makedirs(dir_save)

  404. 	file_output = open(dir_save + 'output.txt', 'a')

  405. 	sys.stdout = file_output

  406. 	

  407. 	# print settings.

  408. 	print('parameters:')

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

  410. 	print('kernel_options:', kernel_options)

  411. 	print('save_results:', save_results)

  412. 	print('irrelevant_labels:', irrelevant_labels)

  413. 	print()

  414. 	

  415. 	# generate preimages.

  416. 	try:

  417. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  418. 	except Exception as exp:

  419. 		print('An exception occured when running this experiment:')

  420. 		LOG_FILENAME = dir_save + 'error.txt'

  421. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  422. 		logging.exception('')

  423. 		print(repr(exp))

  424. 		

  425. 		

  426. def xp_median_preimage_12_4():

  427. 	"""xp 12_4: PAH, WeisfeilerLehman, using CONSTANT, unlabeled.

  428. 	"""

  429. 	# set parameters.

  430. 	ds_name = 'PAH' #

  431. 	rpg_options = {'k': 5,

  432. 				   'r_max': 10, #

  433. 				   'l': 500,

  434. 				   'alphas': None,

  435. 				   'parallel': True,

  436. 				   'verbose': 2}

  437. 	kernel_options = {'name': 'WeisfeilerLehman',

  438. 				      'height': 14,

  439. 					  'base_kernel': 'subtree',

  440.  					  'parallel': 'imap_unordered', 

  441.                       # 'parallel': None, 

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

  443. 					  'normalize': True,

  444. 					  'verbose': 0}

  445. 	save_results = True

  446. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.unlabeled/' 

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

  448. 	edge_required = False #

  449. 	

  450. 	if not os.path.exists(dir_save):

  451. 		os.makedirs(dir_save)

  452. 	file_output = open(dir_save + 'output.txt', 'a')

  453. 	sys.stdout = file_output

  454. 

  455. 	# print settings.

  456. 	print('parameters:')

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

  458. 	print('kernel_options:', kernel_options)

  459. 	print('save_results:', save_results)

  460. 	print('irrelevant_labels:', irrelevant_labels)

  461. 	print()

  462. 	

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

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

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

  466. 	

  467. 	# generate preimages.

  468. 	try:

  469. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  470. 	except Exception as exp:

  471. 		print('An exception occured when running this experiment:')

  472. 		LOG_FILENAME = dir_save + 'error.txt'

  473. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  474. 		logging.exception('')

  475. 		print(repr(exp))

  476. 		

  477. 		

  478. def xp_median_preimage_12_5():

  479. 	"""xp 12_5: PAH, ShortestPath, using NON_SYMBOLIC, unlabeled.

  480. 	"""

  481. 	# set parameters.

  482. 	ds_name = 'PAH' #

  483. 	rpg_options = {'k': 5,

  484. 				   'r_max': 10, #

  485. 				   'l': 500,

  486. 				   'alphas': None,

  487. 				   'parallel': True,

  488. 				   'verbose': 2}

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

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

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

  492. 					  'edge_weight': None,

  493. 					  'node_kernels': sub_kernels,

  494.  					  'parallel': 'imap_unordered', 

  495.                       # 'parallel': None, 

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

  497. 					  'normalize': True,

  498. 					  'verbose': 0}

  499. 	save_results = True

  500. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.unlabeled/'  # 

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

  502. 	edge_required = True #

  503. 	

  504. 	if not os.path.exists(dir_save):

  505. 		os.makedirs(dir_save)

  506. 	file_output = open(dir_save + 'output.txt', 'a')

  507. 	sys.stdout = file_output

  508. 

  509. 	# print settings.

  510. 	print('parameters:')

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

  512. 	print('kernel_options:', kernel_options)

  513. 	print('save_results:', save_results)

  514. 	print('irrelevant_labels:', irrelevant_labels)

  515. 	print()

  516. 	

  517. 	# generate preimages.

  518. 	try:

  519. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  520. 	except Exception as exp:

  521. 		print('An exception occured when running this experiment:')

  522. 		LOG_FILENAME = dir_save + 'error.txt'

  523. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  524. 		logging.exception('')

  525. 		print(repr(exp))

  526. 

  527. 

  528. def xp_median_preimage_9_1():

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

  530. 	"""

  531. 	# set parameters.

  532. 	ds_name = 'MAO' #

  533. 	rpg_options = {'k': 5,

  534. 				   'r_max': 10, #

  535. 				   'l': 500,

  536. 				   'alphas': None,

  537. 				   'parallel': True,

  538. 				   'verbose': 2}

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

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

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

  542. 					  'edge_weight': None,

  543. 					  'node_kernels': sub_kernels,

  544. 					  'edge_kernels': sub_kernels, 

  545. 					  'compute_method': 'naive',

  546.  					  'parallel': 'imap_unordered', 

  547.                       # 'parallel': None, 

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

  549. 					  'normalize': True,

  550. 					  'verbose': 0}

  551. 	save_results = True

  552. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.symb/' 

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

  554. 	edge_required = False #

  555. 	

  556. 	if not os.path.exists(dir_save):

  557. 		os.makedirs(dir_save)

  558. 	file_output = open(dir_save + 'output.txt', 'a')

  559. 	sys.stdout = file_output

  560. 

  561. 	# print settings.

  562. 	print('parameters:')

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

  564. 	print('kernel_options:', kernel_options)

  565. 	print('save_results:', save_results)

  566. 	print('irrelevant_labels:', irrelevant_labels)

  567. 	print()

  568. 	

  569. 	# generate preimages.

  570. 	try:

  571. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  572. 	except Exception as exp:

  573. 		print('An exception occured when running this experiment:')

  574. 		LOG_FILENAME = dir_save + 'error.txt'

  575. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  576. 		logging.exception('')

  577. 		print(repr(exp))

  578. 		

  579. 			

  580. def xp_median_preimage_9_2():

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

  582. 	"""

  583. 	# set parameters.

  584. 	ds_name = 'MAO' #

  585. 	rpg_options = {'k': 5,

  586. 				   'r_max': 10, #

  587. 				   'l': 500,

  588. 				   'alphas': None,

  589. 				   'parallel': True,

  590. 				   'verbose': 2}

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

  592. 					  'depth': 9, #

  593. 					  'k_func': 'MinMax', #

  594. 					  'compute_method': 'trie',

  595.  					  'parallel': 'imap_unordered', 

  596.                       # 'parallel': None, 

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

  598. 					  'normalize': True,

  599. 					  'verbose': 0}

  600. 	save_results = True

  601. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.symb/' 

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

  603. 	edge_required = False #

  604. 	

  605. 	if not os.path.exists(dir_save):

  606. 		os.makedirs(dir_save)

  607. 	file_output = open(dir_save + 'output.txt', 'a')

  608. 	sys.stdout = file_output

  609. 

  610. 	# print settings.

  611. 	print('parameters:')

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

  613. 	print('kernel_options:', kernel_options)

  614. 	print('save_results:', save_results)

  615. 	print('irrelevant_labels:', irrelevant_labels)

  616. 	print()

  617. 	

  618. 	# generate preimages.

  619. 	try:

  620. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  621. 	except Exception as exp:

  622. 		print('An exception occured when running this experiment:')

  623. 		LOG_FILENAME = dir_save + 'error.txt'

  624. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  625. 		logging.exception('')

  626. 		print(repr(exp))

  627. 		

  628. 			

  629. def xp_median_preimage_9_3():

  630. 	"""xp 9_3: MAO, Treelet, using CONSTANT, symbolic only.

  631. 	"""

  632. 	from gklearn.utils.kernels import polynomialkernel

  633. 	# set parameters.

  634. 	ds_name = 'MAO' #

  635. 	rpg_options = {'k': 5,

  636. 				   'r_max': 10, #

  637. 				   'l': 500,

  638. 				   'alphas': None,

  639. 				   'parallel': True,

  640. 				   'verbose': 2}

  641. 	pkernel = functools.partial(polynomialkernel, d=4, c=1e+7)

  642. 	kernel_options = {'name': 'Treelet', #

  643. 				      'sub_kernel': pkernel,

  644.  					  'parallel': 'imap_unordered', 

  645.                       # 'parallel': None, 

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

  647. 					  'normalize': True,

  648. 					  'verbose': 0}

  649. 	save_results = True

  650. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.symb/' 

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

  652. 	edge_required = False #

  653. 	

  654. 	if not os.path.exists(dir_save):

  655. 		os.makedirs(dir_save)

  656. 	file_output = open(dir_save + 'output.txt', 'a')

  657. 	sys.stdout = file_output

  658. 

  659. 	# print settings.

  660. 	print('parameters:')

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

  662. 	print('kernel_options:', kernel_options)

  663. 	print('save_results:', save_results)

  664. 	print('irrelevant_labels:', irrelevant_labels)

  665. 	print()

  666. 	

  667. 	# generate preimages.

  668. 	try:

  669. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  670. 	except Exception as exp:

  671. 		print('An exception occured when running this experiment:')

  672. 		LOG_FILENAME = dir_save + 'error.txt'

  673. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  674. 		logging.exception('')

  675. 		print(repr(exp))

  676. 		

  677. 			

  678. def xp_median_preimage_9_4():

  679. 	"""xp 9_4: MAO, WeisfeilerLehman, using CONSTANT, symbolic only.

  680. 	"""

  681. 	# set parameters.

  682. 	ds_name = 'MAO' #

  683. 	rpg_options = {'k': 5,

  684. 				   'r_max': 10, #

  685. 				   'l': 500,

  686. 				   'alphas': None,

  687. 				   'parallel': True,

  688. 				   'verbose': 2}

  689. 	kernel_options = {'name': 'WeisfeilerLehman',

  690. 				      'height': 6,

  691. 					  'base_kernel': 'subtree',

  692.  					  'parallel': 'imap_unordered', 

  693.                       # 'parallel': None, 

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

  695. 					  'normalize': True,

  696. 					  'verbose': 0}

  697. 	save_results = True

  698. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.symb/' 

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

  700. 	edge_required = False #

  701. 	

  702. 	if not os.path.exists(dir_save):

  703. 		os.makedirs(dir_save)

  704. 	file_output = open(dir_save + 'output.txt', 'a')

  705. 	sys.stdout = file_output

  706. 

  707. 	# print settings.

  708. 	print('parameters:')

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

  710. 	print('kernel_options:', kernel_options)

  711. 	print('save_results:', save_results)

  712. 	print('irrelevant_labels:', irrelevant_labels)

  713. 	print()

  714. 	

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

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

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

  718. 	

  719. 	# generate preimages.

  720. 	try:

  721. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  722. 	except Exception as exp:

  723. 		print('An exception occured when running this experiment:')

  724. 		LOG_FILENAME = dir_save + 'error.txt'

  725. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  726. 		logging.exception('')

  727. 		print(repr(exp))

  728. 

  729. 

  730. def xp_median_preimage_8_1():

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

  732. 	"""

  733. 	# set parameters.

  734. 	ds_name = 'Monoterpenoides' #

  735. 	rpg_options = {'k': 5,

  736. 				   'r_max': 10, #

  737. 				   'l': 500,

  738. 				   'alphas': None,

  739. 				   'parallel': True,

  740. 				   'verbose': 2}

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

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

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

  744. 					  'edge_weight': None,

  745. 					  'node_kernels': sub_kernels,

  746. 					  'edge_kernels': sub_kernels, 

  747. 					  'compute_method': 'naive',

  748.  					  'parallel': 'imap_unordered', 

  749.                       # 'parallel': None, 

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

  751. 					  'normalize': True,

  752. 					  'verbose': 0}

  753. 	save_results = True

  754. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' 

  755. 	irrelevant_labels = {'edge_labels': ['valence']} #

  756. 	edge_required = False #

  757. 	

  758. 	if not os.path.exists(dir_save):

  759. 		os.makedirs(dir_save)

  760. 	file_output = open(dir_save + 'output.txt', 'a')

  761. 	sys.stdout = file_output

  762. 

  763. 	# print settings.

  764. 	print('parameters:')

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

  766. 	print('kernel_options:', kernel_options)

  767. 	print('save_results:', save_results)

  768. 	print('irrelevant_labels:', irrelevant_labels)

  769. 	print()

  770. 	

  771. 	# generate preimages.

  772. 	try:

  773. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  774. 	except Exception as exp:

  775. 		print('An exception occured when running this experiment:')

  776. 		LOG_FILENAME = dir_save + 'error.txt'

  777. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  778. 		logging.exception('')

  779. 		print(repr(exp))

  780. 			

  781. 			

  782. def xp_median_preimage_8_2():

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

  784. 	"""

  785. 	# set parameters.

  786. 	ds_name = 'Monoterpenoides' #

  787. 	rpg_options = {'k': 5,

  788. 				   'r_max': 10, #

  789. 				   'l': 500,

  790. 				   'alphas': None,

  791. 				   'parallel': True,

  792. 				   'verbose': 2}

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

  794. 					  'depth': 7, #

  795. 					  'k_func': 'MinMax', #

  796. 					  'compute_method': 'trie',

  797.  					  'parallel': 'imap_unordered', 

  798.                       # 'parallel': None, 

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

  800. 					  'normalize': True,

  801. 					  'verbose': 0}

  802. 	save_results = True

  803. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' 

  804. 	irrelevant_labels = {'edge_labels': ['valence']} #

  805. 	edge_required = False #

  806. 	

  807. 	if not os.path.exists(dir_save):

  808. 		os.makedirs(dir_save)

  809. 	file_output = open(dir_save + 'output.txt', 'a')

  810. 	sys.stdout = file_output

  811. 

  812. 	# print settings.

  813. 	print('parameters:')

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

  815. 	print('kernel_options:', kernel_options)

  816. 	print('save_results:', save_results)

  817. 	print('irrelevant_labels:', irrelevant_labels)

  818. 	print()

  819. 	

  820. 	# generate preimages.

  821. 	try:

  822. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  823. 	except Exception as exp:

  824. 		print('An exception occured when running this experiment:')

  825. 		LOG_FILENAME = dir_save + 'error.txt'

  826. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  827. 		logging.exception('')

  828. 		print(repr(exp))

  829. 			

  830. 			

  831. def xp_median_preimage_8_3():

  832. 	"""xp 8_3: Monoterpenoides, Treelet, using CONSTANT.

  833. 	"""

  834. 	from gklearn.utils.kernels import polynomialkernel

  835. 	# set parameters.

  836. 	ds_name = 'Monoterpenoides' #

  837. 	rpg_options = {'k': 5,

  838. 				   'r_max': 10, #

  839. 				   'l': 500,

  840. 				   'alphas': None,

  841. 				   'parallel': True,

  842. 				   'verbose': 0}

  843. 	pkernel = functools.partial(polynomialkernel, d=2, c=1e+5)

  844. 	kernel_options = {'name': 'Treelet',

  845. 				      'sub_kernel': pkernel,

  846.  					  'parallel': 'imap_unordered', 

  847.                       # 'parallel': None, 

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

  849. 					  'normalize': True,

  850. 					  'verbose': 0}

  851. 	save_results = True

  852. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' 

  853. 	irrelevant_labels = {'edge_labels': ['valence']} #

  854. 	edge_required = False #

  855. 	

  856. 	if not os.path.exists(dir_save):

  857. 		os.makedirs(dir_save)

  858. 	file_output = open(dir_save + 'output.txt', 'a')

  859. 	sys.stdout = file_output

  860. 

  861. 	# print settings.

  862. 	print('parameters:')

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

  864. 	print('kernel_options:', kernel_options)

  865. 	print('save_results:', save_results)

  866. 	print('irrelevant_labels:', irrelevant_labels)

  867. 	print()

  868. 	

  869. 	# generate preimages.

  870. 	try:

  871. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  872. 	except Exception as exp:

  873. 		print('An exception occured when running this experiment:')

  874. 		LOG_FILENAME = dir_save + 'error.txt'

  875. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  876. 		logging.exception('')

  877. 		print(repr(exp))

  878. 			

  879. 			

  880. def xp_median_preimage_8_4():

  881. 	"""xp 8_4: Monoterpenoides, WeisfeilerLehman, using CONSTANT.

  882. 	"""

  883. 	# set parameters.

  884. 	ds_name = 'Monoterpenoides' #

  885. 	rpg_options = {'k': 5,

  886. 				   'r_max': 10, #

  887. 				   'l': 500,

  888. 				   'alphas': None,

  889. 				   'parallel': True,

  890. 				   'verbose': 2}

  891. 	kernel_options = {'name': 'WeisfeilerLehman',

  892. 				      'height': 4,

  893. 					  'base_kernel': 'subtree',

  894.  					  'parallel': 'imap_unordered', 

  895.                       # 'parallel': None, 

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

  897. 					  'normalize': True,

  898. 					  'verbose': 0}

  899. 	save_results = True

  900. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' 

  901. 	irrelevant_labels = {'edge_labels': ['valence']} #

  902. 	edge_required = False #

  903. 	

  904. 	if not os.path.exists(dir_save):

  905. 		os.makedirs(dir_save)

  906. 	file_output = open(dir_save + 'output.txt', 'a')

  907. 	sys.stdout = file_output

  908. 

  909. 	# print settings.

  910. 	print('parameters:')

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

  912. 	print('kernel_options:', kernel_options)

  913. 	print('save_results:', save_results)

  914. 	print('irrelevant_labels:', irrelevant_labels)

  915. 	print()

  916. 	

  917. 	# generate preimages.

  918. 	try:

  919. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  920. 	except Exception as exp:

  921. 		print('An exception occured when running this experiment:')

  922. 		LOG_FILENAME = dir_save + 'error.txt'

  923. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  924. 		logging.exception('')

  925. 		print(repr(exp))

  926. 			

  927. 

  928. def xp_median_preimage_7_1():

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

  930. 	"""

  931. 	# set parameters.

  932. 	ds_name = 'MUTAG' #

  933. 	rpg_options = {'k': 5,

  934. 				   'r_max': 10, #

  935. 				   'l': 500,

  936. 				   'alphas': None,

  937. 				   'parallel': True,

  938. 				   'verbose': 2}

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

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

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

  942. 					  'edge_weight': None,

  943. 					  'node_kernels': sub_kernels,

  944. 					  'edge_kernels': sub_kernels, 

  945. 					  'compute_method': 'naive',

  946.  					  'parallel': 'imap_unordered', 

  947.                       # 'parallel': None, 

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

  949. 					  'normalize': True,

  950. 					  'verbose': 0}

  951. 	save_results = True

  952. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' 

  953. 	irrelevant_labels = {'edge_labels': ['label_0']} #

  954. 	edge_required = False #

  955. 	

  956. 	if not os.path.exists(dir_save):

  957. 		os.makedirs(dir_save)

  958. 	file_output = open(dir_save + 'output.txt', 'a')

  959. 	sys.stdout = file_output

  960. 

  961. 	# print settings.

  962. 	print('parameters:')

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

  964. 	print('kernel_options:', kernel_options)

  965. 	print('save_results:', save_results)

  966. 	print('irrelevant_labels:', irrelevant_labels)

  967. 	print()

  968. 	

  969. 	# generate preimages.

  970. 	try:

  971. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  972. 	except Exception as exp:

  973. 		print('An exception occured when running this experiment:')

  974. 		LOG_FILENAME = dir_save + 'error.txt'

  975. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  976. 		logging.exception('')

  977. 		print(repr(exp))

  978. 			

  979. 			

  980. def xp_median_preimage_7_2():

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

  982. 	"""

  983. 	# set parameters.

  984. 	ds_name = 'MUTAG' #

  985. 	rpg_options = {'k': 5,

  986. 				   'r_max': 10, #

  987. 				   'l': 500,

  988. 				   'alphas': None,

  989. 				   'parallel': True,

  990. 				   'verbose': 2}

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

  992. 					  'depth': 2, #

  993. 					  'k_func': 'MinMax', #

  994. 					  'compute_method': 'trie',

  995.  					  'parallel': 'imap_unordered', 

  996.                       # 'parallel': None, 

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

  998. 					  'normalize': True,

  999. 					  'verbose': 0}

  1000. 	save_results = True

  1001. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' 

  1002. 	irrelevant_labels = {'edge_labels': ['label_0']} #

  1003. 	edge_required = False #

  1004. 	

  1005. 	if not os.path.exists(dir_save):

  1006. 		os.makedirs(dir_save)

  1007. 	file_output = open(dir_save + 'output.txt', 'a')

  1008. 	sys.stdout = file_output

  1009. 	

  1010. 	# print settings.

  1011. 	print('parameters:')

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

  1013. 	print('kernel_options:', kernel_options)

  1014. 	print('save_results:', save_results)

  1015. 	print('irrelevant_labels:', irrelevant_labels)

  1016. 	print()

  1017. 	

  1018. 	# generate preimages.

  1019. 	try:

  1020. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None)

  1021. 	except Exception as exp:

  1022. 		print('An exception occured when running experiment on xp_median_preimage_7_2:')

  1023. 		LOG_FILENAME = dir_save + 'error.txt'

  1024. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  1025. 		logging.exception('')

  1026. 		print(repr(exp))

  1027. 			

  1028. 			

  1029. def xp_median_preimage_7_3():

  1030. 	"""xp 7_3: MUTAG, Treelet, using CONSTANT.

  1031. 	"""

  1032. 	from gklearn.utils.kernels import polynomialkernel

  1033. 	# set parameters.

  1034. 	ds_name = 'MUTAG' #

  1035. 	rpg_options = {'k': 5,

  1036. 				   'r_max': 10, #

  1037. 				   'l': 500,

  1038. 				   'alphas': None,

  1039. 				   'parallel': True,

  1040. 				   'verbose': 2}

  1041. 	pkernel = functools.partial(polynomialkernel, d=3, c=1e+8)

  1042. 	kernel_options = {'name': 'Treelet',

  1043. 				      'sub_kernel': pkernel,

  1044.  					  'parallel': 'imap_unordered', 

  1045.                       # 'parallel': None, 

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

  1047. 					  'normalize': True,

  1048. 					  'verbose': 0}

  1049. 	save_results = True

  1050. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' 

  1051. 	irrelevant_labels = {'edge_labels': ['label_0']} #

  1052. 	edge_required = False #

  1053. 	

  1054. 	if not os.path.exists(dir_save):

  1055. 		os.makedirs(dir_save)

  1056. 	file_output = open(dir_save + 'output.txt', 'a')

  1057. 	sys.stdout = file_output

  1058. 

  1059. 	# print settings.

  1060. 	print('parameters:')

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

  1062. 	print('kernel_options:', kernel_options)

  1063. 	print('save_results:', save_results)

  1064. 	print('irrelevant_labels:', irrelevant_labels)

  1065. 	print()

  1066. 	

  1067. 	# generate preimages.

  1068. 	try:

  1069. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  1070. 	except Exception as exp:

  1071. 		print('An exception occured when running this experiment:')

  1072. 		LOG_FILENAME = dir_save + 'error.txt'

  1073. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  1074. 		logging.exception('')

  1075. 		print(repr(exp))

  1076. 			

  1077. 			

  1078. def xp_median_preimage_7_4():

  1079. 	"""xp 7_4: MUTAG, WeisfeilerLehman, using CONSTANT.

  1080. 	"""

  1081. 	# set parameters.

  1082. 	ds_name = 'MUTAG' #

  1083. 	rpg_options = {'k': 5,

  1084. 				   'r_max': 10, #

  1085. 				   'l': 500,

  1086. 				   'alphas': None,

  1087. 				   'parallel': True,

  1088. 				   'verbose': 2}

  1089. 	kernel_options = {'name': 'WeisfeilerLehman',

  1090. 				      'height': 1,

  1091. 					  'base_kernel': 'subtree',

  1092.  					  'parallel': 'imap_unordered', 

  1093.                       # 'parallel': None, 

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

  1095. 					  'normalize': True,

  1096. 					  'verbose': 0}

  1097. 	save_results = True

  1098. 	dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' 

  1099. 	irrelevant_labels = {'edge_labels': ['label_0']} #

  1100. 	edge_required = False #

  1101. 	

  1102. 	if not os.path.exists(dir_save):

  1103. 		os.makedirs(dir_save)

  1104. 	file_output = open(dir_save + 'output.txt', 'a')

  1105. 	sys.stdout = file_output

  1106. 

  1107. 	# print settings.

  1108. 	print('parameters:')

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

  1110. 	print('kernel_options:', kernel_options)

  1111. 	print('save_results:', save_results)

  1112. 	print('irrelevant_labels:', irrelevant_labels)

  1113. 	print()

  1114. 	

  1115. 	# generate preimages.

  1116. 	try:

  1117. 		generate_random_preimages_by_class(ds_name, rpg_options, kernel_options, save_results=save_results, save_preimages=True, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required)

  1118. 	except Exception as exp:

  1119. 		print('An exception occured when running this experiment:')

  1120. 		LOG_FILENAME = dir_save + 'error.txt'

  1121. 		logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)

  1122. 		logging.exception('')

  1123. 		print(repr(exp))

  1124. 				

  1125. 				

  1126. if __name__ == "__main__":

  1127. 

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

  1129.  	xp_median_preimage_7_2()

  1130. 

  1131. # 	#### xp 7_3: MUTAG, Treelet, using CONSTANT.

  1132.  	xp_median_preimage_7_3()

  1133. 

  1134. # 	#### xp 7_4: MUTAG, WeisfeilerLehman, using CONSTANT.

  1135.  	xp_median_preimage_7_4()

  1136. # 	 

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

  1138.  	xp_median_preimage_7_1()

  1139. 

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

  1141.  	xp_median_preimage_8_2()

  1142. 

  1143. # 	#### xp 8_3: Monoterpenoides, Treelet, using CONSTANT.

  1144.  	xp_median_preimage_8_3()

  1145. 

  1146. # 	#### xp 8_4: Monoterpenoides, WeisfeilerLehman, using CONSTANT.

  1147.  	xp_median_preimage_8_4()

  1148. 	 

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

  1150.  	xp_median_preimage_8_1()

  1151. 

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

  1153.  	xp_median_preimage_9_2()

  1154. 

  1155. # 	#### xp 9_3: MAO, Treelet, using CONSTANT, symbolic only.

  1156.  	xp_median_preimage_9_3()

  1157. 

  1158. # 	#### xp 9_4: MAO, WeisfeilerLehman, using CONSTANT, symbolic only.

  1159.  	xp_median_preimage_9_4()

  1160. 	 

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

  1162.  	xp_median_preimage_9_1()

  1163. 

  1164.  	#### xp 12_1: PAH, StructuralSP, using NON_SYMBOLIC, unlabeled.

  1165.  	xp_median_preimage_12_1()

  1166. 

  1167.  	#### xp 12_2: PAH, PathUpToH, using CONSTANT, unlabeled.

  1168.  	xp_median_preimage_12_2()

  1169. 

  1170.  	#### xp 12_3: PAH, Treelet, using CONSTANT, unlabeled.

  1171.  	xp_median_preimage_12_3()

  1172. 

  1173.  	#### xp 12_4: PAH, WeisfeilerLehman, using CONSTANT, unlabeled.

  1174.  	xp_median_preimage_12_4()

  1175. 

  1176.  	#### xp 12_5: PAH, ShortestPath, using NON_SYMBOLIC, unlabeled.

  1177.  	xp_median_preimage_12_5()

  1178. 	 

  1179. 	 # 	#### xp 15_1: AIDS, StructuralSP, using CONSTANT, symbolic only.

  1180.  	xp_median_preimage_15_1()

  1181. 

  1182. # 	#### xp 15_2: AIDS, PathUpToH, using CONSTANT, symbolic only.

  1183.  	xp_median_preimage_15_2()

  1184. 

  1185. # 	#### xp 15_3: AIDS, Treelet, using CONSTANT, symbolic only.

  1186.  	xp_median_preimage_15_3()

  1187. 

  1188. # 	#### xp 15_4: AIDS, WeisfeilerLehman, using CONSTANT, symbolic only.

  1189.  	xp_median_preimage_15_4()

  1190. # 	

  1191.  	#### xp 14_1: DD, PathUpToH, using CONSTANT.

  1192.  	xp_median_preimage_14_1()