Comment calculer un noyau gaussien efficacement en numpy [fermé]

J'ai un tableau numpy avec m colonnes et n lignes, les colonnes étant des dimensions et les points de données des lignes.

Je dois maintenant calculer les valeurs du noyau pour chaque combinaison de points de données.

Pour un noyau linéaire $K(\mathbf{x}_i,\mathbf{x}_j) = \langle \mathbf{x}_i,\mathbf{x}_j \rangle$ je peux simplement fairedot(X,X.T)

$K(\mathbf{x}_i,\mathbf{x}_j) = \exp{-\frac{\|\mathbf{x}_i-\mathbf{x}_j\|_2^2}{s^2}}$

Je pense que le principal problème est d'obtenir efficacement les distances par paires. Une fois que vous avez que le reste est élémentaire.

Pour ce faire, vous voudrez probablement utiliser scipy. La fonction scipy.spatial.distance.pdistfait ce dont vous avez besoin et scipy.spatial.distance.squareformpeut vous faciliter la vie.

Donc, si vous voulez la matrice du noyau que vous faites

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 documentation peut être trouvée ici . 

Comme un petit addendum à la réponse de bayerj, la pdistfonction de scipy peut directement calculer les normes euclidiennes au carré en l'appelant comme pdist(X, 'sqeuclidean'). Le code complet peut ensuite être écrit plus efficacement

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)

Vous pouvez également écrire la forme carrée à la main:

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 mais cela fonctionne 30% plus lentement

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)

ce qui est égal à

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

Vous pouvez calculer efficacement le RBF à partir du code ci-dessus, notez que la valeur gamma est 1, car il s'agit d'une constante, le s que vous avez demandé est également la même constante.

Je pense que ça aidera:

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