Implémentation Python du noyau RBF précalculé avec matrice Gram?

Question

Python a des informations très limitées et des exemples precomputed kernels. sklearn offre seulement un exemple trivial de linear kernel: http://scikit-learn.org/stable/modules/svm.html

Voici le code pour le noyau linéaire:

import numpy as np 
from scipy.spatial.distance import cdist 
from sklearn.datasets import load_iris 

# import data 
iris = datasets.load_iris() 
X = iris.data      
Y = iris.target 

X_train, X_test, y_train, y_test = train_test_split(X, Y) 

clf = svm.SVC(kernel='precomputed') 

# Linear kernel 
G_train = np.dot(X_train, X_train.T) 
clf.fit(G_train, y_train) 

G_test = np.dot(X_test, X_train.T) 
y_pred = clf.predict(G_test)  

Ce n'est pas très utile de comprendre davantage la mise en œuvre d'autres noyaux non triviales, tels que, RBF kernel qui serait:

K(X, X') = np.exp(divide(-cdist(X, X, 'euclidean), 2*np.std(X**2))) 

Comment faire la même chose train et test divisé et mettre en œuvre precomputed kernel pour RBF?

si le noyau obtient plus complique qui dépend d'autres paramètres qui doivent être calculés dans une fonction séparée, par exemple, pour le paramètre alpha >= 0:

K(X, X') = alpha('some function depending on X_train, X_test')*np.exp(divide(-cdist(X, X, 'euclidean), 2*np.std(X**2))) 

Nous avons besoin d'exemples de tels noyaux non triviales. J'apprécierai n'importe quel conseil.

Answer 1

Nous pouvons écrire kernel pca manuellement. Commençons par le noyau polinomial.

from sklearn.datasets import make_circles 
from scipy.spatial.distance import pdist, squareform 
from scipy.linalg import eigh 
import numpy as np 
import matplotlib.pyplot as plt 
%matplotlib inline 

X_c, y_c = make_circles(n_samples=100, random_state=654) 

plt.figure(figsize=(8,6)) 

plt.scatter(X_c[y_c==0, 0], X_c[y_c==0, 1], color='red') 
plt.scatter(X_c[y_c==1, 0], X_c[y_c==1, 1], color='blue') 


plt.ylabel('y coordinate') 
plt.xlabel('x coordinate') 

plt.show() 

données:

def degree_pca(X, gamma, degree, n_components): 
    # Calculating kernel 

    K = gamma*(X@X.T+1)**degree 


    # Obtaining eigenvalues in descending order with corresponding 
    # eigenvectors from the symmetric matrix. 
    eigvals, eigvecs = eigh(K) 

    # Obtaining the i eigenvectors that corresponds to the i highest eigenvalues. 
    X_pc = np.column_stack((eigvecs[:,-i] for i in range(1,n_components+1))) 

    return X_pc 

maintenant transformer les données et l'intrigue il

X_c1 = degree_pca(X_c, gamma=5, degree=2, n_components=2) 

plt.figure(figsize=(8,6)) 

plt.scatter(X_c1[y_c==0, 0], X_c1[y_c==0, 1], color='red') 
plt.scatter(X_c1[y_c==1, 0], X_c1[y_c==1, 1], color='blue') 


plt.ylabel('y coordinate') 
plt.xlabel('x coordinate') 

plt.show() 

séparable Linéairement:

Maintenant, les points peuvent être séparés linéairement.

Ensuite, écrivons le noyau RBF. Pour la démonstration prenons des lunes.

from sklearn.datasets import make_moons 
X, y = make_moons(n_samples=100, random_state=654) 

plt.figure(figsize=(8,6)) 

plt.scatter(X[y==0, 0], X[y==0, 1], color='red') 
plt.scatter(X[y==1, 0], X[y==1, 1], color='blue') 


plt.ylabel('y coordinate') 
plt.xlabel('x coordinate') 

plt.show() 

Lunes:

transformation du noyau pca:

def stepwise_kpca(X, gamma, n_components): 
    """ 
    X: A MxN dataset as NumPy array where the samples are stored as rows (M), features as columns (N). 
    gamma: coefficient for the RBF kernel. 
    n_components: number of components to be returned. 

    """ 
    # Calculating the squared Euclidean distances for every pair of points 
    # in the MxN dimensional dataset. 
    sq_dists = pdist(X, 'sqeuclidean') 

    # Converting the pairwise distances into a symmetric MxM matrix. 
    mat_sq_dists = squareform(sq_dists) 

    K=np.exp(-gamma*mat_sq_dists) 

    # Centering the symmetric NxN kernel matrix. 
    N = K.shape[0] 
    one_n = np.ones((N,N))/N 
    K = K - one_n.dot(K) - K.dot(one_n) + one_n.dot(K).dot(one_n) 

    # Obtaining eigenvalues in descending order with corresponding 
    # eigenvectors from the symmetric matrix. 
    eigvals, eigvecs = eigh(K) 

    # Obtaining the i eigenvectors that corresponds to the i highest eigenvalues. 
    X_pc = np.column_stack((eigvecs[:,-i] for i in range(1,n_components+1))) 

    return X_pc 

complot Let

X_4 = stepwise_kpca(X, gamma=15, n_components=2) 

plt.scatter(X_4[y==0, 0], X_4[y==0, 1], color='red') 
plt.scatter(X_4[y==1, 0], X_4[y==1, 1], color='blue') 


plt.ylabel('y coordinate') 
plt.xlabel('x coordinate') 

plt.show() 

Résultat: