#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Tue Jan 14 15:39:29 2020 @author: ljia """ import numpy as np import random import csv from shutil import copyfile import networkx as nx import matplotlib.pyplot as plt import os from gklearn.utils.graphfiles import loadDataset, loadGXL, saveGXL from gklearn.preimage.test_k_closest_graphs import median_on_k_closest_graphs, reform_attributes from gklearn.preimage.utils import get_same_item_indices, kernel_distance_matrix, compute_kernel from gklearn.preimage.find_best_k import getRelations def get_dataset(ds_name): if ds_name == 'Letter-high': # node non-symb dataset = 'cpp_ext/data/collections/Letter.xml' graph_dir = os.path.dirname(os.path.realpath(__file__)) + '/cpp_ext/data/datasets/Letter/HIGH/' Gn, y_all = loadDataset(dataset, extra_params=graph_dir) for G in Gn: reform_attributes(G) elif ds_name == 'Fingerprint': # dataset = 'cpp_ext/data/collections/Fingerprint.xml' # graph_dir = os.path.dirname(os.path.realpath(__file__)) + '/cpp_ext/generated_datsets/Fingerprint/node_attrs/' # Gn, y_all = loadDataset(dataset, extra_params=graph_dir) # for G in Gn: # reform_attributes(G) dataset = '../../datasets/Fingerprint/Fingerprint_A.txt' graph_dir = os.path.dirname(os.path.realpath(__file__)) + '/cpp_ext/generated_datsets/Fingerprint/node_attrs/' Gn, y_all = loadDataset(dataset) elif ds_name == 'SYNTHETIC': pass elif ds_name == 'SYNTHETICnew': dataset = '../../datasets/SYNTHETICnew/SYNTHETICnew_A.txt' graph_dir = os.path.dirname(os.path.realpath(__file__)) + '/cpp_ext/generated_datsets/SYNTHETICnew' # dataset = '../../datasets/Letter-high/Letter-high_A.txt' # graph_dir = os.path.dirname(os.path.realpath(__file__)) + '/cpp_ext/data/datasets/Letter/HIGH/' Gn, y_all = loadDataset(dataset) elif ds_name == 'Synthie': pass elif ds_name == 'COIL-RAG': pass elif ds_name == 'COLORS-3': pass elif ds_name == 'FRANKENSTEIN': pass return Gn, y_all, graph_dir def init_output_file(ds_name, gkernel, fit_method, dir_output): # fn_output_detail = 'results_detail.' + ds_name + '.' + gkernel + '.' + fit_method + '.csv' fn_output_detail = 'results_detail.' + ds_name + '.' + gkernel + '.csv' f_detail = open(dir_output + fn_output_detail, 'a') csv.writer(f_detail).writerow(['dataset', 'graph kernel', 'edit cost', 'GED method', 'attr distance', 'fit method', 'k', 'target', 'repeat', 'SOD SM', 'SOD GM', 'dis_k SM', 'dis_k GM', 'min dis_k gi', 'SOD SM -> GM', 'dis_k SM -> GM', 'dis_k gi -> SM', 'dis_k gi -> GM', 'fitting time', 'generating time', 'total time', 'median set']) f_detail.close() # fn_output_summary = 'results_summary.' + ds_name + '.' + gkernel + '.' + fit_method + '.csv' fn_output_summary = 'results_summary.' + ds_name + '.' + gkernel + '.csv' f_summary = open(dir_output + fn_output_summary, 'a') csv.writer(f_summary).writerow(['dataset', 'graph kernel', 'edit cost', 'GED method', 'attr distance', 'fit method', 'k', 'target', 'SOD SM', 'SOD GM', 'dis_k SM', 'dis_k GM', 'min dis_k gi', 'SOD SM -> GM', 'dis_k SM -> GM', 'dis_k gi -> SM', 'dis_k gi -> GM', 'fitting time', 'generating time', 'total time', '# SOD SM -> GM', '# dis_k SM -> GM', '# dis_k gi -> SM', '# dis_k gi -> GM', 'repeats better SOD SM -> GM', 'repeats better dis_k SM -> GM', 'repeats better dis_k gi -> SM', 'repeats better dis_k gi -> GM']) f_summary.close() return fn_output_detail, fn_output_summary def xp_fit_method_for_non_symbolic(parameters, save_results=True, initial_solutions=1, Gn_data=None, k_dis_data=None, Kmatrix=None): # 1. set parameters. print('1. setting parameters...') ds_name = parameters['ds_name'] gkernel = parameters['gkernel'] edit_cost_name = parameters['edit_cost_name'] ged_method = parameters['ged_method'] attr_distance = parameters['attr_distance'] fit_method = parameters['fit_method'] node_label = None edge_label = None dir_output = 'results/xp_fit_method/' # 2. get dataset. print('2. getting dataset...') if Gn_data is None: Gn, y_all, graph_dir = get_dataset(ds_name) else: Gn = Gn_data[0] y_all = Gn_data[1] graph_dir = Gn_data[2] # 3. compute kernel distance matrix. print('3. computing kernel distance matrix...') if k_dis_data is None: dis_mat, dis_max, dis_min, dis_mean = kernel_distance_matrix(Gn, None, None, Kmatrix=Kmatrix, gkernel=gkernel) else: dis_mat = k_dis_data[0] dis_max = k_dis_data[1] dis_min = k_dis_data[2] dis_mean = k_dis_data[3] print('pair distances - dis_max, dis_min, dis_mean:', dis_max, dis_min, dis_mean) if save_results: # create result files. print('creating output files...') fn_output_detail, fn_output_summary = init_output_file(ds_name, gkernel, fit_method, dir_output) # start repeats. repeats = 1 # k_list = range(2, 11) k_list = [0] # get indices by classes. y_idx = get_same_item_indices(y_all) random.seed(1) rdn_seed_list = random.sample(range(0, repeats * 100), repeats) for k in k_list: # print('\n--------- k =', k, '----------') sod_sm_mean_list = [] sod_gm_mean_list = [] dis_k_sm_mean_list = [] dis_k_gm_mean_list = [] dis_k_gi_min_mean_list = [] time_fitting_mean_list = [] time_generating_mean_list = [] time_total_mean_list = [] # 3. start generating and computing over targets. print('4. starting generating and computing over targets......') for i, (y, values) in enumerate(y_idx.items()): # y = 'I' # values = y_idx[y] # values = values[0:10] print('\ny =', y) # if y.strip() == 'A': # continue k = len(values) print('\n--------- k =', k, '----------') sod_sm_list = [] sod_gm_list = [] dis_k_sm_list = [] dis_k_gm_list = [] dis_k_gi_min_list = [] time_fitting_list = [] time_generating_list = [] time_total_list = [] nb_sod_sm2gm = [0, 0, 0] nb_dis_k_sm2gm = [0, 0, 0] nb_dis_k_gi2sm = [0, 0, 0] nb_dis_k_gi2gm = [0, 0, 0] repeats_better_sod_sm2gm = [] repeats_better_dis_k_sm2gm = [] repeats_better_dis_k_gi2sm = [] repeats_better_dis_k_gi2gm = [] # get Gram matrix for this part of data. if Kmatrix is not None: Kmatrix_sub = Kmatrix[values,:] Kmatrix_sub = Kmatrix_sub[:,values] else: Kmatrix_sub = None for repeat in range(repeats): print('\nrepeat =', repeat) random.seed(rdn_seed_list[repeat]) median_set_idx_idx = random.sample(range(0, len(values)), k) median_set_idx = [values[idx] for idx in median_set_idx_idx] print('median set: ', median_set_idx) Gn_median = [Gn[g] for g in values] # from notebooks.utils.plot_all_graphs import draw_Fingerprint_graph # for Gn in Gn_median: # draw_Fingerprint_graph(Gn, save=None) # GENERATING & COMPUTING!! res_sods, res_dis_ks, res_times = median_on_k_closest_graphs(Gn_median, node_label, edge_label, gkernel, k, fit_method=fit_method, graph_dir=graph_dir, edit_cost_constants=None, group_min=median_set_idx_idx, dataset=ds_name, initial_solutions=initial_solutions, edit_cost_name=edit_cost_name, Kmatrix=Kmatrix_sub, parallel=False) sod_sm = res_sods[0] sod_gm = res_sods[1] dis_k_sm = res_dis_ks[0] dis_k_gm = res_dis_ks[1] dis_k_gi = res_dis_ks[2] dis_k_gi_min = res_dis_ks[3] idx_dis_k_gi_min = res_dis_ks[4] time_fitting = res_times[0] time_generating = res_times[1] # write result detail. sod_sm2gm = getRelations(np.sign(sod_gm - sod_sm)) dis_k_sm2gm = getRelations(np.sign(dis_k_gm - dis_k_sm)) dis_k_gi2sm = getRelations(np.sign(dis_k_sm - dis_k_gi_min)) dis_k_gi2gm = getRelations(np.sign(dis_k_gm - dis_k_gi_min)) if save_results: f_detail = open(dir_output + fn_output_detail, 'a') csv.writer(f_detail).writerow([ds_name, gkernel, edit_cost_name, ged_method, attr_distance, fit_method, k, y, repeat, sod_sm, sod_gm, dis_k_sm, dis_k_gm, dis_k_gi_min, sod_sm2gm, dis_k_sm2gm, dis_k_gi2sm, dis_k_gi2gm, time_fitting, time_generating, time_fitting + time_generating, median_set_idx]) f_detail.close() # compute result summary. sod_sm_list.append(sod_sm) sod_gm_list.append(sod_gm) dis_k_sm_list.append(dis_k_sm) dis_k_gm_list.append(dis_k_gm) dis_k_gi_min_list.append(dis_k_gi_min) time_fitting_list.append(time_fitting) time_generating_list.append(time_generating) time_total_list.append(time_fitting + time_generating) # # SOD SM -> GM if sod_sm > sod_gm: nb_sod_sm2gm[0] += 1 repeats_better_sod_sm2gm.append(repeat) elif sod_sm == sod_gm: nb_sod_sm2gm[1] += 1 elif sod_sm < sod_gm: nb_sod_sm2gm[2] += 1 # # dis_k SM -> GM if dis_k_sm > dis_k_gm: nb_dis_k_sm2gm[0] += 1 repeats_better_dis_k_sm2gm.append(repeat) elif dis_k_sm == dis_k_gm: nb_dis_k_sm2gm[1] += 1 elif dis_k_sm < dis_k_gm: nb_dis_k_sm2gm[2] += 1 # # dis_k gi -> SM if dis_k_gi_min > dis_k_sm: nb_dis_k_gi2sm[0] += 1 repeats_better_dis_k_gi2sm.append(repeat) elif dis_k_gi_min == dis_k_sm: nb_dis_k_gi2sm[1] += 1 elif dis_k_gi_min < dis_k_sm: nb_dis_k_gi2sm[2] += 1 # # dis_k gi -> GM if dis_k_gi_min > dis_k_gm: nb_dis_k_gi2gm[0] += 1 repeats_better_dis_k_gi2gm.append(repeat) elif dis_k_gi_min == dis_k_gm: nb_dis_k_gi2gm[1] += 1 elif dis_k_gi_min < dis_k_gm: nb_dis_k_gi2gm[2] += 1 # save median graphs. fname_sm = os.path.dirname(os.path.realpath(__file__)) + '/cpp_ext/output/tmp_ged/set_median.gxl' fn_pre_sm_new = dir_output + 'medians/set_median.' + fit_method \ + '.k' + str(int(k)) + '.y' + str(y) + '.repeat' + str(repeat) copyfile(fname_sm, fn_pre_sm_new + '.gxl') fname_gm = os.path.dirname(os.path.realpath(__file__)) + '/cpp_ext/output/tmp_ged/gen_median.gxl' fn_pre_gm_new = dir_output + 'medians/gen_median.' + fit_method \ + '.k' + str(int(k)) + '.y' + str(y) + '.repeat' + str(repeat) copyfile(fname_gm, fn_pre_gm_new + '.gxl') G_best_kernel = Gn_median[idx_dis_k_gi_min].copy() # reform_attributes(G_best_kernel) fn_pre_g_best_kernel = dir_output + 'medians/g_best_kernel.' + fit_method \ + '.k' + str(int(k)) + '.y' + str(y) + '.repeat' + str(repeat) saveGXL(G_best_kernel, fn_pre_g_best_kernel + '.gxl', method='default') # plot median graphs. if ds_name == 'Letter-high': set_median = loadGXL(fn_pre_sm_new + '.gxl') gen_median = loadGXL(fn_pre_gm_new + '.gxl') draw_Letter_graph(set_median, fn_pre_sm_new) draw_Letter_graph(gen_median, fn_pre_gm_new) draw_Letter_graph(G_best_kernel, fn_pre_g_best_kernel) # write result summary for each letter. sod_sm_mean_list.append(np.mean(sod_sm_list)) sod_gm_mean_list.append(np.mean(sod_gm_list)) dis_k_sm_mean_list.append(np.mean(dis_k_sm_list)) dis_k_gm_mean_list.append(np.mean(dis_k_gm_list)) dis_k_gi_min_mean_list.append(np.mean(dis_k_gi_min_list)) time_fitting_mean_list.append(np.mean(time_fitting_list)) time_generating_mean_list.append(np.mean(time_generating_list)) time_total_mean_list.append(np.mean(time_total_list)) sod_sm2gm_mean = getRelations(np.sign(sod_gm_mean_list[-1] - sod_sm_mean_list[-1])) dis_k_sm2gm_mean = getRelations(np.sign(dis_k_gm_mean_list[-1] - dis_k_sm_mean_list[-1])) dis_k_gi2sm_mean = getRelations(np.sign(dis_k_sm_mean_list[-1] - dis_k_gi_min_mean_list[-1])) dis_k_gi2gm_mean = getRelations(np.sign(dis_k_gm_mean_list[-1] - dis_k_gi_min_mean_list[-1])) if save_results: f_summary = open(dir_output + fn_output_summary, 'a') csv.writer(f_summary).writerow([ds_name, gkernel, edit_cost_name, ged_method, attr_distance, fit_method, k, y, sod_sm_mean_list[-1], sod_gm_mean_list[-1], dis_k_sm_mean_list[-1], dis_k_gm_mean_list[-1], dis_k_gi_min_mean_list[-1], sod_sm2gm_mean, dis_k_sm2gm_mean, dis_k_gi2sm_mean, dis_k_gi2gm_mean, time_fitting_mean_list[-1], time_generating_mean_list[-1], time_total_mean_list[-1], nb_sod_sm2gm, nb_dis_k_sm2gm, nb_dis_k_gi2sm, nb_dis_k_gi2gm, repeats_better_sod_sm2gm, repeats_better_dis_k_sm2gm, repeats_better_dis_k_gi2sm, repeats_better_dis_k_gi2gm]) f_summary.close() # write result summary for each letter. sod_sm_mean = np.mean(sod_sm_mean_list) sod_gm_mean = np.mean(sod_gm_mean_list) dis_k_sm_mean = np.mean(dis_k_sm_mean_list) dis_k_gm_mean = np.mean(dis_k_gm_mean_list) dis_k_gi_min_mean = np.mean(dis_k_gi_min_list) time_fitting_mean = np.mean(time_fitting_list) time_generating_mean = np.mean(time_generating_list) time_total_mean = np.mean(time_total_list) sod_sm2gm_mean = getRelations(np.sign(sod_gm_mean - sod_sm_mean)) dis_k_sm2gm_mean = getRelations(np.sign(dis_k_gm_mean - dis_k_sm_mean)) dis_k_gi2sm_mean = getRelations(np.sign(dis_k_sm_mean - dis_k_gi_min_mean)) dis_k_gi2gm_mean = getRelations(np.sign(dis_k_gm_mean - dis_k_gi_min_mean)) if save_results: f_summary = open(dir_output + fn_output_summary, 'a') csv.writer(f_summary).writerow([ds_name, gkernel, edit_cost_name, ged_method, attr_distance, fit_method, k, 'all', sod_sm_mean, sod_gm_mean, dis_k_sm_mean, dis_k_gm_mean, dis_k_gi_min_mean, sod_sm2gm_mean, dis_k_sm2gm_mean, dis_k_gi2sm_mean, dis_k_gi2gm_mean, time_fitting_mean, time_generating_mean, time_total_mean]) f_summary.close() print('\ncomplete.') #Dessin median courrant def draw_Letter_graph(graph, file_prefix): plt.figure() pos = {} for n in graph.nodes: pos[n] = np.array([float(graph.node[n]['x']),float(graph.node[n]['y'])]) nx.draw_networkx(graph, pos) plt.savefig(file_prefix + '.eps', format='eps', dpi=300) # plt.show() plt.clf() if __name__ == "__main__": # #### xp 1: Letter-high, spkernel. # # load dataset. # print('getting dataset and computing kernel distance matrix first...') # ds_name = 'Letter-high' # gkernel = 'spkernel' # Gn, y_all, graph_dir = get_dataset(ds_name) # # remove graphs without edges. # Gn = [(idx, G) for idx, G in enumerate(Gn) if nx.number_of_edges(G) != 0] # idx = [G[0] for G in Gn] # Gn = [G[1] for G in Gn] # y_all = [y_all[i] for i in idx] ## Gn = Gn[0:50] ## y_all = y_all[0:50] # # compute pair distances. # dis_mat, dis_max, dis_min, dis_mean = kernel_distance_matrix(Gn, None, None, # Kmatrix=None, gkernel=gkernel, verbose=True) ## dis_mat, dis_max, dis_min, dis_mean = 0, 0, 0, 0 # # fitting and computing. # fit_methods = ['random', 'expert', 'k-graphs'] # for fit_method in fit_methods: # print('\n-------------------------------------') # print('fit method:', fit_method) # parameters = {'ds_name': ds_name, # 'gkernel': gkernel, # 'edit_cost_name': 'LETTER2', # 'ged_method': 'mIPFP', # 'attr_distance': 'euclidean', # 'fit_method': fit_method} # xp_fit_method_for_non_symbolic(parameters, save_results=True, # initial_solutions=40, # Gn_data = [Gn, y_all, graph_dir], # k_dis_data = [dis_mat, dis_max, dis_min, dis_mean]) # #### xp 2: Letter-high, sspkernel. # # load dataset. # print('getting dataset and computing kernel distance matrix first...') # ds_name = 'Letter-high' # gkernel = 'structuralspkernel' # Gn, y_all, graph_dir = get_dataset(ds_name) ## Gn = Gn[0:50] ## y_all = y_all[0:50] # # compute pair distances. # dis_mat, dis_max, dis_min, dis_mean = kernel_distance_matrix(Gn, None, None, # Kmatrix=None, gkernel=gkernel, verbose=True) ## dis_mat, dis_max, dis_min, dis_mean = 0, 0, 0, 0 # # fitting and computing. # fit_methods = ['random', 'expert', 'k-graphs'] # for fit_method in fit_methods: # print('\n-------------------------------------') # print('fit method:', fit_method) # parameters = {'ds_name': ds_name, # 'gkernel': gkernel, # 'edit_cost_name': 'LETTER2', # 'ged_method': 'mIPFP', # 'attr_distance': 'euclidean', # 'fit_method': fit_method} # print('parameters: ', parameters) # xp_fit_method_for_non_symbolic(parameters, save_results=True, # initial_solutions=40, # Gn_data = [Gn, y_all, graph_dir], # k_dis_data = [dis_mat, dis_max, dis_min, dis_mean]) # #### xp 3: SYNTHETICnew, sspkernel, using NON_SYMBOLIC. # gmfile = np.load('results/xp_fit_method/Kmatrix.SYNTHETICnew.structuralspkernel.gm.npz') # Kmatrix = gmfile['Kmatrix'] # run_time = gmfile['run_time'] # # normalization # Kmatrix_diag = Kmatrix.diagonal().copy() # for i in range(len(Kmatrix)): # for j in range(i, len(Kmatrix)): # Kmatrix[i][j] /= np.sqrt(Kmatrix_diag[i] * Kmatrix_diag[j]) # Kmatrix[j][i] = Kmatrix[i][j] ## np.savez('results/xp_fit_method/Kmatrix.SYNTHETICnew.spkernel.gm', ## Kmatrix=Kmatrix, run_time=run_time) # # load dataset. # print('getting dataset and computing kernel distance matrix first...') # ds_name = 'SYNTHETICnew' # gkernel = 'structuralspkernel' # Gn, y_all, graph_dir = get_dataset(ds_name) # # remove graphs without nodes and edges. # Gn = [(idx, G) for idx, G in enumerate(Gn) if (nx.number_of_nodes(G) != 0 # and nx.number_of_edges(G) != 0)] # idx = [G[0] for G in Gn] # Gn = [G[1] for G in Gn] # y_all = [y_all[i] for i in idx] ## Gn = Gn[0:10] ## y_all = y_all[0:10] # for G in Gn: # G.graph['filename'] = 'graph' + str(G.graph['name']) + '.gxl' # # compute pair distances. # dis_mat, dis_max, dis_min, dis_mean = kernel_distance_matrix(Gn, None, None, # Kmatrix=Kmatrix, gkernel=gkernel, verbose=True) ## dis_mat, dis_max, dis_min, dis_mean = 0, 0, 0, 0 # # fitting and computing. # fit_methods = ['k-graphs', 'random', 'random', 'random'] # for fit_method in fit_methods: # print('\n-------------------------------------') # print('fit method:', fit_method) # parameters = {'ds_name': ds_name, # 'gkernel': gkernel, # 'edit_cost_name': 'NON_SYMBOLIC', # 'ged_method': 'mIPFP', # 'attr_distance': 'euclidean', # 'fit_method': fit_method} # xp_fit_method_for_non_symbolic(parameters, save_results=True, # initial_solutions=1, # Gn_data = [Gn, y_all, graph_dir], # k_dis_data = [dis_mat, dis_max, dis_min, dis_mean], # Kmatrix=Kmatrix) # ### xp 4: SYNTHETICnew, spkernel, using NON_SYMBOLIC. # gmfile = np.load('results/xp_fit_method/Kmatrix.SYNTHETICnew.spkernel.gm.npz') # Kmatrix = gmfile['Kmatrix'] # # normalization # Kmatrix_diag = Kmatrix.diagonal().copy() # for i in range(len(Kmatrix)): # for j in range(i, len(Kmatrix)): # Kmatrix[i][j] /= np.sqrt(Kmatrix_diag[i] * Kmatrix_diag[j]) # Kmatrix[j][i] = Kmatrix[i][j] # run_time = 21821.35 # np.savez('results/xp_fit_method/Kmatrix.SYNTHETICnew.spkernel.gm', # Kmatrix=Kmatrix, run_time=run_time) # # # load dataset. # print('getting dataset and computing kernel distance matrix first...') # ds_name = 'SYNTHETICnew' # gkernel = 'spkernel' # Gn, y_all, graph_dir = get_dataset(ds_name) ## # remove graphs without nodes and edges. ## Gn = [(idx, G) for idx, G in enumerate(Gn) if (nx.number_of_node(G) != 0 ## and nx.number_of_edges(G) != 0)] ## idx = [G[0] for G in Gn] ## Gn = [G[1] for G in Gn] ## y_all = [y_all[i] for i in idx] ## Gn = Gn[0:5] ## y_all = y_all[0:5] # for G in Gn: # G.graph['filename'] = 'graph' + str(G.graph['name']) + '.gxl' # # # compute/read Gram matrix and pair distances. ## Kmatrix = compute_kernel(Gn, gkernel, None, None, True) ## np.savez('results/xp_fit_method/Kmatrix.' + ds_name + '.' + gkernel + '.gm', ## Kmatrix=Kmatrix) # gmfile = np.load('results/xp_fit_method/Kmatrix.' + ds_name + '.' + gkernel + '.gm.npz') # Kmatrix = gmfile['Kmatrix'] # run_time = gmfile['run_time'] ## Kmatrix = Kmatrix[[0,1,2,3,4],:] ## Kmatrix = Kmatrix[:,[0,1,2,3,4]] # print('\nTime to compute Gram matrix for the whole dataset: ', run_time) # dis_mat, dis_max, dis_min, dis_mean = kernel_distance_matrix(Gn, None, None, # Kmatrix=Kmatrix, gkernel=gkernel, verbose=True) ## Kmatrix = np.zeros((len(Gn), len(Gn))) ## dis_mat, dis_max, dis_min, dis_mean = 0, 0, 0, 0 # # # fitting and computing. # fit_methods = ['k-graphs', 'random', 'random', 'random'] # for fit_method in fit_methods: # print('\n-------------------------------------') # print('fit method:', fit_method) # parameters = {'ds_name': ds_name, # 'gkernel': gkernel, # 'edit_cost_name': 'NON_SYMBOLIC', # 'ged_method': 'mIPFP', # 'attr_distance': 'euclidean', # 'fit_method': fit_method} # xp_fit_method_for_non_symbolic(parameters, save_results=True, # initial_solutions=1, # Gn_data=[Gn, y_all, graph_dir], # k_dis_data=[dis_mat, dis_max, dis_min, dis_mean], # Kmatrix=Kmatrix) #### xp 5: Fingerprint, sspkernel, using LETTER2. # load dataset. print('getting dataset and computing kernel distance matrix first...') ds_name = 'Fingerprint' gkernel = 'structuralspkernel' Gn, y_all, graph_dir = get_dataset(ds_name) # remove graphs without nodes and edges. Gn = [(idx, G) for idx, G in enumerate(Gn) if (nx.number_of_nodes(G) != 0)] # and nx.number_of_edges(G) != 0)] idx = [G[0] for G in Gn] Gn = [G[1] for G in Gn] y_all = [y_all[i] for i in idx] y_idx = get_same_item_indices(y_all) # remove unused labels. for G in Gn: G.graph['edge_attrs'] = [] for edge in G.edges: del G.edges[edge]['attributes'] del G.edges[edge]['orient'] del G.edges[edge]['angle'] Gn = Gn[805:815] y_all = y_all[805:815] for G in Gn: G.graph['filename'] = 'graph' + str(G.graph['name']) + '.gxl' # compute/read Gram matrix and pair distances. Kmatrix = compute_kernel(Gn, gkernel, None, None, True, parallel='imap_unordered') np.savez('results/xp_fit_method/Kmatrix.' + ds_name + '.' + gkernel + '.gm', Kmatrix=Kmatrix) # gmfile = np.load('results/xp_fit_method/Kmatrix.' + ds_name + '.' + gkernel + '.gm.npz') # Kmatrix = gmfile['Kmatrix'] # run_time = gmfile['run_time'] # Kmatrix = Kmatrix[[0,1,2,3,4],:] # Kmatrix = Kmatrix[:,[0,1,2,3,4]] # print('\nTime to compute Gram matrix for the whole dataset: ', run_time) dis_mat, dis_max, dis_min, dis_mean = kernel_distance_matrix(Gn, None, None, Kmatrix=Kmatrix, gkernel=gkernel, verbose=True) # Kmatrix = np.zeros((len(Gn), len(Gn))) # dis_mat, dis_max, dis_min, dis_mean = 0, 0, 0, 0 # compute pair distances. # dis_mat, dis_max, dis_min, dis_mean = kernel_distance_matrix(Gn, None, None, # Kmatrix=None, gkernel=gkernel, verbose=True) # dis_mat, dis_max, dis_min, dis_mean = 0, 0, 0, 0 # fitting and computing. fit_methods = ['k-graphs', 'expert', 'random', 'random', 'random'] for fit_method in fit_methods: print('\n-------------------------------------') print('fit method:', fit_method) parameters = {'ds_name': ds_name, 'gkernel': gkernel, 'edit_cost_name': 'LETTER2', 'ged_method': 'mIPFP', 'attr_distance': 'euclidean', 'fit_method': fit_method} xp_fit_method_for_non_symbolic(parameters, save_results=True, initial_solutions=40, Gn_data = [Gn, y_all, graph_dir], k_dis_data = [dis_mat, dis_max, dis_min, dis_mean], Kmatrix=Kmatrix)