diff --git a/gklearn/preimage/experiments/xp_1nn.py b/gklearn/preimage/experiments/xp_1nn.py deleted file mode 100644 index a45a9c3..0000000 --- a/gklearn/preimage/experiments/xp_1nn.py +++ /dev/null @@ -1,109 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -""" -Created on Mon May 11 14:15:11 2020 - -@author: ljia -""" -import functools -import multiprocessing -import os -import sys -import logging -from gklearn.utils.kernels import deltakernel, gaussiankernel, kernelproduct -from gklearn.preimage import kernel_knn_cv - -dir_root = '../results/xp_1nn.init1.no_triangle_rule.allow_zeros/' -num_random = 10 -initial_solutions = 1 -triangle_rule = False -allow_zeros = True -update_order = False -test_sizes = [0.9, 0.7] # , 0.5, 0.3, 0.1] - -def xp_knn_1_1(): - for test_size in test_sizes: - ds_name = 'Letter-high' - knn_options = {'n_neighbors': 1, - 'n_splits': 30, - 'test_size': test_size, - 'verbose': True} - mpg_options = {'fit_method': 'k-graphs', - 'init_ecc': [0.675, 0.675, 0.75, 0.425, 0.425], - 'ds_name': ds_name, - 'parallel': False, # False - 'time_limit_in_sec': 0, - 'max_itrs': 100, - 'max_itrs_without_update': 3, - 'epsilon_residual': 0.01, - 'epsilon_ec': 0.1, - 'allow_zeros': allow_zeros, - 'triangle_rule': triangle_rule, - 'verbose': 1} - mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) - sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} - kernel_options = {'name': 'StructuralSP', - 'edge_weight': None, - 'node_kernels': sub_kernels, - 'edge_kernels': sub_kernels, - 'compute_method': 'naive', - 'parallel': 'imap_unordered', -# 'parallel': None, - 'n_jobs': multiprocessing.cpu_count(), - 'normalize': True, - 'verbose': 0} - ged_options = {'method': 'IPFP', - 'initialization_method': 'RANDOM', # 'NODE' - 'initial_solutions': initial_solutions, # 1 - 'edit_cost': 'LETTER2', - 'attr_distance': 'euclidean', - 'ratio_runs_from_initial_solutions': 1, - 'threads': multiprocessing.cpu_count(), - 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} - mge_options = {'init_type': 'MEDOID', - 'random_inits': 10, - 'time_limit': 0, - 'verbose': 1, - 'update_order': update_order, - 'randomness': 'REAL', - 'refine': False} - save_results = True - dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') - - if not os.path.exists(dir_save): - os.makedirs(dir_save) - file_output = open(dir_save + 'output.txt', 'a') -# sys.stdout = file_output - - # print settings. - print('parameters:') - print('dataset name:', ds_name) - print('mpg_options:', mpg_options) - print('kernel_options:', kernel_options) - print('ged_options:', ged_options) - print('mge_options:', mge_options) - print('save_results:', save_results) - - for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: -# for train_examples in ['expert']: - print('\n-------------------------------------') - print('train examples used:', train_examples, '\n') - mpg_options['fit_method'] = train_examples -# try: - kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=None, edge_required=False, cut_range=None) -# except Exception as exp: -# print('An exception occured when running this experiment:') -# LOG_FILENAME = dir_save + 'error.txt' -# logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) -# logging.exception('') -# print(repr(exp)) - - -if __name__ == '__main__': - import pdb, traceback - try: - xp_knn_1_1() - except: - extype, value, tb = sys.exc_info() - traceback.print_exc() - pdb.post_mortem(tb) \ No newline at end of file diff --git a/gklearn/preimage/experiments/xp_1nn_init10_trianglerule.py b/gklearn/preimage/experiments/xp_1nn_init10_trianglerule.py new file mode 100644 index 0000000..9af5828 --- /dev/null +++ b/gklearn/preimage/experiments/xp_1nn_init10_trianglerule.py @@ -0,0 +1,3022 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Fri May 15 10:50:46 2020 + +@author: ljia +""" +import multiprocessing +import functools +import sys +import os +import logging +from gklearn.utils.kernels import deltakernel, gaussiankernel, kernelproduct +from gklearn.preimage import kernel_knn_cv +from gklearn.utils import compute_gram_matrices_by_class + + +dir_root = '../results/xp_1nn.init10.triangle_rule/' +initial_solutions = 10 +triangle_rule = True +allow_zeros = False +update_order = False +test_sizes = [0.9, 0.7] # , 0.5, 0.3, 0.1] + + +def xp_median_preimage_14_1(): + """xp 14_1: DD, PathUpToH, using CONSTANT. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'DD' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + kernel_options = {'name': 'PathUpToH', + 'depth': 2, # + 'k_func': 'MinMax', # + 'compute_method': 'trie', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # # compute gram matrices for each class a priori. + # print('Compute gram matrices for each class a priori.') + # 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) + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_13_1(): + """xp 13_1: PAH, StructuralSP, using NON_SYMBOLIC. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'PAH' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [3, 3, 1, 3, 3, 0], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'StructuralSP', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'edge_kernels': sub_kernels, + 'compute_method': 'naive', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'NON_SYMBOLIC', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_13_2(): + """xp 13_2: PAH, ShortestPath, using NON_SYMBOLIC. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'PAH' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [3, 3, 1, 3, 3, 0], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'ShortestPath', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'NON_SYMBOLIC', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') # + irrelevant_labels = None # + edge_required = True # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'random', 'best-dataset', 'trainset']: # + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_12_1(): + """xp 12_1: PAH, StructuralSP, using NON_SYMBOLIC, unlabeled. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'PAH' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 0, 1, 1, 0], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'StructuralSP', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'edge_kernels': sub_kernels, + 'compute_method': 'naive', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'NON_SYMBOLIC', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.unlabeled/' + irrelevant_labels = {'node_attrs': ['x', 'y', 'z'], 'edge_labels': ['bond_stereo']} # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_12_2(): + """xp 12_2: PAH, PathUpToH, using CONSTANT, unlabeled. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'PAH' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + kernel_options = {'name': 'PathUpToH', + 'depth': 1, # + 'k_func': 'MinMax', # + 'compute_method': 'trie', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.unlabeled/' + irrelevant_labels = {'node_attrs': ['x', 'y', 'z'], 'edge_labels': ['bond_stereo']} # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_12_3(): + """xp 12_3: PAH, Treelet, using CONSTANT, unlabeled. + """ + from gklearn.utils.kernels import gaussiankernel + for test_size in test_sizes: + # set parameters. + ds_name = 'PAH' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + pkernel = functools.partial(gaussiankernel, gamma=None) # @todo + kernel_options = {'name': 'Treelet', # + 'sub_kernel': pkernel, + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.unlabeled/' + irrelevant_labels = {'node_attrs': ['x', 'y', 'z'], 'edge_labels': ['bond_stereo']} # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_12_4(): + """xp 12_4: PAH, WeisfeilerLehman, using CONSTANT, unlabeled. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'PAH' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + kernel_options = {'name': 'WeisfeilerLehman', + 'height': 14, + 'base_kernel': 'subtree', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.unlabeled/' + irrelevant_labels = {'node_attrs': ['x', 'y', 'z'], 'edge_labels': ['bond_stereo']} # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # # compute gram matrices for each class a priori. + # print('Compute gram matrices for each class a priori.') + # compute_gram_matrices_by_class(ds_name, kernel_options, save_results=True, dir_save=dir_save, irrelevant_labels=irrelevant_labels) + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_12_5(): + """xp 12_5: PAH, ShortestPath, using NON_SYMBOLIC, unlabeled. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'PAH' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 0, 1, 1, 0], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'ShortestPath', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'NON_SYMBOLIC', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.unlabeled/' # + irrelevant_labels = {'node_attrs': ['x', 'y', 'z'], 'edge_labels': ['bond_stereo']} # + edge_required = True # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: # + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_9_1(): + """xp 9_1: MAO, StructuralSP, using CONSTANT, symbolic only. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'MAO' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'StructuralSP', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'edge_kernels': sub_kernels, + 'compute_method': 'naive', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.symb/' + irrelevant_labels = {'node_attrs': ['x', 'y', 'z'], 'edge_labels': ['bond_stereo']} # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_9_2(): + """xp 9_2: MAO, PathUpToH, using CONSTANT, symbolic only. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'MAO' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + kernel_options = {'name': 'PathUpToH', + 'depth': 9, # + 'k_func': 'MinMax', # + 'compute_method': 'trie', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.symb/' + irrelevant_labels = {'node_attrs': ['x', 'y', 'z'], 'edge_labels': ['bond_stereo']} # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_9_3(): + """xp 9_3: MAO, Treelet, using CONSTANT, symbolic only. + """ + for test_size in test_sizes: + from gklearn.utils.kernels import polynomialkernel + # set parameters. + ds_name = 'MAO' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + pkernel = functools.partial(polynomialkernel, d=4, c=1e+7) + kernel_options = {'name': 'Treelet', # + 'sub_kernel': pkernel, + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.symb/' + irrelevant_labels = {'node_attrs': ['x', 'y', 'z'], 'edge_labels': ['bond_stereo']} # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_9_4(): + """xp 9_4: MAO, WeisfeilerLehman, using CONSTANT, symbolic only. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'MAO' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + kernel_options = {'name': 'WeisfeilerLehman', + 'height': 6, + 'base_kernel': 'subtree', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.symb/' + irrelevant_labels = {'node_attrs': ['x', 'y', 'z'], 'edge_labels': ['bond_stereo']} # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + +# # compute gram matrices for each class a priori. +# print('Compute gram matrices for each class a priori.') +# compute_gram_matrices_by_class(ds_name, kernel_options, save_results=True, dir_save=dir_save, irrelevant_labels=irrelevant_labels) + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_8_1(): + """xp 8_1: Monoterpenoides, StructuralSP, using CONSTANT. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'Monoterpenoides' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [3, 3, 1, 3, 3, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'StructuralSP', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'edge_kernels': sub_kernels, + 'compute_method': 'naive', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_8_2(): + """xp 8_2: Monoterpenoides, PathUpToH, using CONSTANT. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'Monoterpenoides' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + kernel_options = {'name': 'PathUpToH', + 'depth': 7, # + 'k_func': 'MinMax', # + 'compute_method': 'trie', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_8_3(): + """xp 8_3: Monoterpenoides, Treelet, using CONSTANT. + """ + for test_size in test_sizes: + from gklearn.utils.kernels import polynomialkernel + # set parameters. + ds_name = 'Monoterpenoides' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + pkernel = functools.partial(polynomialkernel, d=2, c=1e+5) + kernel_options = {'name': 'Treelet', + 'sub_kernel': pkernel, + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_8_4(): + """xp 8_4: Monoterpenoides, WeisfeilerLehman, using CONSTANT. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'Monoterpenoides' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + kernel_options = {'name': 'WeisfeilerLehman', + 'height': 4, + 'base_kernel': 'subtree', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_7_1(): + """xp 7_1: MUTAG, StructuralSP, using CONSTANT. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'MUTAG' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'StructuralSP', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'edge_kernels': sub_kernels, + 'compute_method': 'naive', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_7_2(): + """xp 7_2: MUTAG, PathUpToH, using CONSTANT. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'MUTAG' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + kernel_options = {'name': 'PathUpToH', + 'depth': 2, # + 'k_func': 'MinMax', # + 'compute_method': 'trie', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running experiment on xp_median_preimage_7_2:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_7_3(): + """xp 7_3: MUTAG, Treelet, using CONSTANT. + """ + for test_size in test_sizes: + from gklearn.utils.kernels import polynomialkernel + # set parameters. + ds_name = 'MUTAG' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + pkernel = functools.partial(polynomialkernel, d=3, c=1e+8) + kernel_options = {'name': 'Treelet', + 'sub_kernel': pkernel, + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_7_4(): + """xp 7_4: MUTAG, WeisfeilerLehman, using CONSTANT. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'MUTAG' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [4, 4, 2, 1, 1, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, # + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + kernel_options = {'name': 'WeisfeilerLehman', + 'height': 1, + 'base_kernel': 'subtree', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'CONSTANT', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_6_1(): + """xp 6_1: COIL-RAG, StructuralSP, using NON_SYMBOLIC. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'COIL-RAG' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [3, 3, 1, 3, 3, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'StructuralSP', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'edge_kernels': sub_kernels, + 'compute_method': 'naive', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'NON_SYMBOLIC', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running experiment on xp_median_preimage_6_1:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_6_2(): + """xp 6_2: COIL-RAG, ShortestPath, using NON_SYMBOLIC. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'COIL-RAG' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [3, 3, 1, 3, 3, 1], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'ShortestPath', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'NON_SYMBOLIC', # + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = True # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running experiment on xp_median_preimage_6_2:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_5_1(): + """xp 5_1: FRANKENSTEIN, StructuralSP, using NON_SYMBOLIC. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'FRANKENSTEIN' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [3, 3, 1, 3, 3, 0], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'StructuralSP', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'edge_kernels': sub_kernels, + 'compute_method': 'naive', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'NON_SYMBOLIC', + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_4_1(): + """xp 4_1: COLORS-3, StructuralSP, using NON_SYMBOLIC. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'COLORS-3' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [3, 3, 1, 3, 3, 0], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'StructuralSP', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'edge_kernels': sub_kernels, + 'compute_method': 'naive', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'NON_SYMBOLIC', + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_3_2(): + """xp 3_2: Fingerprint, ShortestPath, using LETTER2, only node attrs. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'Fingerprint' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [0.525, 0.525, 0.01, 0.125, 0.125], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'ShortestPath', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'LETTER2', + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = {'edge_attrs': ['orient', 'angle']} # + edge_required = True # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_3_1(): + """xp 3_1: Fingerprint, StructuralSP, using LETTER2, only node attrs. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'Fingerprint' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [0.525, 0.525, 0.01, 0.125, 0.125], # + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'StructuralSP', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'edge_kernels': sub_kernels, + 'compute_method': 'naive', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'LETTER2', + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = {'edge_attrs': ['orient', 'angle']} # + edge_required = False # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_2_1(): + """xp 2_1: COIL-DEL, StructuralSP, using LETTER2, only node attrs. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'COIL-DEL' # + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [3, 3, 1, 3, 3], + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'StructuralSP', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'edge_kernels': sub_kernels, + 'compute_method': 'naive', + 'parallel': 'imap_unordered', + # 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'LETTER2', + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '.node_attrs/' + irrelevant_labels = {'edge_labels': ['valence']} + edge_required = False + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + +# # compute gram matrices for each class a priori. +# print('Compute gram matrices for each class a priori.') +# compute_gram_matrices_by_class(ds_name, kernel_options, save_results=True, dir_save=dir_save, irrelevant_labels=irrelevant_labels) + + # generate preimages. + for train_examples in ['k-graphs', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running this experiment:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_1_1(): + """xp 1_1: Letter-high, StructuralSP. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'Letter-high' + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [0.675, 0.675, 0.75, 0.425, 0.425], + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'StructuralSP', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'edge_kernels': sub_kernels, + 'compute_method': 'naive', + 'parallel': 'imap_unordered', +# 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'LETTER2', + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None + edge_required = False + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running experiment on xp_median_preimage_1_1:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_1_2(): + """xp 1_2: Letter-high, ShortestPath. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'Letter-high' + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [0.675, 0.675, 0.75, 0.425, 0.425], + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'ShortestPath', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'parallel': 'imap_unordered', +# 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'LETTER2', + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = True # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running experiment on xp_median_preimage_1_2:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_10_1(): + """xp 10_1: Letter-med, StructuralSP. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'Letter-med' + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [0.525, 0.525, 0.75, 0.475, 0.475], + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'StructuralSP', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'edge_kernels': sub_kernels, + 'compute_method': 'naive', + 'parallel': 'imap_unordered', +# 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'LETTER2', + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None + edge_required = False + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running experiment on xp_median_preimage_10_1:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_10_2(): + """xp 10_2: Letter-med, ShortestPath. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'Letter-med' + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [0.525, 0.525, 0.75, 0.475, 0.475], + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'ShortestPath', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'parallel': 'imap_unordered', +# 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'LETTER2', + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = True # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running experiment on xp_median_preimage_10_2:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_11_1(): + """xp 11_1: Letter-low, StructuralSP. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'Letter-low' + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [0.075, 0.075, 0.25, 0.075, 0.075], + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'StructuralSP', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'edge_kernels': sub_kernels, + 'compute_method': 'naive', + 'parallel': 'imap_unordered', +# 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'LETTER2', + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None + edge_required = False + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running experiment on xp_median_preimage_11_1:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +def xp_median_preimage_11_2(): + """xp 11_2: Letter-low, ShortestPath. + """ + for test_size in test_sizes: + # set parameters. + ds_name = 'Letter-low' + knn_options = {'n_neighbors': 1, + 'n_splits': 30, + 'test_size': test_size, + 'verbose': True} + mpg_options = {'fit_method': 'k-graphs', + 'init_ecc': [0.075, 0.075, 0.25, 0.075, 0.075], + 'ds_name': ds_name, + 'parallel': True, # False + 'time_limit_in_sec': 0, + 'max_itrs': 100, + 'max_itrs_without_update': 3, + 'epsilon_residual': 0.01, + 'epsilon_ec': 0.1, + 'allow_zeros': allow_zeros, + 'triangle_rule': triangle_rule, + 'verbose': 1} + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + kernel_options = {'name': 'ShortestPath', + 'edge_weight': None, + 'node_kernels': sub_kernels, + 'parallel': 'imap_unordered', +# 'parallel': None, + 'n_jobs': multiprocessing.cpu_count(), + 'normalize': True, + 'verbose': 0} + ged_options = {'method': 'IPFP', + 'initialization_method': 'RANDOM', # 'NODE' + 'initial_solutions': initial_solutions, # 1 + 'edit_cost': 'LETTER2', + 'attr_distance': 'euclidean', + 'ratio_runs_from_initial_solutions': 1, + 'threads': multiprocessing.cpu_count(), + 'init_option': 'EAGER_WITHOUT_SHUFFLED_COPIES'} + mge_options = {'init_type': 'MEDOID', + 'random_inits': 10, + 'time_limit': 0, + 'verbose': 1, + 'update_order': update_order, + 'randomness': 'REAL', + 'refine': False} + save_results = True + dir_save = dir_root + ds_name + '.' + kernel_options['name'] + '/' + ('update_order/' if update_order else '') + irrelevant_labels = None # + edge_required = True # + + if not os.path.exists(dir_save): + os.makedirs(dir_save) + file_output = open(dir_save + 'output.txt', 'a') + sys.stdout = file_output + + # print settings. + print('parameters:') + print('dataset name:', ds_name) + print('knn_options:', knn_options) + print('mpg_options:', mpg_options) + print('kernel_options:', kernel_options) + print('ged_options:', ged_options) + print('mge_options:', mge_options) + print('save_results:', save_results) + print('irrelevant_labels:', irrelevant_labels) + print() + + # generate preimages. + for train_examples in ['k-graphs', 'expert', 'random', 'best-dataset', 'trainset']: + print('\n-------------------------------------') + print('train examples used:', train_examples, '\n') + mpg_options['fit_method'] = train_examples + try: + kernel_knn_cv(ds_name, train_examples, knn_options, mpg_options, kernel_options, ged_options, mge_options, save_results=save_results, load_gm='auto', dir_save=dir_save, irrelevant_labels=irrelevant_labels, edge_required=edge_required, cut_range=None) + except Exception as exp: + print('An exception occured when running experiment on xp_median_preimage_11_2:') + LOG_FILENAME = dir_save + 'error.txt' + logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) + logging.exception('') + print(repr(exp)) + + +if __name__ == "__main__": + +# #### xp 1_1: Letter-high, StructuralSP. + # xp_median_preimage_1_1() + +# #### xp 1_2: Letter-high, ShortestPath. + # xp_median_preimage_1_2() + +# #### xp 10_1: Letter-med, StructuralSP. + # xp_median_preimage_10_1() + +# #### xp 10_2: Letter-med, ShortestPath. + # xp_median_preimage_10_2() + +# #### xp 11_1: Letter-low, StructuralSP. + # xp_median_preimage_11_1() + +# #### xp 11_2: Letter-low, ShortestPath. + # xp_median_preimage_11_2() +# +# #### xp 2_1: COIL-DEL, StructuralSP, using LETTER2, only node attrs. +# # xp_median_preimage_2_1() +# +# #### xp 3_1: Fingerprint, StructuralSP, using LETTER2, only node attrs. +# # xp_median_preimage_3_1() + +# #### xp 3_2: Fingerprint, ShortestPath, using LETTER2, only node attrs. + # xp_median_preimage_3_2() + +# #### xp 4_1: COLORS-3, StructuralSP, using NON_SYMBOLIC. +# # xp_median_preimage_4_1() +# +# #### xp 5_1: FRANKENSTEIN, StructuralSP, using NON_SYMBOLIC. +# # xp_median_preimage_5_1() +# +# #### xp 6_1: COIL-RAG, StructuralSP, using NON_SYMBOLIC. + # xp_median_preimage_6_1() + +# #### xp 6_2: COIL-RAG, ShortestPath, using NON_SYMBOLIC. + # xp_median_preimage_6_2() + +# #### xp 7_1: MUTAG, StructuralSP, using CONSTANT. + # xp_median_preimage_7_1() + +# #### xp 7_2: MUTAG, PathUpToH, using CONSTANT. + # xp_median_preimage_7_2() + +# #### xp 7_3: MUTAG, Treelet, using CONSTANT. + # xp_median_preimage_7_3() + +# #### xp 7_4: MUTAG, WeisfeilerLehman, using CONSTANT. + # xp_median_preimage_7_4() +# +# #### xp 8_1: Monoterpenoides, StructuralSP, using CONSTANT. + # xp_median_preimage_8_1() + +# #### xp 8_2: Monoterpenoides, PathUpToH, using CONSTANT. + # xp_median_preimage_8_2() + +# #### xp 8_3: Monoterpenoides, Treelet, using CONSTANT. + # xp_median_preimage_8_3() + +# #### xp 8_4: Monoterpenoides, WeisfeilerLehman, using CONSTANT. + # xp_median_preimage_8_4() + +# #### xp 9_1: MAO, StructuralSP, using CONSTANT, symbolic only. + # xp_median_preimage_9_1() + +# #### xp 9_2: MAO, PathUpToH, using CONSTANT, symbolic only. + # xp_median_preimage_9_2() + +# #### xp 9_3: MAO, Treelet, using CONSTANT, symbolic only. + # xp_median_preimage_9_3() + +# #### xp 9_4: MAO, WeisfeilerLehman, using CONSTANT, symbolic only. + # xp_median_preimage_9_4() + + #### xp 12_1: PAH, StructuralSP, using NON_SYMBOLIC, unlabeled. + # xp_median_preimage_12_1() + + #### xp 12_2: PAH, PathUpToH, using CONSTANT, unlabeled. + # xp_median_preimage_12_2() + + #### xp 12_3: PAH, Treelet, using CONSTANT, unlabeled. + # xp_median_preimage_12_3() + + #### xp 12_4: PAH, WeisfeilerLehman, using CONSTANT, unlabeled. + # xp_median_preimage_12_4() + + #### xp 12_5: PAH, ShortestPath, using NON_SYMBOLIC, unlabeled. + # xp_median_preimage_12_5() + + #### xp 13_1: PAH, StructuralSP, using NON_SYMBOLIC. + # xp_median_preimage_13_1() + + #### xp 13_2: PAH, ShortestPath, using NON_SYMBOLIC. +# xp_median_preimage_13_2() + + #### xp 14_1: DD, PathUpToH, using CONSTANT. +# xp_median_preimage_14_1() + + + + + + + + +# #### xp 1_1: Letter-high, StructuralSP. + xp_median_preimage_1_1() + +# #### xp 1_2: Letter-high, ShortestPath. + xp_median_preimage_1_2() + +# #### xp 10_1: Letter-med, StructuralSP. + xp_median_preimage_10_1() + +# #### xp 10_2: Letter-med, ShortestPath. + xp_median_preimage_10_2() + +# #### xp 11_1: Letter-low, StructuralSP. + xp_median_preimage_11_1() + +# #### xp 11_2: Letter-low, ShortestPath. + xp_median_preimage_11_2() + + #### xp 13_1: PAH, StructuralSP, using NON_SYMBOLIC. + xp_median_preimage_13_1() + + #### xp 13_2: PAH, ShortestPath, using NON_SYMBOLIC. + xp_median_preimage_13_2() + +# #### xp 7_2: MUTAG, PathUpToH, using CONSTANT. + xp_median_preimage_7_2() + +# #### xp 7_3: MUTAG, Treelet, using CONSTANT. + xp_median_preimage_7_3() + +# #### xp 7_4: MUTAG, WeisfeilerLehman, using CONSTANT. + xp_median_preimage_7_4() +# +# #### xp 7_1: MUTAG, StructuralSP, using CONSTANT. + xp_median_preimage_7_1() + +# #### xp 8_2: Monoterpenoides, PathUpToH, using CONSTANT. + xp_median_preimage_8_2() + +# #### xp 8_3: Monoterpenoides, Treelet, using CONSTANT. + xp_median_preimage_8_3() + +# #### xp 8_4: Monoterpenoides, WeisfeilerLehman, using CONSTANT. + xp_median_preimage_8_4() + +# #### xp 8_1: Monoterpenoides, StructuralSP, using CONSTANT. + xp_median_preimage_8_1() + +# #### xp 9_2: MAO, PathUpToH, using CONSTANT, symbolic only. + xp_median_preimage_9_2() + +# #### xp 9_3: MAO, Treelet, using CONSTANT, symbolic only. + xp_median_preimage_9_3() + +# #### xp 9_4: MAO, WeisfeilerLehman, using CONSTANT, symbolic only. + xp_median_preimage_9_4() + +# #### xp 9_1: MAO, StructuralSP, using CONSTANT, symbolic only. + xp_median_preimage_9_1() + + #### xp 12_1: PAH, StructuralSP, using NON_SYMBOLIC, unlabeled. + xp_median_preimage_12_1() + + #### xp 12_2: PAH, PathUpToH, using CONSTANT, unlabeled. + xp_median_preimage_12_2() + + #### xp 12_3: PAH, Treelet, using CONSTANT, unlabeled. + xp_median_preimage_12_3() + + #### xp 12_4: PAH, WeisfeilerLehman, using CONSTANT, unlabeled. + xp_median_preimage_12_4() + + #### xp 12_5: PAH, ShortestPath, using NON_SYMBOLIC, unlabeled. + xp_median_preimage_12_5() + +# #### xp 6_1: COIL-RAG, StructuralSP, using NON_SYMBOLIC. + xp_median_preimage_6_1() +# +# #### xp 2_1: COIL-DEL, StructuralSP, using LETTER2, only node attrs. + xp_median_preimage_2_1() +# +# #### xp 3_1: Fingerprint, StructuralSP, using LETTER2, only node attrs. +# # xp_median_preimage_3_1() + +# #### xp 3_2: Fingerprint, ShortestPath, using LETTER2, only node attrs. + # xp_median_preimage_3_2() + +# #### xp 4_1: COLORS-3, StructuralSP, using NON_SYMBOLIC. +# # xp_median_preimage_4_1() +# +# #### xp 5_1: FRANKENSTEIN, StructuralSP, using NON_SYMBOLIC. +# # xp_median_preimage_5_1() +# +# #### xp 6_2: COIL-RAG, ShortestPath, using NON_SYMBOLIC. + # xp_median_preimage_6_2() + + #### xp 14_1: DD, PathUpToH, using CONSTANT. +# xp_median_preimage_14_1() \ No newline at end of file diff --git a/gklearn/preimage/median_preimage_generator.py b/gklearn/preimage/median_preimage_generator.py index 9aaa88a..9deabe0 100644 --- a/gklearn/preimage/median_preimage_generator.py +++ b/gklearn/preimage/median_preimage_generator.py @@ -443,7 +443,7 @@ class MedianPreimageGenerator(PreimageGenerator): # # 1. if c_vi != c_vr, c_ei != c_er. # nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4,5]] # x = cp.Variable(nb_cost_mat_new.shape[1]) - # cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + # cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) ## # 1.1 no constraints. ## constraints = [x >= [0.0 for i in range(nb_cost_mat_new.shape[1])]] # # 1.2 c_vs <= c_vi + c_vr. @@ -454,7 +454,7 @@ class MedianPreimageGenerator(PreimageGenerator): ## nb_cost_mat_new[:,0] += nb_cost_mat[:,1] ## nb_cost_mat_new[:,2] += nb_cost_mat[:,5] ## x = cp.Variable(nb_cost_mat_new.shape[1]) - ## cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + ## cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) ## # 2.1 no constraints. ## constraints = [x >= [0.0 for i in range(nb_cost_mat_new.shape[1])]] ### # 2.2 c_vs <= c_vi + c_vr. @@ -469,7 +469,7 @@ class MedianPreimageGenerator(PreimageGenerator): if not self.__triangle_rule and self.__allow_zeros: nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4,5]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.0 for i in range(nb_cost_mat_new.shape[1])], np.array([1.0, 0.0, 0.0, 0.0, 0.0]).T@x >= 0.01, np.array([0.0, 1.0, 0.0, 0.0, 0.0]).T@x >= 0.01, @@ -482,7 +482,7 @@ class MedianPreimageGenerator(PreimageGenerator): elif self.__triangle_rule and self.__allow_zeros: nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4,5]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.0 for i in range(nb_cost_mat_new.shape[1])], np.array([1.0, 0.0, 0.0, 0.0, 0.0]).T@x >= 0.01, np.array([0.0, 1.0, 0.0, 0.0, 0.0]).T@x >= 0.01, @@ -496,7 +496,7 @@ class MedianPreimageGenerator(PreimageGenerator): elif not self.__triangle_rule and not self.__allow_zeros: nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4,5]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat_new.shape[1])]] prob = cp.Problem(cp.Minimize(cost_fun), constraints) prob.solve() @@ -506,7 +506,7 @@ class MedianPreimageGenerator(PreimageGenerator): # # c_vs <= c_vi + c_vr. # nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4,5]] # x = cp.Variable(nb_cost_mat_new.shape[1]) - # cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + # cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) # constraints = [x >= [0.0 for i in range(nb_cost_mat_new.shape[1])], # np.array([1.0, 1.0, -1.0, 0.0, 0.0]).T@x >= 0.0] # prob = cp.Problem(cp.Minimize(cost_fun), constraints) @@ -519,7 +519,7 @@ class MedianPreimageGenerator(PreimageGenerator): # c_vs <= c_vi + c_vr. nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4,5]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat_new.shape[1])], np.array([1.0, 1.0, -1.0, 0.0, 0.0]).T@x >= 0.0] prob = cp.Problem(cp.Minimize(cost_fun), constraints) @@ -530,7 +530,7 @@ class MedianPreimageGenerator(PreimageGenerator): # c_vs <= c_vi + c_vr and c_vi == c_vr, c_ei == c_er. nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4,5]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat_new.shape[1])], np.array([1.0, 1.0, -1.0, 0.0, 0.0]).T@x >= 0.0, np.array([1.0, -1.0, 0.0, 0.0, 0.0]).T@x == 0.0, @@ -548,7 +548,7 @@ class MedianPreimageGenerator(PreimageGenerator): # nb_cost_mat_new = nb_cost_mat[:,[0,1,2,3,4]] nb_cost_mat_new = nb_cost_mat[:,[2,3,4]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) # constraints = [x >= [0.0 for i in range(nb_cost_mat_new.shape[1])], # np.array([0.0, 0.0, 0.0, 1.0, -1.0]).T@x == 0.0] # constraints = [x >= [0.0001 for i in range(nb_cost_mat_new.shape[1])]] @@ -565,7 +565,7 @@ class MedianPreimageGenerator(PreimageGenerator): if is_n_attr and is_e_attr: nb_cost_mat_new = nb_cost_mat[:,[0,1,2,3,4,5]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.0 for i in range(nb_cost_mat_new.shape[1])], np.array([1.0, 0.0, 0.0, 0.0, 0.0, 0.0]).T@x >= 0.01, np.array([0.0, 1.0, 0.0, 0.0, 0.0, 0.0]).T@x >= 0.01, @@ -578,7 +578,7 @@ class MedianPreimageGenerator(PreimageGenerator): elif is_n_attr and not is_e_attr: nb_cost_mat_new = nb_cost_mat[:,[0,1,2,3,4]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.0 for i in range(nb_cost_mat_new.shape[1])], np.array([1.0, 0.0, 0.0, 0.0, 0.0]).T@x >= 0.01, np.array([0.0, 1.0, 0.0, 0.0, 0.0]).T@x >= 0.01, @@ -591,7 +591,7 @@ class MedianPreimageGenerator(PreimageGenerator): elif not is_n_attr and is_e_attr: nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4,5]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.0 for i in range(nb_cost_mat_new.shape[1])], np.array([1.0, 0.0, 0.0, 0.0, 0.0]).T@x >= 0.01, np.array([0.0, 1.0, 0.0, 0.0, 0.0]).T@x >= 0.01, @@ -604,7 +604,7 @@ class MedianPreimageGenerator(PreimageGenerator): else: nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat_new.shape[1])]] prob = cp.Problem(cp.Minimize(cost_fun), constraints) self.__execute_cvx(prob) @@ -615,7 +615,7 @@ class MedianPreimageGenerator(PreimageGenerator): if is_n_attr and is_e_attr: nb_cost_mat_new = nb_cost_mat[:,[0,1,2,3,4,5]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.0 for i in range(nb_cost_mat_new.shape[1])], np.array([1.0, 0.0, 0.0, 0.0, 0.0, 0.0]).T@x >= 0.01, np.array([0.0, 1.0, 0.0, 0.0, 0.0, 0.0]).T@x >= 0.01, @@ -630,7 +630,7 @@ class MedianPreimageGenerator(PreimageGenerator): elif is_n_attr and not is_e_attr: nb_cost_mat_new = nb_cost_mat[:,[0,1,2,3,4]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.0 for i in range(nb_cost_mat_new.shape[1])], np.array([1.0, 0.0, 0.0, 0.0, 0.0]).T@x >= 0.01, np.array([0.0, 1.0, 0.0, 0.0, 0.0]).T@x >= 0.01, @@ -644,7 +644,7 @@ class MedianPreimageGenerator(PreimageGenerator): elif not is_n_attr and is_e_attr: nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4,5]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.0 for i in range(nb_cost_mat_new.shape[1])], np.array([1.0, 0.0, 0.0, 0.0, 0.0]).T@x >= 0.01, np.array([0.0, 1.0, 0.0, 0.0, 0.0]).T@x >= 0.01, @@ -658,7 +658,7 @@ class MedianPreimageGenerator(PreimageGenerator): else: nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat_new.shape[1])]] prob = cp.Problem(cp.Minimize(cost_fun), constraints) self.__execute_cvx(prob) @@ -669,7 +669,7 @@ class MedianPreimageGenerator(PreimageGenerator): if is_n_attr and is_e_attr: nb_cost_mat_new = nb_cost_mat[:,[0,1,2,3,4,5]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat_new.shape[1])]] prob = cp.Problem(cp.Minimize(cost_fun), constraints) self.__execute_cvx(prob) @@ -678,7 +678,7 @@ class MedianPreimageGenerator(PreimageGenerator): elif is_n_attr and not is_e_attr: nb_cost_mat_new = nb_cost_mat[:,[0,1,2,3,4]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat_new.shape[1])]] prob = cp.Problem(cp.Minimize(cost_fun), constraints) self.__execute_cvx(prob) @@ -687,7 +687,7 @@ class MedianPreimageGenerator(PreimageGenerator): elif not is_n_attr and is_e_attr: nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4,5]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat_new.shape[1])]] prob = cp.Problem(cp.Minimize(cost_fun), constraints) self.__execute_cvx(prob) @@ -696,7 +696,7 @@ class MedianPreimageGenerator(PreimageGenerator): else: nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat_new.shape[1])]] prob = cp.Problem(cp.Minimize(cost_fun), constraints) self.__execute_cvx(prob) @@ -708,7 +708,7 @@ class MedianPreimageGenerator(PreimageGenerator): if is_n_attr and is_e_attr: nb_cost_mat_new = nb_cost_mat[:,[0,1,2,3,4,5]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat_new.shape[1])], np.array([1.0, 1.0, -1.0, 0.0, 0.0, 0.0]).T@x >= 0.0, np.array([0.0, 0.0, 0.0, 1.0, 1.0, -1.0]).T@x >= 0.0] @@ -719,7 +719,7 @@ class MedianPreimageGenerator(PreimageGenerator): elif is_n_attr and not is_e_attr: nb_cost_mat_new = nb_cost_mat[:,[0,1,2,3,4]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat_new.shape[1])], np.array([1.0, 1.0, -1.0, 0.0, 0.0]).T@x >= 0.0] prob = cp.Problem(cp.Minimize(cost_fun), constraints) @@ -729,7 +729,7 @@ class MedianPreimageGenerator(PreimageGenerator): elif not is_n_attr and is_e_attr: nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4,5]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat_new.shape[1])], np.array([0.0, 0.0, 1.0, 1.0, -1.0]).T@x >= 0.0] prob = cp.Problem(cp.Minimize(cost_fun), constraints) @@ -739,7 +739,7 @@ class MedianPreimageGenerator(PreimageGenerator): else: nb_cost_mat_new = nb_cost_mat[:,[0,1,3,4]] x = cp.Variable(nb_cost_mat_new.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat_new @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat_new.shape[1])]] prob = cp.Problem(cp.Minimize(cost_fun), constraints) self.__execute_cvx(prob) @@ -750,7 +750,7 @@ class MedianPreimageGenerator(PreimageGenerator): elif self.__ged_options['edit_cost'] == 'CONSTANT': # @todo: node/edge may not labeled. if not self.__triangle_rule and self.__allow_zeros: x = cp.Variable(nb_cost_mat.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat @ x - dis_k_vec) constraints = [x >= [0.0 for i in range(nb_cost_mat.shape[1])], np.array([1.0, 0.0, 0.0, 0.0, 0.0, 0.0]).T@x >= 0.01, np.array([0.0, 1.0, 0.0, 0.0, 0.0, 0.0]).T@x >= 0.01, @@ -762,7 +762,7 @@ class MedianPreimageGenerator(PreimageGenerator): residual = np.sqrt(prob.value) elif self.__triangle_rule and self.__allow_zeros: x = cp.Variable(nb_cost_mat.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat @ x - dis_k_vec) constraints = [x >= [0.0 for i in range(nb_cost_mat.shape[1])], np.array([1.0, 0.0, 0.0, 0.0, 0.0, 0.0]).T@x >= 0.01, np.array([0.0, 1.0, 0.0, 0.0, 0.0, 0.0]).T@x >= 0.01, @@ -776,7 +776,7 @@ class MedianPreimageGenerator(PreimageGenerator): residual = np.sqrt(prob.value) elif not self.__triangle_rule and not self.__allow_zeros: x = cp.Variable(nb_cost_mat.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat.shape[1])]] prob = cp.Problem(cp.Minimize(cost_fun), constraints) self.__execute_cvx(prob) @@ -784,7 +784,7 @@ class MedianPreimageGenerator(PreimageGenerator): residual = np.sqrt(prob.value) elif self.__triangle_rule and not self.__allow_zeros: x = cp.Variable(nb_cost_mat.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat @ x - dis_k_vec) constraints = [x >= [0.01 for i in range(nb_cost_mat.shape[1])], np.array([1.0, 1.0, -1.0, 0.0, 0.0, 0.0]).T@x >= 0.0, np.array([0.0, 0.0, 0.0, 1.0, 1.0, -1.0]).T@x >= 0.0] @@ -818,7 +818,7 @@ class MedianPreimageGenerator(PreimageGenerator): # G = -1 * np.identity(nb_cost_mat.shape[1]) # h = np.array([0 for i in range(nb_cost_mat.shape[1])]) x = cp.Variable(nb_cost_mat.shape[1]) - cost_fun = cp.sum_squares(nb_cost_mat * x - dis_k_vec) + cost_fun = cp.sum_squares(nb_cost_mat @ x - dis_k_vec) constraints = [x >= [0.0 for i in range(nb_cost_mat.shape[1])], # np.array([1.0, 1.0, -1.0, 0.0, 0.0]).T@x >= 0.0] np.array([1.0, 1.0, -1.0, 0.0, 0.0, 0.0]).T@x >= 0.0, diff --git a/gklearn/utils/graph_files.py b/gklearn/utils/graph_files.py index d977b73..7de4ba0 100644 --- a/gklearn/utils/graph_files.py +++ b/gklearn/utils/graph_files.py @@ -494,7 +494,8 @@ def load_tud(filename): 'edge_labels': [], 'edge_attrs': []} class_label_map = None class_label_map_strings = [] - content_rm = open(frm).read().splitlines() + with open(frm) as rm: + content_rm = rm.read().splitlines() i = 0 while i < len(content_rm): line = content_rm[i].strip() @@ -558,16 +559,20 @@ def load_tud(filename): label_names = {'node_labels': [], 'node_attrs': [], 'edge_labels': [], 'edge_attrs': []} class_label_map = None - - content_gi = open(fgi).read().splitlines() # graph indicator - content_am = open(fam).read().splitlines() # adjacency matrix + + with open(fgi) as gi: + content_gi = gi.read().splitlines() # graph indicator + with open(fam) as am: + content_am = am.read().splitlines() # adjacency matrix # load targets. if 'fgl' in locals(): - content_targets = open(fgl).read().splitlines() # targets (classification) + with open(fgl) as gl: + content_targets = gl.read().splitlines() # targets (classification) targets = [float(i) for i in content_targets] elif 'fga' in locals(): - content_targets = open(fga).read().splitlines() # targets (regression) + with open(fga) as ga: + content_targets = ga.read().splitlines() # targets (regression) targets = [int(i) for i in content_targets] else: raise Exception('Can not find targets file. Please make sure there is a "', ds_name, '_graph_labels.txt" or "', ds_name, '_graph_attributes.txt"', 'file in your dataset folder.') @@ -577,7 +582,8 @@ def load_tud(filename): # create graphs and add nodes data = [nx.Graph(name=str(i)) for i in range(0, len(content_targets))] if 'fnl' in locals(): - content_nl = open(fnl).read().splitlines() # node labels + with open(fnl) as nl: + content_nl = nl.read().splitlines() # node labels for idx, line in enumerate(content_gi): # transfer to int first in case of unexpected blanks data[int(line) - 1].add_node(idx) @@ -605,7 +611,8 @@ def load_tud(filename): # add edge labels if 'fel' in locals(): - content_el = open(fel).read().splitlines() + with open(fel) as el: + content_el = el.read().splitlines() for idx, line in enumerate(content_el): labels = [l.strip() for l in line.split(',')] n = [int(i) - 1 for i in content_am[idx].split(',')] @@ -621,7 +628,8 @@ def load_tud(filename): # add node attributes if 'fna' in locals(): - content_na = open(fna).read().splitlines() + with open(fna) as na: + content_na = na.read().splitlines() for idx, line in enumerate(content_na): attrs = [a.strip() for a in line.split(',')] g = int(content_gi[idx]) - 1 @@ -636,7 +644,8 @@ def load_tud(filename): # add edge attributes if 'fea' in locals(): - content_ea = open(fea).read().splitlines() + with open(fea) as ea: + content_ea = ea.read().splitlines() for idx, line in enumerate(content_ea): attrs = [a.strip() for a in line.split(',')] n = [int(i) - 1 for i in content_am[idx].split(',')] @@ -669,7 +678,8 @@ def load_from_ds(filename, filename_targets): data = [] y = [] label_names = {'node_labels': [], 'edge_labels': [], 'node_attrs': [], 'edge_attrs': []} - content = open(filename).read().splitlines() + with open(filename) as fn: + content = fn.read().splitlines() extension = splitext(content[0].split(' ')[0])[1][1:] if extension == 'ct': load_file_fun = load_ct @@ -691,8 +701,9 @@ def load_from_ds(filename, filename_targets): g, l_names = load_file_fun(dirname_dataset + '/' + tmp.replace('#', '', 1)) data.append(g) __append_label_names(label_names, l_names) - - content_y = open(filename_targets).read().splitlines() + + with open(filename_targets) as fnt: + content_y = fnt.read().splitlines() # assume entries in filename and filename_targets have the same order. for item in content_y: tmp = item.split(' ')