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

648 lines
30 kB
Raw Blame History 

  1. #!/usr/bin/env python3

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

  3. """

  4. Created on Thu Oct 24 11:50:56 2019

  5. 

  6. @author: ljia

  7. """

  8. from matplotlib import pyplot as plt

  9. import numpy as np

  10. from tqdm import tqdm

  11. 

  12. from gklearn.utils.graphfiles import loadDataset

  13. from gklearn.preimage.utils import remove_edges

  14. from gklearn.preimage.fitDistance import fit_GED_to_kernel_distance

  15. from gklearn.preimage.utils import normalize_distance_matrix

  16. 

  17. 

  18. def test_update_costs():

  19.     from preimage.fitDistance import update_costs

  20.     import cvxpy as cp

  21.     

  22.     ds = np.load('results/xp_fit_method/fit_data_debug4.gm.npz')

  23.     nb_cost_mat = ds['nb_cost_mat']

  24.     dis_k_vec = ds['dis_k_vec']

  25.     n_edit_operations = ds['n_edit_operations']

  26.     ged_vec_init = ds['ged_vec_init']

  27.     ged_mat = ds['ged_mat']

  28.     

  29.     nb_cost_mat_new = nb_cost_mat[:,[2,3,4]]

  30.     x = cp.Variable(nb_cost_mat_new.shape[1])

  31.     cost_fun = cp.sum_squares(nb_cost_mat_new * x - dis_k_vec)

  32. #    constraints = [x >= [0.000 for i in range(nb_cost_mat_new.shape[1])],

  33. #                   np.array([1.0, 1.0, -1.0, 0.0, 0.0]).T@x >= 0.0]

  34. #    constraints = [x >= [0.000 for i in range(nb_cost_mat_new.shape[1])],

  35. #                   np.array([1.0, 1.0, -1.0, 0.0, 0.0]).T@x >= 0.0,

  36. #                   np.array([0.0, 0.0, 0.0, 1.0, -1.0]).T@x == 0.0]

  37.     constraints = [x >= [0.00 for i in range(nb_cost_mat_new.shape[1])],

  38.                    np.array([0.0, 1.0, -1.0]).T@x == 0.0]

  39. #    constraints = [x >= [0.00000 for i in range(nb_cost_mat_new.shape[1])]]

  40.     prob = cp.Problem(cp.Minimize(cost_fun), constraints)

  41.     prob.solve()

  42.     print(x.value)

  43.     edit_costs_new = np.concatenate((x.value, np.array([0.0])))

  44.     residual = np.sqrt(prob.value)

  45. 

  46. 

  47. def median_paper_clcpc_python_best():

  48.     """c_vs <= c_vi + c_vr, c_es <= c_ei + c_er with ged computation with 

  49.        python invoking the c++ code by bash command (with updated library).

  50.     """

  51. #    ds = {'name': 'monoterpenoides', 

  52. #          'dataset': '../datasets/monoterpenoides/dataset_10+.ds'}  # node/edge symb

  53. #    _, y_all = loadDataset(ds['dataset'])

  54.     gkernel = 'untilhpathkernel'

  55.     node_label = 'atom'

  56.     edge_label = 'bond_type'

  57.     itr_max = 6

  58.     algo_options = '--threads 8 --initial-solutions 40 --ratio-runs-from-initial-solutions 1'

  59.     params_ged = {'lib': 'gedlibpy', 'cost': 'CONSTANT', 'method': 'IPFP', 

  60.                 'algo_options': algo_options, 'stabilizer': None}

  61.     

  62.     y_all = ['3', '1', '4', '6', '7', '8', '9', '2']

  63.     repeats = 50

  64.     collection_path = os.path.dirname(os.path.realpath(__file__)) + '/cpp_ext/generated_datsets/monoterpenoides/'

  65.     graph_dir = collection_path + 'gxl/'

  66.     

  67.     fn_edit_costs_output = 'results/median_paper/edit_costs_output.python_init40.k10.txt'

  68. 

  69.     for y in y_all:

  70.         for repeat in range(repeats):

  71.             edit_costs_output_file = open(fn_edit_costs_output, 'a')

  72.             collection_file = collection_path + 'monoterpenoides_' + y + '_' + str(repeat) + '.xml'

  73.             Gn, _ = loadDataset(collection_file, extra_params=graph_dir)

  74.             edit_costs, residual_list, edit_cost_list, dis_k_mat, ged_mat, time_list, \

  75.                 nb_cost_mat_list = fit_GED_to_kernel_distance(Gn, node_label, edge_label, 

  76.                                             gkernel, itr_max, params_ged=params_ged, 

  77.                                             parallel=True)

  78.             total_time = np.sum(time_list)

  79. #            print('\nedit_costs:', edit_costs)

  80. #            print('\nresidual_list:', residual_list)

  81. #            print('\nedit_cost_list:', edit_cost_list)

  82. #            print('\ndistance matrix in kernel space:', dis_k_mat)

  83. #            print('\nged matrix:', ged_mat)

  84. #            print('\ntotal time:', total_time)

  85. #            print('\nnb_cost_mat:', nb_cost_mat_list[-1])

  86.             np.savez('results/median_paper/fit_distance.clcpc.python_init40.monot.elabeled.uhpkernel.y' 

  87.                      + y + '.repeat' + str(repeat) + '.k10..gm', 

  88.                      edit_costs=edit_costs, 

  89.                      residual_list=residual_list, edit_cost_list=edit_cost_list,

  90.                      dis_k_mat=dis_k_mat, ged_mat=ged_mat, time_list=time_list, 

  91.                      total_time=total_time, nb_cost_mat_list=nb_cost_mat_list)

  92.             

  93.             for ec in edit_costs:

  94.                 edit_costs_output_file.write(str(ec) + ' ')

  95.             edit_costs_output_file.write('\n')

  96.             edit_costs_output_file.close()

  97.     

  98.     

  99. #    # normalized distance matrices.

  100. #    gmfile = np.load('results/fit_distance.cs_leq_ci_plus_cr.cost_leq_1en2.monot.elabeled.uhpkernel.gm.npz')

  101. #    edit_costs = gmfile['edit_costs']

  102. #    residual_list = gmfile['residual_list']

  103. #    edit_cost_list = gmfile['edit_cost_list']

  104. #    dis_k_mat = gmfile['dis_k_mat']

  105. #    ged_mat = gmfile['ged_mat']

  106. #    total_time = gmfile['total_time']

  107. #    nb_cost_mat_list = gmfile['nb_cost_mat_list']

  108.     

  109.             nb_consistent, nb_inconsistent, ratio_consistent = pairwise_substitution_consistence(dis_k_mat, ged_mat)

  110.             print(nb_consistent, nb_inconsistent, ratio_consistent)

  111.                       

  112. #            norm_dis_k_mat = normalize_distance_matrix(dis_k_mat)

  113. #            plt.imshow(norm_dis_k_mat)

  114. #            plt.colorbar()

  115. #            plt.savefig('results/median_paper/norm_dis_k_mat.clcpc.python_best.monot.elabeled.uhpkernel.y' 

  116. #                        + y + '.repeat' + str(repeat) + '.eps', format='eps', dpi=300)

  117. #            plt.savefig('results/median_paper/norm_dis_k_mat.clcpc.python_best.monot.elabeled.uhpkernel.y' 

  118. #                        + y + '.repeat' + str(repeat) + '.png', format='png')

  119. #        #    plt.show()

  120. #            plt.clf()

  121. #            

  122. #            norm_ged_mat = normalize_distance_matrix(ged_mat)

  123. #            plt.imshow(norm_ged_mat)

  124. #            plt.colorbar()

  125. #            plt.savefig('results/median_paper/norm_ged_mat.clcpc.python_best.monot.elabeled.uhpkernel.y' 

  126. #                        + y + '.repeat' + str(repeat) + '.eps', format='eps', dpi=300)

  127. #            plt.savefig('results/median_paper/norm_ged_mat.clcpc.python_best.monot.elabeled.uhpkernel.y' 

  128. #                        + y + '.repeat' + str(repeat) + '.png', format='png')

  129. #        #    plt.show()

  130. #            plt.clf()

  131. #            

  132. #            norm_diff = norm_ged_mat - norm_dis_k_mat

  133. #            plt.imshow(norm_diff)

  134. #            plt.colorbar()

  135. #            plt.savefig('results/median_paper/diff_mat_norm_ged_dis_k.clcpc.python_best.monot.elabeled.uhpkernel.y' 

  136. #                        + y + '.repeat' + str(repeat) + '.eps', format='eps', dpi=300)

  137. #            plt.savefig('results/median_paper/diff_mat_norm_ged_dis_k.clcpc.python_best.monot.elabeled.uhpkernel.y' 

  138. #                        + y + '.repeat' + str(repeat) + '.png', format='png')

  139. #        #    plt.show()

  140. #            plt.clf()

  141. #        #    draw_count_bar(norm_diff)

  142. 

  143. 

  144. def median_paper_clcpc_python_bash_cpp():

  145.     """c_vs <= c_vi + c_vr, c_es <= c_ei + c_er with ged computation with 

  146.        python invoking the c++ code by bash command (with updated library).

  147.     """

  148. #    ds = {'name': 'monoterpenoides', 

  149. #          'dataset': '../datasets/monoterpenoides/dataset_10+.ds'}  # node/edge symb

  150. #    _, y_all = loadDataset(ds['dataset'])

  151.     gkernel = 'untilhpathkernel'

  152.     node_label = 'atom'

  153.     edge_label = 'bond_type'

  154.     itr_max = 20

  155.     algo_options = '--threads 6 --initial-solutions 10 --ratio-runs-from-initial-solutions .5'

  156.     params_ged = {'lib': 'gedlib-bash', 'cost': 'CONSTANT', 'method': 'IPFP', 

  157.                 'algo_options': algo_options}

  158.     

  159.     y_all = ['3', '1', '4', '6', '7', '8', '9', '2']

  160.     repeats = 50

  161.     collection_path = os.path.dirname(os.path.realpath(__file__)) + '/cpp_ext/generated_datsets/monoterpenoides/'

  162.     graph_dir = collection_path + 'gxl/'

  163.     

  164.     fn_edit_costs_output = 'results/median_paper/edit_costs_output.txt'

  165. 

  166.     for y in y_all:

  167.         for repeat in range(repeats):

  168.             edit_costs_output_file = open(fn_edit_costs_output, 'a')

  169.             collection_file = collection_path + 'monoterpenoides_' + y + '_' + str(repeat) + '.xml'

  170.             Gn, _ = loadDataset(collection_file, extra_params=graph_dir)

  171.             edit_costs, residual_list, edit_cost_list, dis_k_mat, ged_mat, time_list, \

  172.                 nb_cost_mat_list, coef_dk = fit_GED_to_kernel_distance(Gn, node_label, edge_label, 

  173.                                             gkernel, itr_max, params_ged=params_ged, 

  174.                                             parallel=False)

  175.             total_time = np.sum(time_list)

  176. #            print('\nedit_costs:', edit_costs)

  177. #            print('\nresidual_list:', residual_list)

  178. #            print('\nedit_cost_list:', edit_cost_list)

  179. #            print('\ndistance matrix in kernel space:', dis_k_mat)

  180. #            print('\nged matrix:', ged_mat)

  181. #            print('\ntotal time:', total_time)

  182. #            print('\nnb_cost_mat:', nb_cost_mat_list[-1])

  183.             np.savez('results/median_paper/fit_distance.clcpc.python_bash_cpp.monot.elabeled.uhpkernel.y' 

  184.                      + y + '.repeat' + str(repeat) + '.gm', 

  185.                      edit_costs=edit_costs, 

  186.                      residual_list=residual_list, edit_cost_list=edit_cost_list,

  187.                      dis_k_mat=dis_k_mat, ged_mat=ged_mat, time_list=time_list, 

  188.                      total_time=total_time, nb_cost_mat_list=nb_cost_mat_list, 

  189.                      coef_dk=coef_dk)

  190.             

  191.             for ec in edit_costs:

  192.                 edit_costs_output_file.write(str(ec) + ' ')

  193.             edit_costs_output_file.write('\n')

  194.             edit_costs_output_file.close()

  195.     

  196.     

  197. #    # normalized distance matrices.

  198. #    gmfile = np.load('results/fit_distance.cs_leq_ci_plus_cr.cost_leq_1en2.monot.elabeled.uhpkernel.gm.npz')

  199. #    edit_costs = gmfile['edit_costs']

  200. #    residual_list = gmfile['residual_list']

  201. #    edit_cost_list = gmfile['edit_cost_list']

  202. #    dis_k_mat = gmfile['dis_k_mat']

  203. #    ged_mat = gmfile['ged_mat']

  204. #    total_time = gmfile['total_time']

  205. #    nb_cost_mat_list = gmfile['nb_cost_mat_list']

  206. #    coef_dk = gmfile['coef_dk']

  207.     

  208.             nb_consistent, nb_inconsistent, ratio_consistent = pairwise_substitution_consistence(dis_k_mat, ged_mat)

  209.             print(nb_consistent, nb_inconsistent, ratio_consistent)

  210.                       

  211. #            norm_dis_k_mat = normalize_distance_matrix(dis_k_mat)

  212. #            plt.imshow(norm_dis_k_mat)

  213. #            plt.colorbar()

  214. #            plt.savefig('results/median_paper/norm_dis_k_mat.clcpc.python_bash_cpp.monot.elabeled.uhpkernel.y' 

  215. #                        + y + '.repeat' + str(repeat) + '.eps', format='eps', dpi=300)

  216. #            plt.savefig('results/median_paper/norm_dis_k_mat.clcpc.python_bash_cpp.monot.elabeled.uhpkernel.y' 

  217. #                        + y + '.repeat' + str(repeat) + '.png', format='png')

  218. #        #    plt.show()

  219. #            plt.clf()

  220. #            

  221. #            norm_ged_mat = normalize_distance_matrix(ged_mat)

  222. #            plt.imshow(norm_ged_mat)

  223. #            plt.colorbar()

  224. #            plt.savefig('results/median_paper/norm_ged_mat.clcpc.python_bash_cpp.monot.elabeled.uhpkernel.y' 

  225. #                        + y + '.repeat' + str(repeat) + '.eps', format='eps', dpi=300)

  226. #            plt.savefig('results/median_paper/norm_ged_mat.clcpc.python_bash_cpp.monot.elabeled.uhpkernel.y' 

  227. #                        + y + '.repeat' + str(repeat) + '.png', format='png')

  228. #        #    plt.show()

  229. #            plt.clf()

  230. #            

  231. #            norm_diff = norm_ged_mat - norm_dis_k_mat

  232. #            plt.imshow(norm_diff)

  233. #            plt.colorbar()

  234. #            plt.savefig('results/median_paper/diff_mat_norm_ged_dis_k.clcpc.python_bash_cpp.monot.elabeled.uhpkernel.y' 

  235. #                        + y + '.repeat' + str(repeat) + '.eps', format='eps', dpi=300)

  236. #            plt.savefig('results/median_paper/diff_mat_norm_ged_dis_k.clcpc.python_bash_cpp.monot.elabeled.uhpkernel.y' 

  237. #                        + y + '.repeat' + str(repeat) + '.png', format='png')

  238. #        #    plt.show()

  239. #            plt.clf()

  240. #        #    draw_count_bar(norm_diff)

  241. 

  242. 

  243. 

  244. 

  245. 

  246. def test_cs_leq_ci_plus_cr_python_bash_cpp():

  247.     """c_vs <= c_vi + c_vr, c_es <= c_ei + c_er with ged computation with 

  248.        python invoking the c++ code by bash command (with updated library).

  249.     """

  250.     ds = {'name': 'monoterpenoides', 

  251.           'dataset': '../datasets/monoterpenoides/dataset_10+.ds'}  # node/edge symb

  252.     Gn, y_all = loadDataset(ds['dataset'])

  253. #    Gn = Gn[0:10]

  254.     gkernel = 'untilhpathkernel'

  255.     node_label = 'atom'

  256.     edge_label = 'bond_type'

  257.     itr_max = 10

  258.     algo_options = '--threads 6 --initial-solutions 10 --ratio-runs-from-initial-solutions .5'

  259.     params_ged = {'lib': 'gedlib-bash', 'cost': 'CONSTANT', 'method': 'IPFP', 

  260.                 'algo_options': algo_options}

  261.     edit_costs, residual_list, edit_cost_list, dis_k_mat, ged_mat, time_list, \

  262.         nb_cost_mat_list, coef_dk = fit_GED_to_kernel_distance(Gn, node_label, edge_label, 

  263.                                     gkernel, itr_max, params_ged=params_ged, 

  264.                                     parallel=False)

  265.     total_time = np.sum(time_list)

  266.     print('\nedit_costs:', edit_costs)

  267.     print('\nresidual_list:', residual_list)

  268.     print('\nedit_cost_list:', edit_cost_list)

  269.     print('\ndistance matrix in kernel space:', dis_k_mat)

  270.     print('\nged matrix:', ged_mat)

  271.     print('\ntotal time:', total_time)

  272.     print('\nnb_cost_mat:', nb_cost_mat_list[-1])

  273.     np.savez('results/fit_distance.cs_leq_ci_plus_cr.python_bash_cpp.monot.elabeled.uhpkernel.gm', 

  274.              edit_costs=edit_costs, 

  275.              residual_list=residual_list, edit_cost_list=edit_cost_list,

  276.              dis_k_mat=dis_k_mat, ged_mat=ged_mat, time_list=time_list, 

  277.              total_time=total_time, nb_cost_mat_list=nb_cost_mat_list, 

  278.              coef_dk=coef_dk)

  279.     

  280. #    ds = {'name': 'MUTAG', 'dataset': '../datasets/MUTAG/MUTAG_A.txt',

  281. #          'extra_params': {}}  # node/edge symb

  282. #    Gn, y_all = loadDataset(ds['dataset'], extra_params=ds['extra_params'])

  283. ##    Gn = Gn[0:10]

  284. ##    remove_edges(Gn)

  285. #    gkernel = 'untilhpathkernel'

  286. #    node_label = 'atom'

  287. #    edge_label = 'bond_type'

  288. #    itr_max = 10

  289. #    edit_costs, residual_list, edit_cost_list, dis_k_mat, ged_mat, time_list, \

  290. #        nb_cost_mat_list, coef_dk = fit_GED_to_kernel_distance(Gn, node_label, edge_label, 

  291. #                                                      gkernel, itr_max)

  292. #    total_time = np.sum(time_list)

  293. #    print('\nedit_costs:', edit_costs)

  294. #    print('\nresidual_list:', residual_list)

  295. #    print('\nedit_cost_list:', edit_cost_list)

  296. #    print('\ndistance matrix in kernel space:', dis_k_mat)

  297. #    print('\nged matrix:', ged_mat)

  298. #    print('\ntotal time:', total_time)

  299. #    print('\nnb_cost_mat:', nb_cost_mat_list[-1])

  300. #    np.savez('results/fit_distance.cs_leq_ci_plus_cr.mutag.elabeled.uhpkernel.gm', 

  301. #             edit_costs=edit_costs, 

  302. #             residual_list=residual_list, edit_cost_list=edit_cost_list,

  303. #             dis_k_mat=dis_k_mat, ged_mat=ged_mat, time_list=time_list, 

  304. #             total_time=total_time, nb_cost_mat_list=nb_cost_mat_list, coef_dk)

  305.     

  306.     

  307. #    # normalized distance matrices.

  308. #    gmfile = np.load('results/fit_distance.cs_leq_ci_plus_cr.monot.elabeled.uhpkernel.gm.npz')

  309. #    edit_costs = gmfile['edit_costs']

  310. #    residual_list = gmfile['residual_list']

  311. #    edit_cost_list = gmfile['edit_cost_list']

  312. #    dis_k_mat = gmfile['dis_k_mat']

  313. #    ged_mat = gmfile['ged_mat']

  314. #    total_time = gmfile['total_time']

  315. #    nb_cost_mat_list = gmfile['nb_cost_mat_list']

  316. #    coef_dk = gmfile['coef_dk']

  317.     

  318.     nb_consistent, nb_inconsistent, ratio_consistent = pairwise_substitution_consistence(dis_k_mat, ged_mat)

  319.     print(nb_consistent, nb_inconsistent, ratio_consistent)

  320.     

  321. #    dis_k_sub = pairwise_substitution(dis_k_mat)

  322. #    ged_sub = pairwise_substitution(ged_mat)    

  323. #    np.savez('results/sub_dis_mat.cs_leq_ci_plus_cr.gm', 

  324. #             dis_k_sub=dis_k_sub, ged_sub=ged_sub)

  325.     

  326.     

  327.     norm_dis_k_mat = normalize_distance_matrix(dis_k_mat)

  328.     plt.imshow(norm_dis_k_mat)

  329.     plt.colorbar()

  330.     plt.savefig('results/norm_dis_k_mat.cs_leq_ci_plus_cr.python_bash_cpp.monot.elabeled.uhpkernel' 

  331.                 + '.eps', format='eps', dpi=300)

  332.     plt.savefig('results/norm_dis_k_mat.cs_leq_ci_plus_cr.python_bash_cpp.monot.elabeled.uhpkernel' 

  333.                 + '.png', format='png')

  334. #    plt.show()

  335.     plt.clf()

  336.     

  337.     norm_ged_mat = normalize_distance_matrix(ged_mat)

  338.     plt.imshow(norm_ged_mat)

  339.     plt.colorbar()

  340.     plt.savefig('results/norm_ged_mat.cs_leq_ci_plus_cr.python_bash_cpp.monot.elabeled.uhpkernel' 

  341.                 + '.eps', format='eps', dpi=300)

  342.     plt.savefig('results/norm_ged_mat.cs_leq_ci_plus_cr.python_bash_cpp.monot.elabeled.uhpkernel' 

  343.                 + '.png', format='png')

  344. #    plt.show()

  345.     plt.clf()

  346.     

  347.     norm_diff = norm_ged_mat - norm_dis_k_mat

  348.     plt.imshow(norm_diff)

  349.     plt.colorbar()

  350.     plt.savefig('results/diff_mat_norm_ged_dis_k.cs_leq_ci_plus_cr.python_bash_cpp.monot.elabeled.uhpkernel' 

  351.                 + '.eps', format='eps', dpi=300)

  352.     plt.savefig('results/diff_mat_norm_ged_dis_k.cs_leq_ci_plus_cr.python_bash_cpp.monot.elabeled.uhpkernel' 

  353.                 + '.png', format='png')

  354. #    plt.show()

  355.     plt.clf()

  356. #    draw_count_bar(norm_diff)

  357. 

  358. 

  359. def test_anycosts():

  360.     ds = {'name': 'MUTAG', 'dataset': '../datasets/MUTAG/MUTAG_A.txt',

  361.           'extra_params': {}}  # node/edge symb

  362.     Gn, y_all = loadDataset(ds['dataset'], extra_params=ds['extra_params'])

  363. #    Gn = Gn[0:10]

  364.     remove_edges(Gn)

  365.     gkernel = 'marginalizedkernel'

  366.     itr_max = 10

  367.     edit_costs, residual_list, edit_cost_list, dis_k_mat, ged_mat, time_list, \

  368.         nb_cost_mat_list, coef_dk = fit_GED_to_kernel_distance(Gn, gkernel, itr_max)

  369.     total_time = np.sum(time_list)

  370.     print('\nedit_costs:', edit_costs)

  371.     print('\nresidual_list:', residual_list)

  372.     print('\nedit_cost_list:', edit_cost_list)

  373.     print('\ndistance matrix in kernel space:', dis_k_mat)

  374.     print('\nged matrix:', ged_mat)

  375.     print('\ntotal time:', total_time)

  376.     print('\nnb_cost_mat:', nb_cost_mat_list[-1])

  377.     np.savez('results/fit_distance.any_costs.gm', edit_costs=edit_costs, 

  378.              residual_list=residual_list, edit_cost_list=edit_cost_list,

  379.              dis_k_mat=dis_k_mat, ged_mat=ged_mat, time_list=time_list, 

  380.              total_time=total_time, nb_cost_mat_list=nb_cost_mat_list)

  381.     

  382. #    # normalized distance matrices.

  383. #    gmfile = np.load('results/fit_distance.any_costs.gm.npz')

  384. #    edit_costs = gmfile['edit_costs']

  385. #    residual_list = gmfile['residual_list']

  386. #    edit_cost_list = gmfile['edit_cost_list']

  387. #    dis_k_mat = gmfile['dis_k_mat']

  388. #    ged_mat = gmfile['ged_mat']

  389. #    total_time = gmfile['total_time']

  390. ##    nb_cost_mat_list = gmfile['nb_cost_mat_list']

  391.     

  392.     norm_dis_k_mat = normalize_distance_matrix(dis_k_mat)

  393.     plt.imshow(norm_dis_k_mat)

  394.     plt.colorbar()

  395.     plt.savefig('results/norm_dis_k_mat.any_costs' + '.eps', format='eps', dpi=300)

  396. #    plt.savefig('results/norm_dis_k_mat.any_costs' + '.png', format='png')

  397. #    plt.show()

  398.     plt.clf()

  399.     

  400.     norm_ged_mat = normalize_distance_matrix(ged_mat)

  401.     plt.imshow(norm_ged_mat)

  402.     plt.colorbar()

  403.     plt.savefig('results/norm_ged_mat.any_costs' + '.eps', format='eps', dpi=300)

  404. #    plt.savefig('results/norm_ged_mat.any_costs' + '.png', format='png')

  405. #    plt.show()

  406.     plt.clf()

  407.     

  408.     norm_diff = norm_ged_mat - norm_dis_k_mat

  409.     plt.imshow(norm_diff)

  410.     plt.colorbar()

  411.     plt.savefig('results/diff_mat_norm_ged_dis_k.any_costs' + '.eps', format='eps', dpi=300)

  412. #    plt.savefig('results/diff_mat_norm_ged_dis_k.any_costs' + '.png', format='png')

  413. #    plt.show()

  414.     plt.clf()

  415. #    draw_count_bar(norm_diff)

  416.     

  417. 

  418. def test_cs_leq_ci_plus_cr():

  419.     """c_vs <= c_vi + c_vr, c_es <= c_ei + c_er

  420.     """

  421.     ds = {'name': 'monoterpenoides', 

  422.           'dataset': '../datasets/monoterpenoides/dataset_10+.ds'}  # node/edge symb

  423.     Gn, y_all = loadDataset(ds['dataset'])

  424. #    Gn = Gn[0:10]

  425.     gkernel = 'untilhpathkernel'

  426.     node_label = 'atom'

  427.     edge_label = 'bond_type'

  428.     itr_max = 10

  429.     edit_costs, residual_list, edit_cost_list, dis_k_mat, ged_mat, time_list, \

  430.         nb_cost_mat_list, coef_dk = fit_GED_to_kernel_distance(Gn, node_label, edge_label, 

  431.                                                       gkernel, itr_max,

  432.                                                       fitkernel='gaussian')

  433.     total_time = np.sum(time_list)

  434.     print('\nedit_costs:', edit_costs)

  435.     print('\nresidual_list:', residual_list)

  436.     print('\nedit_cost_list:', edit_cost_list)

  437.     print('\ndistance matrix in kernel space:', dis_k_mat)

  438.     print('\nged matrix:', ged_mat)

  439.     print('\ntotal time:', total_time)

  440.     print('\nnb_cost_mat:', nb_cost_mat_list[-1])

  441.     np.savez('results/fit_distance.cs_leq_ci_plus_cr.gaussian.cost_leq_1en2.monot.elabeled.uhpkernel.gm', 

  442.              edit_costs=edit_costs, 

  443.              residual_list=residual_list, edit_cost_list=edit_cost_list,

  444.              dis_k_mat=dis_k_mat, ged_mat=ged_mat, time_list=time_list, 

  445.              total_time=total_time, nb_cost_mat_list=nb_cost_mat_list, 

  446.              coef_dk=coef_dk)

  447.     

  448. #    ds = {'name': 'MUTAG', 'dataset': '../datasets/MUTAG/MUTAG_A.txt',

  449. #          'extra_params': {}}  # node/edge symb

  450. #    Gn, y_all = loadDataset(ds['dataset'], extra_params=ds['extra_params'])

  451. ##    Gn = Gn[0:10]

  452. ##    remove_edges(Gn)

  453. #    gkernel = 'untilhpathkernel'

  454. #    node_label = 'atom'

  455. #    edge_label = 'bond_type'

  456. #    itr_max = 10

  457. #    edit_costs, residual_list, edit_cost_list, dis_k_mat, ged_mat, time_list, \

  458. #        nb_cost_mat_list, coef_dk = fit_GED_to_kernel_distance(Gn, node_label, edge_label, 

  459. #                                                      gkernel, itr_max)

  460. #    total_time = np.sum(time_list)

  461. #    print('\nedit_costs:', edit_costs)

  462. #    print('\nresidual_list:', residual_list)

  463. #    print('\nedit_cost_list:', edit_cost_list)

  464. #    print('\ndistance matrix in kernel space:', dis_k_mat)

  465. #    print('\nged matrix:', ged_mat)

  466. #    print('\ntotal time:', total_time)

  467. #    print('\nnb_cost_mat:', nb_cost_mat_list[-1])

  468. #    np.savez('results/fit_distance.cs_leq_ci_plus_cr.cost_leq_1en2.mutag.elabeled.uhpkernel.gm', 

  469. #             edit_costs=edit_costs, 

  470. #             residual_list=residual_list, edit_cost_list=edit_cost_list,

  471. #             dis_k_mat=dis_k_mat, ged_mat=ged_mat, time_list=time_list, 

  472. #             total_time=total_time, nb_cost_mat_list=nb_cost_mat_list, coef_dk)

  473.     

  474.     

  475. #    # normalized distance matrices.

  476. #    gmfile = np.load('results/fit_distance.cs_leq_ci_plus_cr.cost_leq_1en2.monot.elabeled.uhpkernel.gm.npz')

  477. #    edit_costs = gmfile['edit_costs']

  478. #    residual_list = gmfile['residual_list']

  479. #    edit_cost_list = gmfile['edit_cost_list']

  480. #    dis_k_mat = gmfile['dis_k_mat']

  481. #    ged_mat = gmfile['ged_mat']

  482. #    total_time = gmfile['total_time']

  483. #    nb_cost_mat_list = gmfile['nb_cost_mat_list']

  484. #    coef_dk = gmfile['coef_dk']

  485.     

  486.     nb_consistent, nb_inconsistent, ratio_consistent = pairwise_substitution_consistence(dis_k_mat, ged_mat)

  487.     print(nb_consistent, nb_inconsistent, ratio_consistent)

  488.     

  489. #    dis_k_sub = pairwise_substitution(dis_k_mat)

  490. #    ged_sub = pairwise_substitution(ged_mat)    

  491. #    np.savez('results/sub_dis_mat.cs_leq_ci_plus_cr.cost_leq_1en2.gm', 

  492. #             dis_k_sub=dis_k_sub, ged_sub=ged_sub)

  493.     

  494.     

  495.     norm_dis_k_mat = normalize_distance_matrix(dis_k_mat)

  496.     plt.imshow(norm_dis_k_mat)

  497.     plt.colorbar()

  498.     plt.savefig('results/norm_dis_k_mat.cs_leq_ci_plus_cr.gaussian.cost_leq_1en2.monot.elabeled.uhpkernel' 

  499.                 + '.eps', format='eps', dpi=300)

  500.     plt.savefig('results/norm_dis_k_mat.cs_leq_ci_plus_cr.gaussian.cost_leq_1en2.monot.elabeled.uhpkernel' 

  501.                 + '.png', format='png')

  502. #    plt.show()

  503.     plt.clf()

  504.     

  505.     norm_ged_mat = normalize_distance_matrix(ged_mat)

  506.     plt.imshow(norm_ged_mat)

  507.     plt.colorbar()

  508.     plt.savefig('results/norm_ged_mat.cs_leq_ci_plus_cr.gaussian.cost_leq_1en2.monot.elabeled.uhpkernel' 

  509.                 + '.eps', format='eps', dpi=300)

  510.     plt.savefig('results/norm_ged_mat.cs_leq_ci_plus_cr.gaussian.cost_leq_1en2.monot.elabeled.uhpkernel' 

  511.                 + '.png', format='png')

  512. #    plt.show()

  513.     plt.clf()

  514.     

  515.     norm_diff = norm_ged_mat - norm_dis_k_mat

  516.     plt.imshow(norm_diff)

  517.     plt.colorbar()

  518.     plt.savefig('results/diff_mat_norm_ged_dis_k.cs_leq_ci_plus_cr.gaussian.cost_leq_1en2.monot.elabeled.uhpkernel' 

  519.                 + '.eps', format='eps', dpi=300)

  520.     plt.savefig('results/diff_mat_norm_ged_dis_k.cs_leq_ci_plus_cr.gaussian.cost_leq_1en2.monot.elabeled.uhpkernel' 

  521.                 + '.png', format='png')

  522. #    plt.show()

  523.     plt.clf()

  524. #    draw_count_bar(norm_diff)

  525.     

  526.     

  527. def test_unfitted():

  528.     """unfitted.

  529.     """  

  530.     from fitDistance import compute_geds

  531.     from utils import kernel_distance_matrix

  532.     ds = {'name': 'monoterpenoides', 

  533.           'dataset': '../datasets/monoterpenoides/dataset_10+.ds'}  # node/edge symb

  534.     Gn, y_all = loadDataset(ds['dataset'])

  535. #    Gn = Gn[0:10]

  536.     gkernel = 'untilhpathkernel'

  537.     node_label = 'atom'

  538.     edge_label = 'bond_type'

  539.         

  540. 

  541. #    ds = {'name': 'MUTAG', 'dataset': '../datasets/MUTAG/MUTAG_A.txt',

  542. #          'extra_params': {}}  # node/edge symb

  543. #    Gn, y_all = loadDataset(ds['dataset'], extra_params=ds['extra_params'])

  544. ##    Gn = Gn[0:10]

  545. ##    remove_edges(Gn)

  546. #    gkernel = 'marginalizedkernel'

  547. 

  548.     dis_k_mat, _, _, _ = kernel_distance_matrix(Gn, node_label, edge_label, gkernel=gkernel)

  549.     ged_all, ged_mat, n_edit_operations = compute_geds(Gn, [3, 3, 1, 3, 3, 1], 

  550.             [0, 1, 2, 3, 4, 5], parallel=True)

  551.     print('\ndistance matrix in kernel space:', dis_k_mat)

  552.     print('\nged matrix:', ged_mat)

  553. #    np.savez('results/fit_distance.cs_leq_ci_plus_cr.cost_leq_1en2.gm', edit_costs=edit_costs, 

  554. #             residual_list=residual_list, edit_cost_list=edit_cost_list,

  555. #             dis_k_mat=dis_k_mat, ged_mat=ged_mat, time_list=time_list, 

  556. #             total_time=total_time, nb_cost_mat_list=nb_cost_mat_list) 

  557.     

  558.     # normalized distance matrices.

  559. #    gmfile = np.load('results/fit_distance.cs_leq_ci_plus_cr.cost_leq_1en3.gm.npz')

  560. #    edit_costs = gmfile['edit_costs']

  561. #    residual_list = gmfile['residual_list']

  562. #    edit_cost_list = gmfile['edit_cost_list']

  563. #    dis_k_mat = gmfile['dis_k_mat']

  564. #    ged_mat = gmfile['ged_mat']

  565. #    total_time = gmfile['total_time']

  566. #    nb_cost_mat_list = gmfile['nb_cost_mat_list']

  567.     

  568.     nb_consistent, nb_inconsistent, ratio_consistent = pairwise_substitution_consistence(dis_k_mat, ged_mat)

  569.     print(nb_consistent, nb_inconsistent, ratio_consistent)

  570.     

  571.     norm_dis_k_mat = normalize_distance_matrix(dis_k_mat)

  572.     plt.imshow(norm_dis_k_mat)

  573.     plt.colorbar()

  574.     plt.savefig('results/norm_dis_k_mat.unfitted.MUTAG' + '.eps', format='eps', dpi=300)

  575.     plt.savefig('results/norm_dis_k_mat.unfitted.MUTAG' + '.png', format='png')

  576. #    plt.show()

  577.     plt.clf()

  578.     

  579.     norm_ged_mat = normalize_distance_matrix(ged_mat)

  580.     plt.imshow(norm_ged_mat)

  581.     plt.colorbar()

  582.     plt.savefig('results/norm_ged_mat.unfitted.MUTAG' + '.eps', format='eps', dpi=300)

  583.     plt.savefig('results/norm_ged_mat.unfitted.MUTAG' + '.png', format='png')

  584. #    plt.show()

  585.     plt.clf()

  586.     

  587.     norm_diff = norm_ged_mat - norm_dis_k_mat

  588.     plt.imshow(norm_diff)

  589.     plt.colorbar()

  590.     plt.savefig('results/diff_mat_norm_ged_dis_k.unfitted.MUTAG' + '.eps', format='eps', dpi=300)

  591.     plt.savefig('results/diff_mat_norm_ged_dis_k.unfitted.MUTAG' + '.png', format='png')

  592. #    plt.show()

  593.     plt.clf()

  594.     draw_count_bar(norm_diff)

  595.     

  596.     

  597. def pairwise_substitution_consistence(mat1, mat2):

  598.     """

  599.     """

  600.     nb_consistent = 0

  601.     nb_inconsistent = 0

  602.     # the matrix is considered symmetric.

  603.     upper_tri1 = mat1[np.triu_indices_from(mat1)]

  604.     upper_tri2 = mat2[np.tril_indices_from(mat2)]

  605.     for i in tqdm(range(len(upper_tri1)), desc='computing consistence', file=sys.stdout):

  606.         for j in range(i, len(upper_tri1)):

  607.             if np.sign(upper_tri1[i] - upper_tri1[j]) == np.sign(upper_tri2[i] - upper_tri2[j]):

  608.                 nb_consistent += 1

  609.             else:

  610.                 nb_inconsistent += 1

  611.     return nb_consistent, nb_inconsistent, nb_consistent / (nb_consistent + nb_inconsistent)

  612. 

  613. 

  614. def pairwise_substitution(mat):

  615.     # the matrix is considered symmetric.

  616.     upper_tri = mat[np.triu_indices_from(mat)]

  617.     sub_list = []

  618.     for i in tqdm(range(len(upper_tri)), desc='computing', file=sys.stdout):

  619.         for j in range(i, len(upper_tri)):

  620.             sub_list.append(upper_tri[i] - upper_tri[j])

  621.     return sub_list

  622.     

  623.     

  624. def draw_count_bar(norm_diff):

  625.     import pandas

  626.     from collections import Counter, OrderedDict

  627.     norm_diff_cnt = norm_diff.flatten()

  628.     norm_diff_cnt = norm_diff_cnt * 10

  629.     norm_diff_cnt = np.floor(norm_diff_cnt)

  630.     norm_diff_cnt = Counter(norm_diff_cnt)

  631.     norm_diff_cnt = OrderedDict(sorted(norm_diff_cnt.items()))

  632.     df = pandas.DataFrame.from_dict(norm_diff_cnt, orient='index')

  633.     df.plot(kind='bar')

  634.     

  635.     

  636. if __name__ == '__main__':

  637. #    test_anycosts()

  638. #    test_cs_leq_ci_plus_cr()

  639. #    test_unfitted()

  640.     

  641. #    test_cs_leq_ci_plus_cr_python_bash_cpp()

  642. #    median_paper_clcpc_python_bash_cpp()

  643. #    median_paper_clcpc_python_best()

  644. 

  645. #    x = np.array([[1,2,3],[4,5,6],[7,8,9]])

  646. #    xx = pairwise_substitution(x)

  647.     

  648.     test_update_costs()