From 1800923c45eb722c19a6c4315d1923d20318008b Mon Sep 17 00:00:00 2001 From: jajupmochi Date: Sat, 22 May 2021 12:30:49 +0200 Subject: [PATCH] [API change] gklearn.utils.kernels.gaussiankernel function no longer transforms inputs to numpy.array of float values. This may be faster, but may cause some errors to the previous codes. --- gklearn/utils/kernels.py | 225 ++++++++++++++++++++++++----------------------- 1 file changed, 114 insertions(+), 111 deletions(-) diff --git a/gklearn/utils/kernels.py b/gklearn/utils/kernels.py index 5bd7e4d..afcfb0c 100644 --- a/gklearn/utils/kernels.py +++ b/gklearn/utils/kernels.py @@ -4,155 +4,158 @@ These kernels are defined between pairs of vectors. import numpy as np def deltakernel(x, y): - """Delta kernel. Return 1 if x == y, 0 otherwise. + """Delta kernel. Return 1 if x == y, 0 otherwise. - Parameters - ---------- - x, y : any - Two parts to compare. + Parameters + ---------- + x, y : any + Two parts to compare. - Return - ------ - kernel : integer - Delta kernel. + Return + ------ + kernel : integer + Delta kernel. - References - ---------- - [1] H. Kashima, K. Tsuda, and A. Inokuchi. Marginalized kernels between - labeled graphs. In Proceedings of the 20th International Conference on - Machine Learning, Washington, DC, United States, 2003. - """ - return x == y #(1 if condition else 0) + References + ---------- + [1] H. Kashima, K. Tsuda, and A. Inokuchi. Marginalized kernels between + labeled graphs. In Proceedings of the 20th International Conference on + Machine Learning, Washington, DC, United States, 2003. + """ + return x == y #(1 if condition else 0) def gaussiankernel(x, y, gamma=None): - """Gaussian kernel. - Compute the rbf (gaussian) kernel between x and y: + """Gaussian kernel. + Compute the rbf (gaussian) kernel between x and y: - K(x, y) = exp(-gamma ||x-y||^2). + K(x, y) = exp(-gamma ||x-y||^2). - Read more in the `User Guide of scikit-learn library `__. + Read more in the `User Guide of scikit-learn library `__. - Parameters - ---------- - x, y : array + Parameters + ---------- + x, y : array - gamma : float, default None - If None, defaults to 1.0 / n_features + gamma : float, default None + If None, defaults to 1.0 / n_features - Returns - ------- - kernel : float - """ - if gamma is None: - gamma = 1.0 / len(x) + Returns + ------- + kernel : float + """ + if gamma is None: + gamma = 1.0 / len(x) + + # xt = np.array([float(itm) for itm in x]) # @todo: move this to dataset or datafile to speed up. + # yt = np.array([float(itm) for itm in y]) +# kernel = xt - yt +# kernel = kernel ** 2 +# kernel = np.sum(kernel) +# kernel *= -gamma +# kernel = np.exp(kernel) +# return kernel + + return np.exp((np.sum((x - y) ** 2)) * -gamma) - xt = np.array([float(itm) for itm in x]) # @todo: move this to dataset or datafile to speed up. - yt = np.array([float(itm) for itm in y]) - kernel = xt - yt - kernel = kernel ** 2 - kernel = np.sum(kernel) - kernel *= -gamma - kernel = np.exp(kernel) - return kernel def polynomialkernel(x, y, d=1, c=0): - """Polynomial kernel. - Compute the polynomial kernel between x and y: + """Polynomial kernel. + Compute the polynomial kernel between x and y: - K(x, y) = ^d + c. + K(x, y) = ^d + c. - Parameters - ---------- - x, y : array + Parameters + ---------- + x, y : array - d : integer, default 1 + d : integer, default 1 - c : float, default 0 + c : float, default 0 - Returns - ------- - kernel : float - """ - return np.dot(x, y) ** d + c + Returns + ------- + kernel : float + """ + return np.dot(x, y) ** d + c def linearkernel(x, y): - """Polynomial kernel. - Compute the polynomial kernel between x and y: + """Polynomial kernel. + Compute the polynomial kernel between x and y: - K(x, y) = . + K(x, y) = . - Parameters - ---------- - x, y : array + Parameters + ---------- + x, y : array - d : integer, default 1 + d : integer, default 1 - c : float, default 0 + c : float, default 0 - Returns - ------- - kernel : float - """ - return np.dot(x, y) + Returns + ------- + kernel : float + """ + return np.dot(x, y) def kernelsum(k1, k2, d11, d12, d21=None, d22=None, lamda1=1, lamda2=1): - """Sum of a pair of kernels. + """Sum of a pair of kernels. - k = lamda1 * k1(d11, d12) + lamda2 * k2(d21, d22) + k = lamda1 * k1(d11, d12) + lamda2 * k2(d21, d22) - Parameters - ---------- - k1, k2 : function - A pair of kernel functions. - d11, d12: - Inputs of k1. If d21 or d22 is None, apply d11, d12 to both k1 and k2. - d21, d22: - Inputs of k2. - lamda1, lamda2: float - Coefficients of the product. + Parameters + ---------- + k1, k2 : function + A pair of kernel functions. + d11, d12: + Inputs of k1. If d21 or d22 is None, apply d11, d12 to both k1 and k2. + d21, d22: + Inputs of k2. + lamda1, lamda2: float + Coefficients of the product. - Return - ------ - kernel : integer + Return + ------ + kernel : integer - """ - if d21 == None or d22 == None: - kernel = lamda1 * k1(d11, d12) + lamda2 * k2(d11, d12) - else: - kernel = lamda1 * k1(d11, d12) + lamda2 * k2(d21, d22) - return kernel + """ + if d21 == None or d22 == None: + kernel = lamda1 * k1(d11, d12) + lamda2 * k2(d11, d12) + else: + kernel = lamda1 * k1(d11, d12) + lamda2 * k2(d21, d22) + return kernel def kernelproduct(k1, k2, d11, d12, d21=None, d22=None, lamda=1): - """Product of a pair of kernels. - - k = lamda * k1(d11, d12) * k2(d21, d22) - - Parameters - ---------- - k1, k2 : function - A pair of kernel functions. - d11, d12: - Inputs of k1. If d21 or d22 is None, apply d11, d12 to both k1 and k2. - d21, d22: - Inputs of k2. - lamda: float - Coefficient of the product. - - Return - ------ - kernel : integer - """ - if d21 == None or d22 == None: - kernel = lamda * k1(d11, d12) * k2(d11, d12) - else: - kernel = lamda * k1(d11, d12) * k2(d21, d22) - return kernel + """Product of a pair of kernels. + + k = lamda * k1(d11, d12) * k2(d21, d22) + + Parameters + ---------- + k1, k2 : function + A pair of kernel functions. + d11, d12: + Inputs of k1. If d21 or d22 is None, apply d11, d12 to both k1 and k2. + d21, d22: + Inputs of k2. + lamda: float + Coefficient of the product. + + Return + ------ + kernel : integer + """ + if d21 == None or d22 == None: + kernel = lamda * k1(d11, d12) * k2(d11, d12) + else: + kernel = lamda * k1(d11, d12) * k2(d21, d22) + return kernel if __name__ == '__main__': - o = polynomialkernel([1, 2], [3, 4], 2, 3) + o = polynomialkernel([1, 2], [3, 4], 2, 3)