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

302 lines
12 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. import sys

  13. sys.path.insert(0, "../")

  14. from pygraph.utils.graphfiles import loadDataset

  15. from utils import remove_edges

  16. from fitDistance import fit_GED_to_kernel_distance

  17. from utils import normalize_distance_matrix

  18. 

  19. def test_anycosts():

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

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

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

  23. #    Gn = Gn[0:10]

  24.     remove_edges(Gn)

  25.     gkernel = 'marginalizedkernel'

  26.     itr_max = 10

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

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

  29.     total_time = np.sum(time_list)

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

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

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

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

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

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

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

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

  38.              residual_list=residual_list, edit_cost_list=edit_cost_list,

  39.              dis_k_mat=dis_k_mat, ged_mat=ged_mat, time_list=time_list, 

  40.              total_time=total_time, nb_cost_mat_list=nb_cost_mat_list)

  41.     

  42. #    # normalized distance matrices.

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

  44. #    edit_costs = gmfile['edit_costs']

  45. #    residual_list = gmfile['residual_list']

  46. #    edit_cost_list = gmfile['edit_cost_list']

  47. #    dis_k_mat = gmfile['dis_k_mat']

  48. #    ged_mat = gmfile['ged_mat']

  49. #    total_time = gmfile['total_time']

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

  51.     

  52.     norm_dis_k_mat = normalize_distance_matrix(dis_k_mat)

  53.     plt.imshow(norm_dis_k_mat)

  54.     plt.colorbar()

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

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

  57. #    plt.show()

  58.     plt.clf()

  59.     

  60.     norm_ged_mat = normalize_distance_matrix(ged_mat)

  61.     plt.imshow(norm_ged_mat)

  62.     plt.colorbar()

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

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

  65. #    plt.show()

  66.     plt.clf()

  67.     

  68.     norm_diff = norm_ged_mat - norm_dis_k_mat

  69.     plt.imshow(norm_diff)

  70.     plt.colorbar()

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

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

  73. #    plt.show()

  74.     plt.clf()

  75. #    draw_count_bar(norm_diff)

  76.     

  77. 

  78. def test_cs_leq_ci_plus_cr():

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

  80.     """

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

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

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

  84. #    Gn = Gn[0:10]

  85.     gkernel = 'untilhpathkernel'

  86.     node_label = 'atom'

  87.     edge_label = 'bond_type'

  88.     itr_max = 10

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

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

  91.                                                       gkernel, itr_max,

  92.                                                       fitkernel='gaussian')

  93.     total_time = np.sum(time_list)

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

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

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

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

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

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

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

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

  102.              edit_costs=edit_costs, 

  103.              residual_list=residual_list, edit_cost_list=edit_cost_list,

  104.              dis_k_mat=dis_k_mat, ged_mat=ged_mat, time_list=time_list, 

  105.              total_time=total_time, nb_cost_mat_list=nb_cost_mat_list, 

  106.              coef_dk=coef_dk)

  107.     

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

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

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

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

  112. ##    remove_edges(Gn)

  113. #    gkernel = 'untilhpathkernel'

  114. #    node_label = 'atom'

  115. #    edge_label = 'bond_type'

  116. #    itr_max = 10

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

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

  119. #                                                      gkernel, itr_max)

  120. #    total_time = np.sum(time_list)

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

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

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

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

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

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

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

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

  129. #             edit_costs=edit_costs, 

  130. #             residual_list=residual_list, edit_cost_list=edit_cost_list,

  131. #             dis_k_mat=dis_k_mat, ged_mat=ged_mat, time_list=time_list, 

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

  133.     

  134.     

  135. #    # normalized distance matrices.

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

  137. #    edit_costs = gmfile['edit_costs']

  138. #    residual_list = gmfile['residual_list']

  139. #    edit_cost_list = gmfile['edit_cost_list']

  140. #    dis_k_mat = gmfile['dis_k_mat']

  141. #    ged_mat = gmfile['ged_mat']

  142. #    total_time = gmfile['total_time']

  143. #    nb_cost_mat_list = gmfile['nb_cost_mat_list']

  144. #    coef_dk = gmfile['coef_dk']

  145.     

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

  147.     print(nb_consistent, nb_inconsistent, ratio_consistent)

  148.     

  149. #    dis_k_sub = pairwise_substitution(dis_k_mat)

  150. #    ged_sub = pairwise_substitution(ged_mat)    

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

  152. #             dis_k_sub=dis_k_sub, ged_sub=ged_sub)

  153.     

  154.     

  155.     norm_dis_k_mat = normalize_distance_matrix(dis_k_mat)

  156.     plt.imshow(norm_dis_k_mat)

  157.     plt.colorbar()

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

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

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

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

  162. #    plt.show()

  163.     plt.clf()

  164.     

  165.     norm_ged_mat = normalize_distance_matrix(ged_mat)

  166.     plt.imshow(norm_ged_mat)

  167.     plt.colorbar()

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

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

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

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

  172. #    plt.show()

  173.     plt.clf()

  174.     

  175.     norm_diff = norm_ged_mat - norm_dis_k_mat

  176.     plt.imshow(norm_diff)

  177.     plt.colorbar()

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

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

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

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

  182. #    plt.show()

  183.     plt.clf()

  184. #    draw_count_bar(norm_diff)

  185.     

  186.     

  187. def test_unfitted():

  188.     """unfitted.

  189.     """  

  190.     from fitDistance import compute_geds

  191.     from utils import kernel_distance_matrix

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

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

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

  195. #    Gn = Gn[0:10]

  196.     gkernel = 'untilhpathkernel'

  197.     node_label = 'atom'

  198.     edge_label = 'bond_type'

  199.         

  200. 

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

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

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

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

  205. ##    remove_edges(Gn)

  206. #    gkernel = 'marginalizedkernel'

  207. 

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

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

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

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

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

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

  214. #             residual_list=residual_list, edit_cost_list=edit_cost_list,

  215. #             dis_k_mat=dis_k_mat, ged_mat=ged_mat, time_list=time_list, 

  216. #             total_time=total_time, nb_cost_mat_list=nb_cost_mat_list) 

  217.     

  218.     # normalized distance matrices.

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

  220. #    edit_costs = gmfile['edit_costs']

  221. #    residual_list = gmfile['residual_list']

  222. #    edit_cost_list = gmfile['edit_cost_list']

  223. #    dis_k_mat = gmfile['dis_k_mat']

  224. #    ged_mat = gmfile['ged_mat']

  225. #    total_time = gmfile['total_time']

  226. #    nb_cost_mat_list = gmfile['nb_cost_mat_list']

  227.     

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

  229.     print(nb_consistent, nb_inconsistent, ratio_consistent)

  230.     

  231.     norm_dis_k_mat = normalize_distance_matrix(dis_k_mat)

  232.     plt.imshow(norm_dis_k_mat)

  233.     plt.colorbar()

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

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

  236. #    plt.show()

  237.     plt.clf()

  238.     

  239.     norm_ged_mat = normalize_distance_matrix(ged_mat)

  240.     plt.imshow(norm_ged_mat)

  241.     plt.colorbar()

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

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

  244. #    plt.show()

  245.     plt.clf()

  246.     

  247.     norm_diff = norm_ged_mat - norm_dis_k_mat

  248.     plt.imshow(norm_diff)

  249.     plt.colorbar()

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

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

  252. #    plt.show()

  253.     plt.clf()

  254.     draw_count_bar(norm_diff)

  255.     

  256.     

  257. def pairwise_substitution_consistence(mat1, mat2):

  258.     """

  259.     """

  260.     nb_consistent = 0

  261.     nb_inconsistent = 0

  262.     # the matrix is considered symmetric.

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

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

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

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

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

  268.                 nb_consistent += 1

  269.             else:

  270.                 nb_inconsistent += 1

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

  272. 

  273. 

  274. def pairwise_substitution(mat):

  275.     # the matrix is considered symmetric.

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

  277.     sub_list = []

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

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

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

  281.     return sub_list

  282.     

  283.     

  284. def draw_count_bar(norm_diff):

  285.     import pandas

  286.     from collections import Counter, OrderedDict

  287.     norm_diff_cnt = norm_diff.flatten()

  288.     norm_diff_cnt = norm_diff_cnt * 10

  289.     norm_diff_cnt = np.floor(norm_diff_cnt)

  290.     norm_diff_cnt = Counter(norm_diff_cnt)

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

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

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

  294.     

  295.     

  296. if __name__ == '__main__':

  297. #    test_anycosts()

  298. #    test_cs_leq_ci_plus_cr()

  299.     test_unfitted()

  300.     

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

  302. #    xx = pairwise_substitution(x)