From 3df13c02bc2d328f1f63e3cc979740d7f208adfb Mon Sep 17 00:00:00 2001 From: linlin Date: Sun, 4 Oct 2020 19:16:11 +0200 Subject: [PATCH] New translations test_graphkernels.py (French) --- lang/fr/gklearn/tests/test_graphkernels.py | 281 +++++++++++++++++++++++++++++ 1 file changed, 281 insertions(+) create mode 100644 lang/fr/gklearn/tests/test_graphkernels.py diff --git a/lang/fr/gklearn/tests/test_graphkernels.py b/lang/fr/gklearn/tests/test_graphkernels.py new file mode 100644 index 0000000..e90a1d0 --- /dev/null +++ b/lang/fr/gklearn/tests/test_graphkernels.py @@ -0,0 +1,281 @@ +"""Tests of graph kernels. +""" + +import pytest +import multiprocessing + + +def chooseDataset(ds_name): + """Choose dataset according to name. + """ + from gklearn.utils.graphfiles import loadDataset + + # no node labels (and no edge labels). + if ds_name == 'Alkane': + ds_file = 'datasets/Alkane/dataset.ds' + ds_y = 'datasets/Alkane/dataset_boiling_point_names.txt' + Gn, y = loadDataset(ds_file, filename_y=ds_y) + for G in Gn: + for node in G.nodes: + del G.nodes[node]['attributes'] + # node symbolic labels. + elif ds_name == 'Acyclic': + ds_file = 'datasets/acyclic/dataset_bps.ds' + Gn, y = loadDataset(ds_file) + for G in Gn: + for node in G.nodes: + del G.nodes[node]['attributes'] + # node non-symbolic labels. + elif ds_name == 'Letter-med': + ds_file = 'datasets/Letter-med/Letter-med_A.txt' + Gn, y = loadDataset(ds_file) + # node symbolic and non-symbolic labels (and edge symbolic labels). + elif ds_name == 'AIDS': + ds_file = 'datasets/AIDS/AIDS_A.txt' + Gn, y = loadDataset(ds_file) + + # edge non-symbolic labels (no node labels). + elif ds_name == 'Fingerprint_edge': + import networkx as nx + ds_file = 'datasets/Fingerprint/Fingerprint_A.txt' + Gn, y = loadDataset(ds_file) + 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 = [y[i] for i in idx] + for G in Gn: + G.graph['node_attrs'] = [] + for node in G.nodes: + del G.nodes[node]['attributes'] + del G.nodes[node]['x'] + del G.nodes[node]['y'] + # edge non-symbolic labels (and node non-symbolic labels). + elif ds_name == 'Fingerprint': + import networkx as nx + ds_file = 'datasets/Fingerprint/Fingerprint_A.txt' + Gn, y = loadDataset(ds_file) + 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 = [y[i] for i in idx] + # edge symbolic and non-symbolic labels (and node symbolic and non-symbolic labels). + elif ds_name == 'Cuneiform': + import networkx as nx + ds_file = 'datasets/Cuneiform/Cuneiform_A.txt' + Gn, y = loadDataset(ds_file) + + Gn = Gn[0:3] + y = y[0:3] + + return Gn, y + + +@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_commonwalkkernel(ds_name, weight, compute_method): + """Test common walk kernel. + """ + from gklearn.kernels.commonWalkKernel import commonwalkkernel + + Gn, y = chooseDataset(ds_name) + + try: + Kmatrix, run_time, idx = commonwalkkernel(Gn, + node_label='atom', + edge_label='bond_type', + weight=weight, + compute_method=compute_method, +# 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', [True, False]) +#@pytest.mark.parametrize('parallel', ['imap_unordered', None]) +def test_marginalizedkernel(ds_name, remove_totters): + """Test marginalized kernel. + """ + from gklearn.kernels.marginalizedKernel import marginalizedkernel + + Gn, y = chooseDataset(ds_name) + + try: + Kmatrix, run_time = marginalizedkernel(Gn, + node_label='atom', + edge_label='bond_type', + p_quit=0.5, + n_iteration=2, + remove_totters=remove_totters, +# parallel=parallel, + n_jobs=multiprocessing.cpu_count(), + verbose=True) + 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_randomwalkkernel(ds_name, compute_method, sub_kernel): + """Test random walk kernel kernel. + """ + from gklearn.kernels.randomWalkKernel import randomwalkkernel + from gklearn.utils.kernels import deltakernel, gaussiankernel, kernelproduct + import functools + + Gn, y = chooseDataset(ds_name) + + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = [{'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel}] + try: + Kmatrix, run_time, idx = randomwalkkernel(Gn, + compute_method=compute_method, + weight=1e-3, + p=None, + q=None, + edge_weight=None, + node_kernels=sub_kernels, + edge_kernels=sub_kernels, + node_label='atom', + edge_label='bond_type', + sub_kernel=sub_kernel, +# parallel=parallel, + n_jobs=multiprocessing.cpu_count(), + verbose=True) + 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]) +@pytest.mark.parametrize('parallel', ['imap_unordered']) +def test_spkernel(ds_name, parallel): + """Test shortest path kernel. + """ + from gklearn.kernels.spKernel import spkernel + from gklearn.utils.kernels import deltakernel, gaussiankernel, kernelproduct + import functools + + Gn, y = chooseDataset(ds_name) + + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + try: + Kmatrix, run_time, idx = spkernel(Gn, node_label='atom', + node_kernels=sub_kernels, + parallel=parallel, n_jobs=multiprocessing.cpu_count(), verbose=True) + 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_structuralspkernel(ds_name, parallel): + """Test structural shortest path kernel. + """ + from gklearn.kernels.structuralspKernel import structuralspkernel + from gklearn.utils.kernels import deltakernel, gaussiankernel, kernelproduct + import functools + + Gn, y = chooseDataset(ds_name) + + mixkernel = functools.partial(kernelproduct, deltakernel, gaussiankernel) + sub_kernels = {'symb': deltakernel, 'nsymb': gaussiankernel, 'mix': mixkernel} + try: + Kmatrix, run_time = structuralspkernel(Gn, node_label='atom', + edge_label='bond_type', node_kernels=sub_kernels, + edge_kernels=sub_kernels, + 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]) +#@pytest.mark.parametrize('k_func', ['MinMax', 'tanimoto', None]) +@pytest.mark.parametrize('k_func', ['MinMax', 'tanimoto']) +@pytest.mark.parametrize('compute_method', ['trie', 'naive']) +def test_untilhpathkernel(ds_name, parallel, k_func, compute_method): + """Test path kernel up to length $h$. + """ + from gklearn.kernels.untilHPathKernel import untilhpathkernel + + Gn, y = chooseDataset(ds_name) + + try: + Kmatrix, run_time = untilhpathkernel(Gn, node_label='atom', + edge_label='bond_type', + depth=2, k_func=k_func, compute_method=compute_method, + 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_treeletkernel(ds_name, parallel): + """Test treelet kernel. + """ + from gklearn.kernels.treeletKernel import treeletkernel + from gklearn.utils.kernels import polynomialkernel + import functools + + Gn, y = chooseDataset(ds_name) + + pkernel = functools.partial(polynomialkernel, d=2, c=1e5) + try: + Kmatrix, run_time = treeletkernel(Gn, + sub_kernel=pkernel, + node_label='atom', + edge_label='bond_type', + 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_weisfeilerlehmankernel(ds_name, parallel, base_kernel): + """Test Weisfeiler-Lehman kernel. + """ + from gklearn.kernels.weisfeilerLehmanKernel import weisfeilerlehmankernel + + Gn, y = chooseDataset(ds_name) + + try: + Kmatrix, run_time = weisfeilerlehmankernel(Gn, + node_label='atom', + edge_label='bond_type', + height=2, + base_kernel=base_kernel, + 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_structuralspkernel('Fingerprint_edge', 'imap_unordered') \ No newline at end of file