Cómo calcular eficazmente un núcleo gaussiano en numpy

Question

Tengo un array numpy con m columnas y n filas, siendo las columnas dimensiones y las filas puntos de datos.

Ahora tengo que calcular los valores del núcleo para cada combinación de puntos de datos.

Para un núcleo lineal $K(\mathbf{x}_i,\mathbf{x}_j) = \langle \mathbf{x}_i,\mathbf{x}_j \rangle$ Simplemente puedo hacer dot(X,X.T)

¿Cómo puedo calcular eficazmente todos los valores del núcleo gaussiano? $K(\mathbf{x}_i,\mathbf{x}_j) = \exp{-\frac{\|\mathbf{x}_i-\mathbf{x}_j\|_2^2}{s^2}}$ con un determinado s ?

Answer 1

Creo que el principal problema es obtener las distancias por pares de forma eficiente. Una vez que se tiene eso, el resto es cuestión de elementos.

Para ello, probablemente quieras utilizar scipy. La función scipy.spatial.distance.pdist hace lo que usted necesita, y scipy.spatial.distance.squareform posiblemente facilitará su vida.

Así que si quieres la matriz del núcleo haces

from scipy.spatial.distance import pdist, squareform
  # this is an NxD matrix, where N is number of items and D its dimensionalites
X = loaddata() 
pairwise_dists = squareform(pdist(X, 'euclidean'))
K = scip.exp(-pairwise_dists ** 2 / s ** 2)

La documentación se puede encontrar aquí .

Answer 2

Como una pequeña adición a la respuesta de bayerj, scipy's pdist puede calcular directamente las normas euclidianas al cuadrado llamándola como pdist(X, 'sqeuclidean') . El código completo puede entonces escribirse de forma más eficiente como

from scipy.spatial.distance import pdist, squareform
  # this is an NxD matrix, where N is number of items and D its dimensionalites
X = loaddata() 
pairwise_sq_dists = squareform(pdist(X, 'sqeuclidean'))
K = scip.exp(-pairwise_sq_dists / s**2)

Answer 3

También puede escribir la forma cuadrada a mano:

import numpy as np
def vectorized_RBF_kernel(X, sigma):
    # % This is equivalent to computing the kernel on every pair of examples
    X2 = np.sum(np.multiply(X, X), 1) # sum colums of the matrix
    K0 = X2 + X2.T - 2 * X * X.T
    K = np.power(np.exp(-1.0 / sigma**2), K0)
    return K

PS pero esto funciona un 30% más lento

Answer 4

def my_kernel(X,Y):
    K = np.zeros((X.shape[0],Y.shape[0]))
    for i,x in enumerate(X):
        for j,y in enumerate(Y):
            K[i,j] = np.exp(-1*np.linalg.norm(x-y)**2)
    return K

clf=SVR(kernel=my_kernel)

que es igual a

clf=SVR(kernel="rbf",gamma=1)

Efectivamente puedes calcular la RBF a partir del código anterior fíjate que el valor de la gamma es 1, como es una constante la s que pediste también es la misma constante.

Answer 5

Creo que esto ayudará:

def GaussianKernel(v1, v2, sigma):
    return exp(-norm(v1-v2, 2)**2/(2.*sigma**2))