Wie man einen Gaußschen Kernel effektiv in numpy berechnet [geschlossen]

Ich habe ein Numpy-Array mit m Spalten und n Zeilen, wobei die Spalten Dimensionen und die Zeilendatenpunkte sind.

Ich muss jetzt Kernelwerte für jede Kombination von Datenpunkten berechnen.

Für einen linearen Kernel kann ich einfach tun$K(\mathbf{x}_i,\mathbf{x}_j) = \langle \mathbf{x}_i,\mathbf{x}_j \rangle$dot(X,X.T)

Wie kann ich effektiv alle Werte für den Gaußschen Kernel berechnen mit einem gegebenen s ?$K(\mathbf{x}_i,\mathbf{x}_j) = \exp{-\frac{\|\mathbf{x}_i-\mathbf{x}_j\|_2^2}{s^2}}$

Ich denke, das Hauptproblem besteht darin, die paarweisen Abstände effizient zu ermitteln. Sobald Sie das haben, ist der Rest elementweise.

Dazu möchten Sie wahrscheinlich scipy verwenden. Die Funktion scipy.spatial.distance.pdistmacht das, was Sie brauchen, und scipy.spatial.distance.squareformwird möglicherweise Ihr Leben erleichtern.

Wenn Sie also die Kernel-Matrix möchten, tun Sie dies

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)

Dokumentation finden Sie hier . 

Als kleiner Nachtrag zu Bayerjs Antwort kann die pdistFunktion von scipy direkt euklidische Normen berechnen, indem sie als bezeichnet wird pdist(X, 'sqeuclidean'). Der vollständige Code kann dann effizienter geschrieben werden als

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)

Sie können die quadratische Form auch von Hand schreiben:

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, aber das funktioniert 30% langsamer

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)

das ist gleich

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

Sie können den RBF effektiv aus dem obigen Code berechnen. Beachten Sie, dass der Gammawert 1 ist, da es sich um eine Konstante handelt. Das von Ihnen angeforderte s ist ebenfalls dieselbe Konstante.

Ich denke, das wird helfen:

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