From c95e641e28d90b165f46f1ef4eb0003c438b948a Mon Sep 17 00:00:00 2001 From: linlin Date: Thu, 15 Oct 2020 16:36:43 +0200 Subject: [PATCH] New translations randomWalkKernel.py (French) --- lang/fr/gklearn/kernels/randomWalkKernel.py | 86 ++++++++++++++--------------- 1 file changed, 43 insertions(+), 43 deletions(-) diff --git a/lang/fr/gklearn/kernels/randomWalkKernel.py b/lang/fr/gklearn/kernels/randomWalkKernel.py index 346bc98..65bf63c 100644 --- a/lang/fr/gklearn/kernels/randomWalkKernel.py +++ b/lang/fr/gklearn/kernels/randomWalkKernel.py @@ -37,15 +37,15 @@ def randomwalkkernel(*args, n_jobs=None, chunksize=None, verbose=True): - """Calculate random walk graph kernels. + """Compute random walk graph kernels. Parameters ---------- Gn : List of NetworkX graph - List of graphs between which the kernels are calculated. + List of graphs between which the kernels are computed. G1, G2 : NetworkX graphs - Two graphs between which the kernel is calculated. + Two graphs between which the kernel is computed. compute_method : string Method used to compute kernel. The Following choices are @@ -125,7 +125,7 @@ def randomwalkkernel(*args, Gn = [g.copy() for g in Gn] eweight = None - if edge_weight == None: + if edge_weight is None: if verbose: print('\n None edge weight specified. Set all weight to 1.\n') else: @@ -212,12 +212,12 @@ def randomwalkkernel(*args, ############################################################################### def _sylvester_equation(Gn, lmda, p, q, eweight, n_jobs, chunksize, verbose=True): - """Calculate walk graph kernels up to n between 2 graphs using Sylvester method. + """Compute walk graph kernels up to n between 2 graphs using Sylvester method. Parameters ---------- G1, G2 : NetworkX graph - Graphs between which the kernel is calculated. + Graphs between which the kernel is computed. node_label : string node attribute used as label. edge_label : string @@ -230,7 +230,7 @@ def _sylvester_equation(Gn, lmda, p, q, eweight, n_jobs, chunksize, verbose=True """ Kmatrix = np.zeros((len(Gn), len(Gn))) - if q == None: + if q is None: # don't normalize adjacency matrices if q is a uniform vector. Note # A_wave_list actually contains the transposes of the adjacency matrices. A_wave_list = [ @@ -245,7 +245,7 @@ def _sylvester_equation(Gn, lmda, p, q, eweight, n_jobs, chunksize, verbose=True # norm = A_tilde.sum(axis=0) # norm[norm == 0] = 1 # A_wave_list.append(A_tilde / norm) - if p == None: # p is uniform distribution as default. + if p is None: # p is uniform distribution as default. def init_worker(Awl_toshare): global G_Awl G_Awl = Awl_toshare @@ -255,7 +255,7 @@ def _sylvester_equation(Gn, lmda, p, q, eweight, n_jobs, chunksize, verbose=True # pbar = tqdm( # total=(1 + len(Gn)) * len(Gn) / 2, -# desc='calculating kernels', +# desc='Computing kernels', # file=sys.stdout) # for i in range(0, len(Gn)): # for j in range(i, len(Gn)): @@ -300,12 +300,12 @@ def _se_do(A_wave1, A_wave2, lmda): ############################################################################### def _conjugate_gradient(Gn, lmda, p, q, ds_attrs, node_kernels, edge_kernels, node_label, edge_label, eweight, n_jobs, chunksize, verbose=True): - """Calculate walk graph kernels up to n between 2 graphs using conjugate method. + """Compute walk graph kernels up to n between 2 graphs using conjugate method. Parameters ---------- G1, G2 : NetworkX graph - Graphs between which the kernel is calculated. + Graphs between which the kernel is computed. node_label : string node attribute used as label. edge_label : string @@ -321,14 +321,14 @@ def _conjugate_gradient(Gn, lmda, p, q, ds_attrs, node_kernels, edge_kernels, # if not ds_attrs['node_labeled'] and ds_attrs['node_attr_dim'] < 1 and \ # not ds_attrs['edge_labeled'] and ds_attrs['edge_attr_dim'] < 1: # # this is faster from unlabeled graphs. @todo: why? -# if q == None: +# if q is None: # # don't normalize adjacency matrices if q is a uniform vector. Note # # A_wave_list actually contains the transposes of the adjacency matrices. # A_wave_list = [ # nx.adjacency_matrix(G, eweight).todense().transpose() for G in # tqdm(Gn, desc='compute adjacency matrices', file=sys.stdout) # ] -# if p == None: # p is uniform distribution as default. +# if p is None: # p is uniform distribution as default. # def init_worker(Awl_toshare): # global G_Awl # G_Awl = Awl_toshare @@ -336,23 +336,23 @@ def _conjugate_gradient(Gn, lmda, p, q, ds_attrs, node_kernels, edge_kernels, # parallel_gm(do_partial, Kmatrix, Gn, init_worker=init_worker, # glbv=(A_wave_list,), n_jobs=n_jobs) # else: - # reindex nodes using consecutive integers for convenience of kernel calculation. + # reindex nodes using consecutive integers for convenience of kernel computation. Gn = [nx.convert_node_labels_to_integers( g, first_label=0, label_attribute='label_orignal') for g in (tqdm( Gn, desc='reindex vertices', file=sys.stdout) if verbose else Gn)] - if p == None and q == None: # p and q are uniform distributions as default. + if p is None and q is None: # p and q are uniform distributions as default. def init_worker(gn_toshare): global G_gn G_gn = gn_toshare - do_partial = partial(wrapper_cg_labled_do, ds_attrs, node_kernels, + do_partial = partial(wrapper_cg_labeled_do, ds_attrs, node_kernels, node_label, edge_kernels, edge_label, lmda) parallel_gm(do_partial, Kmatrix, Gn, init_worker=init_worker, glbv=(Gn,), n_jobs=n_jobs, chunksize=chunksize, verbose=verbose) # pbar = tqdm( # total=(1 + len(Gn)) * len(Gn) / 2, -# desc='calculating kernels', +# desc='Computing kernels', # file=sys.stdout) # for i in range(0, len(Gn)): # for j in range(i, len(Gn)): @@ -382,24 +382,24 @@ def _cg_unlabled_do(A_wave1, A_wave2, lmda): return np.dot(q_times, x) -def wrapper_cg_labled_do(ds_attrs, node_kernels, node_label, edge_kernels, +def wrapper_cg_labeled_do(ds_attrs, node_kernels, node_label, edge_kernels, edge_label, lmda, itr): i = itr[0] j = itr[1] - return i, j, _cg_labled_do(G_gn[i], G_gn[j], ds_attrs, node_kernels, + return i, j, _cg_labeled_do(G_gn[i], G_gn[j], ds_attrs, node_kernels, node_label, edge_kernels, edge_label, lmda) -def _cg_labled_do(g1, g2, ds_attrs, node_kernels, node_label, +def _cg_labeled_do(g1, g2, ds_attrs, node_kernels, node_label, edge_kernels, edge_label, lmda): - # Frist, compute kernels between all pairs of nodes, method borrowed + # Frist, compute kernels between all pairs of nodes using the method borrowed # from FCSP. It is faster than directly computing all edge kernels # when $d_1d_2>2$, where $d_1$ and $d_2$ are vertex degrees of the # graphs compared, which is the most case we went though. For very # sparse graphs, this would be slow. vk_dict = computeVK(g1, g2, ds_attrs, node_kernels, node_label) - # Compute weight matrix of the direct product graph. + # Compute the weight matrix of the direct product graph. w_times, w_dim = computeW(g1, g2, vk_dict, ds_attrs, edge_kernels, edge_label) # use uniform distribution if there is no prior knowledge. @@ -415,12 +415,12 @@ def _cg_labled_do(g1, g2, ds_attrs, node_kernels, node_label, ############################################################################### def _fixed_point(Gn, lmda, p, q, ds_attrs, node_kernels, edge_kernels, node_label, edge_label, eweight, n_jobs, chunksize, verbose=True): - """Calculate walk graph kernels up to n between 2 graphs using Fixed-Point method. + """Compute walk graph kernels up to n between 2 graphs using Fixed-Point method. Parameters ---------- G1, G2 : NetworkX graph - Graphs between which the kernel is calculated. + Graphs between which the kernel is computed. node_label : string node attribute used as label. edge_label : string @@ -438,17 +438,17 @@ def _fixed_point(Gn, lmda, p, q, ds_attrs, node_kernels, edge_kernels, # if not ds_attrs['node_labeled'] and ds_attrs['node_attr_dim'] < 1 and \ # not ds_attrs['edge_labeled'] and ds_attrs['edge_attr_dim'] > 1: # # this is faster from unlabeled graphs. @todo: why? -# if q == None: +# if q is None: # # don't normalize adjacency matrices if q is a uniform vector. Note # # A_wave_list actually contains the transposes of the adjacency matrices. # A_wave_list = [ # nx.adjacency_matrix(G, eweight).todense().transpose() for G in # tqdm(Gn, desc='compute adjacency matrices', file=sys.stdout) # ] -# if p == None: # p is uniform distribution as default. +# if p is None: # p is uniform distribution as default. # pbar = tqdm( # total=(1 + len(Gn)) * len(Gn) / 2, -# desc='calculating kernels', +# desc='Computing kernels', # file=sys.stdout) # for i in range(0, len(Gn)): # for j in range(i, len(Gn)): @@ -464,33 +464,33 @@ def _fixed_point(Gn, lmda, p, q, ds_attrs, node_kernels, edge_kernels, # Kmatrix[j][i] = Kmatrix[i][j] # pbar.update(1) # else: - # reindex nodes using consecutive integers for convenience of kernel calculation. + # reindex nodes using consecutive integers for the convenience of kernel computation. Gn = [nx.convert_node_labels_to_integers( g, first_label=0, label_attribute='label_orignal') for g in (tqdm( Gn, desc='reindex vertices', file=sys.stdout) if verbose else Gn)] - if p == None and q == None: # p and q are uniform distributions as default. + if p is None and q is None: # p and q are uniform distributions as default. def init_worker(gn_toshare): global G_gn G_gn = gn_toshare - do_partial = partial(wrapper_fp_labled_do, ds_attrs, node_kernels, + do_partial = partial(wrapper_fp_labeled_do, ds_attrs, node_kernels, node_label, edge_kernels, edge_label, lmda) parallel_gm(do_partial, Kmatrix, Gn, init_worker=init_worker, glbv=(Gn,), n_jobs=n_jobs, chunksize=chunksize, verbose=verbose) return Kmatrix -def wrapper_fp_labled_do(ds_attrs, node_kernels, node_label, edge_kernels, +def wrapper_fp_labeled_do(ds_attrs, node_kernels, node_label, edge_kernels, edge_label, lmda, itr): i = itr[0] j = itr[1] - return i, j, _fp_labled_do(G_gn[i], G_gn[j], ds_attrs, node_kernels, + return i, j, _fp_labeled_do(G_gn[i], G_gn[j], ds_attrs, node_kernels, node_label, edge_kernels, edge_label, lmda) -def _fp_labled_do(g1, g2, ds_attrs, node_kernels, node_label, +def _fp_labeled_do(g1, g2, ds_attrs, node_kernels, node_label, edge_kernels, edge_label, lmda): - # Frist, compute kernels between all pairs of nodes, method borrowed + # Frist, compute kernels between all pairs of nodes using the method borrowed # from FCSP. It is faster than directly computing all edge kernels # when $d_1d_2>2$, where $d_1$ and $d_2$ are vertex degrees of the # graphs compared, which is the most case we went though. For very @@ -519,13 +519,13 @@ def func_fp(x, p_times, lmda, w_times): ############################################################################### def _spectral_decomposition(Gn, weight, p, q, sub_kernel, eweight, n_jobs, chunksize, verbose=True): - """Calculate walk graph kernels up to n between 2 unlabeled graphs using + """Compute walk graph kernels up to n between 2 unlabeled graphs using spectral decomposition method. Labels will be ignored. Parameters ---------- G1, G2 : NetworkX graph - Graphs between which the kernel is calculated. + Graphs between which the kernel is computed. node_label : string node attribute used as label. edge_label : string @@ -538,7 +538,7 @@ def _spectral_decomposition(Gn, weight, p, q, sub_kernel, eweight, n_jobs, chunk """ Kmatrix = np.zeros((len(Gn), len(Gn))) - if q == None: + if q is None: # precompute the spectral decomposition of each graph. P_list = [] D_list = [] @@ -552,7 +552,7 @@ def _spectral_decomposition(Gn, weight, p, q, sub_kernel, eweight, n_jobs, chunk P_list.append(ev) # P_inv_list = [p.T for p in P_list] # @todo: also works for directed graphs? - if p == None: # p is uniform distribution as default. + if p is None: # p is uniform distribution as default. q_T_list = [np.full((1, nx.number_of_nodes(G)), 1 / nx.number_of_nodes(G)) for G in Gn] # q_T_list = [q.T for q in q_list] def init_worker(q_T_toshare, P_toshare, D_toshare): @@ -568,7 +568,7 @@ def _spectral_decomposition(Gn, weight, p, q, sub_kernel, eweight, n_jobs, chunk # pbar = tqdm( # total=(1 + len(Gn)) * len(Gn) / 2, -# desc='calculating kernels', +# desc='Computing kernels', # file=sys.stdout) # for i in range(0, len(Gn)): # for j in range(i, len(Gn)): @@ -605,12 +605,12 @@ def _sd_do(q_T1, q_T2, P1, P2, D1, D2, weight, sub_kernel): ############################################################################### def _randomwalkkernel_kron(G1, G2, node_label, edge_label): - """Calculate walk graph kernels up to n between 2 graphs using nearest Kronecker product approximation method. + """Compute walk graph kernels up to n between 2 graphs using nearest Kronecker product approximation method. Parameters ---------- G1, G2 : NetworkX graph - Graphs between which the kernel is calculated. + Graphs between which the kernel is computed. node_label : string node attribute used as label. edge_label : string @@ -692,8 +692,8 @@ def computeVK(g1, g2, ds_attrs, node_kernels, node_label): def computeW(g1, g2, vk_dict, ds_attrs, edge_kernels, edge_label): - '''Compute weight matrix of the direct product graph. - ''' + """Compute the weight matrix of the direct product graph. + """ w_dim = nx.number_of_nodes(g1) * nx.number_of_nodes(g2) w_times = np.zeros((w_dim, w_dim)) if vk_dict: # node labeled