From 5bdfb68551234e3e330377dc507e5d6815e431a7 Mon Sep 17 00:00:00 2001 From: jajupmochi Date: Fri, 16 Oct 2020 17:20:12 +0200 Subject: [PATCH] Add test for four random walk kernel classes. --- gklearn/tests/test_graph_kernels.py | 480 ++++++++++++++++++------------------ 1 file changed, 240 insertions(+), 240 deletions(-) diff --git a/gklearn/tests/test_graph_kernels.py b/gklearn/tests/test_graph_kernels.py index 274465c..4fbbbe7 100644 --- a/gklearn/tests/test_graph_kernels.py +++ b/gklearn/tests/test_graph_kernels.py @@ -52,63 +52,63 @@ def chooseDataset(ds_name): return dataset -# @pytest.mark.parametrize('ds_name', ['Alkane', 'AIDS']) -# @pytest.mark.parametrize('weight,compute_method', [(0.01, 'geo'), (1, 'exp')]) -# @pytest.mark.parametrize('parallel', ['imap_unordered', None]) -# def test_CommonWalk(ds_name, parallel, weight, compute_method): -# """Test common walk kernel. -# """ -# from gklearn.kernels import CommonWalk -# import networkx as nx -# -# dataset = chooseDataset(ds_name) -# dataset.load_graphs([g for g in dataset.graphs if nx.number_of_nodes(g) > 1]) -# -# try: -# graph_kernel = CommonWalk(node_labels=dataset.node_labels, -# edge_labels=dataset.edge_labels, -# ds_infos=dataset.get_dataset_infos(keys=['directed']), -# weight=weight, -# compute_method=compute_method) -# gram_matrix, run_time = graph_kernel.compute(dataset.graphs, -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) +@pytest.mark.parametrize('ds_name', ['Alkane', 'AIDS']) +@pytest.mark.parametrize('weight,compute_method', [(0.01, 'geo'), (1, 'exp')]) +@pytest.mark.parametrize('parallel', ['imap_unordered', None]) +def test_CommonWalk(ds_name, parallel, weight, compute_method): + """Test common walk kernel. + """ + from gklearn.kernels import CommonWalk + import networkx as nx + + dataset = chooseDataset(ds_name) + dataset.load_graphs([g for g in dataset.graphs if nx.number_of_nodes(g) > 1]) + + try: + graph_kernel = CommonWalk(node_labels=dataset.node_labels, + edge_labels=dataset.edge_labels, + ds_infos=dataset.get_dataset_infos(keys=['directed']), + weight=weight, + compute_method=compute_method) + gram_matrix, run_time = graph_kernel.compute(dataset.graphs, + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# except Exception as exception: -# assert False, exception -# -# -# @pytest.mark.parametrize('ds_name', ['Alkane', 'AIDS']) -# @pytest.mark.parametrize('remove_totters', [False]) #[True, False]) -# @pytest.mark.parametrize('parallel', ['imap_unordered', None]) -# def test_Marginalized(ds_name, parallel, remove_totters): -# """Test marginalized kernel. -# """ -# from gklearn.kernels import Marginalized -# -# dataset = chooseDataset(ds_name) -# -# try: -# graph_kernel = Marginalized(node_labels=dataset.node_labels, -# edge_labels=dataset.edge_labels, -# ds_infos=dataset.get_dataset_infos(keys=['directed']), -# p_quit=0.5, -# n_iteration=2, -# remove_totters=remove_totters) -# gram_matrix, run_time = graph_kernel.compute(dataset.graphs, -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + except Exception as exception: + assert False, exception + + +@pytest.mark.parametrize('ds_name', ['Alkane', 'AIDS']) +@pytest.mark.parametrize('remove_totters', [False]) #[True, False]) +@pytest.mark.parametrize('parallel', ['imap_unordered', None]) +def test_Marginalized(ds_name, parallel, remove_totters): + """Test marginalized kernel. + """ + from gklearn.kernels import Marginalized + + dataset = chooseDataset(ds_name) + + try: + graph_kernel = Marginalized(node_labels=dataset.node_labels, + edge_labels=dataset.edge_labels, + ds_infos=dataset.get_dataset_infos(keys=['directed']), + p_quit=0.5, + n_iteration=2, + remove_totters=remove_totters) + gram_matrix, run_time = graph_kernel.compute(dataset.graphs, + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# except Exception as exception: -# assert False, exception -# -# + except Exception as exception: + assert False, exception + + @pytest.mark.parametrize('ds_name', ['Acyclic']) @pytest.mark.parametrize('parallel', ['imap_unordered', None]) def test_SylvesterEquation(ds_name, parallel): @@ -239,203 +239,203 @@ def test_SpectralDecomposition(ds_name, sub_kernel, parallel): except Exception as exception: assert False, exception -# -# -# # @pytest.mark.parametrize( -# # 'compute_method,ds_name,sub_kernel', -# # [ -# # ('sylvester', 'Alkane', None), -# # ('conjugate', 'Alkane', None), -# # ('conjugate', 'AIDS', None), -# # ('fp', 'Alkane', None), -# # ('fp', 'AIDS', None), -# # ('spectral', 'Alkane', 'exp'), -# # ('spectral', 'Alkane', 'geo'), -# # ] -# # ) -# # @pytest.mark.parametrize('parallel', ['imap_unordered', None]) -# # def test_RandomWalk(ds_name, compute_method, sub_kernel, parallel): -# # """Test random walk kernel. -# # """ -# # from gklearn.kernels import RandomWalk -# # from gklearn.utils.kernels import deltakernel, gaussiankernel, kernelproduct -# # import functools -# # -# # dataset = chooseDataset(ds_name) + + +# @pytest.mark.parametrize( +# 'compute_method,ds_name,sub_kernel', +# [ +# ('sylvester', 'Alkane', None), +# ('conjugate', 'Alkane', None), +# ('conjugate', 'AIDS', None), +# ('fp', 'Alkane', None), +# ('fp', 'AIDS', None), +# ('spectral', 'Alkane', 'exp'), +# ('spectral', 'Alkane', 'geo'), +# ] +# ) +# @pytest.mark.parametrize('parallel', ['imap_unordered', None]) +# def test_RandomWalk(ds_name, compute_method, sub_kernel, parallel): +# """Test random walk kernel. +# """ +# from gklearn.kernels import RandomWalk +# from gklearn.utils.kernels import deltakernel, gaussiankernel, kernelproduct +# import functools +# +# dataset = chooseDataset(ds_name) -# # mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) -# # sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} -# # # try: -# # graph_kernel = RandomWalk(node_labels=dataset.node_labels, -# # node_attrs=dataset.node_attrs, -# # edge_labels=dataset.edge_labels, -# # edge_attrs=dataset.edge_attrs, -# # ds_infos=dataset.get_dataset_infos(keys=['directed']), -# # compute_method=compute_method, -# # weight=1e-3, -# # p=None, -# # q=None, -# # edge_weight=None, -# # node_kernels=sub_kernels, -# # edge_kernels=sub_kernels, -# # sub_kernel=sub_kernel) -# # gram_matrix, run_time = graph_kernel.compute(dataset.graphs, -# # parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# # kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], -# # parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# # kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], -# # parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) +# mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) +# sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} +# # try: +# graph_kernel = RandomWalk(node_labels=dataset.node_labels, +# node_attrs=dataset.node_attrs, +# edge_labels=dataset.edge_labels, +# edge_attrs=dataset.edge_attrs, +# ds_infos=dataset.get_dataset_infos(keys=['directed']), +# compute_method=compute_method, +# weight=1e-3, +# p=None, +# q=None, +# edge_weight=None, +# node_kernels=sub_kernels, +# edge_kernels=sub_kernels, +# sub_kernel=sub_kernel) +# gram_matrix, run_time = graph_kernel.compute(dataset.graphs, +# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) +# kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], +# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) +# kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], +# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# # except Exception as exception: -# # assert False, exception +# except Exception as exception: +# assert False, exception -# -# @pytest.mark.parametrize('ds_name', ['Alkane', 'Acyclic', 'Letter-med', 'AIDS', 'Fingerprint']) -# @pytest.mark.parametrize('parallel', ['imap_unordered', None]) -# def test_ShortestPath(ds_name, parallel): -# """Test shortest path kernel. -# """ -# from gklearn.kernels import ShortestPath -# from gklearn.utils.kernels import deltakernel, gaussiankernel, kernelproduct -# import functools -# -# dataset = chooseDataset(ds_name) -# -# mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) -# sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} -# try: -# graph_kernel = ShortestPath(node_labels=dataset.node_labels, -# node_attrs=dataset.node_attrs, -# ds_infos=dataset.get_dataset_infos(keys=['directed']), -# node_kernels=sub_kernels) -# gram_matrix, run_time = graph_kernel.compute(dataset.graphs, -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + +@pytest.mark.parametrize('ds_name', ['Alkane', 'Acyclic', 'Letter-med', 'AIDS', 'Fingerprint']) +@pytest.mark.parametrize('parallel', ['imap_unordered', None]) +def test_ShortestPath(ds_name, parallel): + """Test shortest path kernel. + """ + from gklearn.kernels import ShortestPath + from gklearn.utils.kernels import deltakernel, gaussiankernel, kernelproduct + import functools + + dataset = chooseDataset(ds_name) + + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + try: + graph_kernel = ShortestPath(node_labels=dataset.node_labels, + node_attrs=dataset.node_attrs, + ds_infos=dataset.get_dataset_infos(keys=['directed']), + node_kernels=sub_kernels) + gram_matrix, run_time = graph_kernel.compute(dataset.graphs, + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# except Exception as exception: -# assert False, exception + except Exception as exception: + assert False, exception -# #@pytest.mark.parametrize('ds_name', ['Alkane', 'Acyclic', 'Letter-med', 'AIDS', 'Fingerprint']) -# @pytest.mark.parametrize('ds_name', ['Alkane', 'Acyclic', 'Letter-med', 'AIDS', 'Fingerprint', 'Fingerprint_edge', 'Cuneiform']) -# @pytest.mark.parametrize('parallel', ['imap_unordered', None]) -# def test_StructuralSP(ds_name, parallel): -# """Test structural shortest path kernel. -# """ -# from gklearn.kernels import StructuralSP -# from gklearn.utils.kernels import deltakernel, gaussiankernel, kernelproduct -# import functools -# -# dataset = chooseDataset(ds_name) -# -# mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) -# sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} -# try: -# graph_kernel = StructuralSP(node_labels=dataset.node_labels, -# edge_labels=dataset.edge_labels, -# node_attrs=dataset.node_attrs, -# edge_attrs=dataset.edge_attrs, -# ds_infos=dataset.get_dataset_infos(keys=['directed']), -# node_kernels=sub_kernels, -# edge_kernels=sub_kernels) -# gram_matrix, run_time = graph_kernel.compute(dataset.graphs, -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) +#@pytest.mark.parametrize('ds_name', ['Alkane', 'Acyclic', 'Letter-med', 'AIDS', 'Fingerprint']) +@pytest.mark.parametrize('ds_name', ['Alkane', 'Acyclic', 'Letter-med', 'AIDS', 'Fingerprint', 'Fingerprint_edge', 'Cuneiform']) +@pytest.mark.parametrize('parallel', ['imap_unordered', None]) +def test_StructuralSP(ds_name, parallel): + """Test structural shortest path kernel. + """ + from gklearn.kernels import StructuralSP + from gklearn.utils.kernels import deltakernel, gaussiankernel, kernelproduct + import functools + + dataset = chooseDataset(ds_name) + + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + try: + graph_kernel = StructuralSP(node_labels=dataset.node_labels, + edge_labels=dataset.edge_labels, + node_attrs=dataset.node_attrs, + edge_attrs=dataset.edge_attrs, + ds_infos=dataset.get_dataset_infos(keys=['directed']), + node_kernels=sub_kernels, + edge_kernels=sub_kernels) + gram_matrix, run_time = graph_kernel.compute(dataset.graphs, + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# except Exception as exception: -# assert False, exception + except Exception as exception: + assert False, exception -# @pytest.mark.parametrize('ds_name', ['Alkane', 'AIDS']) -# @pytest.mark.parametrize('parallel', ['imap_unordered', None]) -# #@pytest.mark.parametrize('k_func', ['MinMax', 'tanimoto', None]) -# @pytest.mark.parametrize('k_func', ['MinMax', 'tanimoto']) -# @pytest.mark.parametrize('compute_method', ['trie', 'naive']) -# def test_PathUpToH(ds_name, parallel, k_func, compute_method): -# """Test path kernel up to length $h$. -# """ -# from gklearn.kernels import PathUpToH -# -# dataset = chooseDataset(ds_name) -# -# try: -# graph_kernel = PathUpToH(node_labels=dataset.node_labels, -# edge_labels=dataset.edge_labels, -# ds_infos=dataset.get_dataset_infos(keys=['directed']), -# depth=2, k_func=k_func, compute_method=compute_method) -# gram_matrix, run_time = graph_kernel.compute(dataset.graphs, -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# except Exception as exception: -# assert False, exception -# -# -# @pytest.mark.parametrize('ds_name', ['Alkane', 'AIDS']) -# @pytest.mark.parametrize('parallel', ['imap_unordered', None]) -# def test_Treelet(ds_name, parallel): -# """Test treelet kernel. -# """ -# from gklearn.kernels import Treelet -# from gklearn.utils.kernels import polynomialkernel -# import functools -# -# dataset = chooseDataset(ds_name) +@pytest.mark.parametrize('ds_name', ['Alkane', 'AIDS']) +@pytest.mark.parametrize('parallel', ['imap_unordered', None]) +#@pytest.mark.parametrize('k_func', ['MinMax', 'tanimoto', None]) +@pytest.mark.parametrize('k_func', ['MinMax', 'tanimoto']) +@pytest.mark.parametrize('compute_method', ['trie', 'naive']) +def test_PathUpToH(ds_name, parallel, k_func, compute_method): + """Test path kernel up to length $h$. + """ + from gklearn.kernels import PathUpToH + + dataset = chooseDataset(ds_name) + + try: + graph_kernel = PathUpToH(node_labels=dataset.node_labels, + edge_labels=dataset.edge_labels, + ds_infos=dataset.get_dataset_infos(keys=['directed']), + depth=2, k_func=k_func, compute_method=compute_method) + gram_matrix, run_time = graph_kernel.compute(dataset.graphs, + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + except Exception as exception: + assert False, exception + + +@pytest.mark.parametrize('ds_name', ['Alkane', 'AIDS']) +@pytest.mark.parametrize('parallel', ['imap_unordered', None]) +def test_Treelet(ds_name, parallel): + """Test treelet kernel. + """ + from gklearn.kernels import Treelet + from gklearn.utils.kernels import polynomialkernel + import functools + + dataset = chooseDataset(ds_name) -# pkernel = functools.partial(polynomialkernel, d=2, c=1e5) -# try: -# graph_kernel = Treelet(node_labels=dataset.node_labels, -# edge_labels=dataset.edge_labels, -# ds_infos=dataset.get_dataset_infos(keys=['directed']), -# sub_kernel=pkernel) -# gram_matrix, run_time = graph_kernel.compute(dataset.graphs, -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# except Exception as exception: -# assert False, exception -# -# -# @pytest.mark.parametrize('ds_name', ['Acyclic']) -# #@pytest.mark.parametrize('base_kernel', ['subtree', 'sp', 'edge']) -# # @pytest.mark.parametrize('base_kernel', ['subtree']) -# @pytest.mark.parametrize('parallel', ['imap_unordered', None]) -# def test_WLSubtree(ds_name, parallel): -# """Test Weisfeiler-Lehman subtree kernel. -# """ -# from gklearn.kernels import WLSubtree -# -# dataset = chooseDataset(ds_name) + pkernel = functools.partial(polynomialkernel, d=2, c=1e5) + try: + graph_kernel = Treelet(node_labels=dataset.node_labels, + edge_labels=dataset.edge_labels, + ds_infos=dataset.get_dataset_infos(keys=['directed']), + sub_kernel=pkernel) + gram_matrix, run_time = graph_kernel.compute(dataset.graphs, + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + except Exception as exception: + assert False, exception + + +@pytest.mark.parametrize('ds_name', ['Acyclic']) +#@pytest.mark.parametrize('base_kernel', ['subtree', 'sp', 'edge']) +# @pytest.mark.parametrize('base_kernel', ['subtree']) +@pytest.mark.parametrize('parallel', ['imap_unordered', None]) +def test_WLSubtree(ds_name, parallel): + """Test Weisfeiler-Lehman subtree kernel. + """ + from gklearn.kernels import WLSubtree + + dataset = chooseDataset(ds_name) -# try: -# graph_kernel = WLSubtree(node_labels=dataset.node_labels, -# edge_labels=dataset.edge_labels, -# ds_infos=dataset.get_dataset_infos(keys=['directed']), -# height=2) -# gram_matrix, run_time = graph_kernel.compute(dataset.graphs, -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], -# parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) -# except Exception as exception: -# assert False, exception + try: + graph_kernel = WLSubtree(node_labels=dataset.node_labels, + edge_labels=dataset.edge_labels, + ds_infos=dataset.get_dataset_infos(keys=['directed']), + height=2) + gram_matrix, run_time = graph_kernel.compute(dataset.graphs, + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + kernel_list, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1:], + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + kernel, run_time = graph_kernel.compute(dataset.graphs[0], dataset.graphs[1], + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + except Exception as exception: + assert False, exception if __name__ == "__main__": -# test_spkernel('Alkane', 'imap_unordered') +# test_spkernel('Alkane', 'imap_unordered') test_StructuralSP('Fingerprint_edge', 'imap_unordered') -# test_RandomWalk('Acyclic', 'sylvester', None, 'imap_unordered') -# test_RandomWalk('Acyclic', 'conjugate', None, 'imap_unordered') -# test_RandomWalk('Acyclic', 'fp', None, None) -# test_RandomWalk('Acyclic', 'spectral', 'exp', 'imap_unordered') \ No newline at end of file +# test_RandomWalk('Acyclic', 'sylvester', None, 'imap_unordered') +# test_RandomWalk('Acyclic', 'conjugate', None, 'imap_unordered') +# test_RandomWalk('Acyclic', 'fp', None, None) +# test_RandomWalk('Acyclic', 'spectral', 'exp', 'imap_unordered') \ No newline at end of file