非线性映射——核主成分分析
许多机器学习算法都假定输入数据是线性可分的。感知器为了保证其收敛性，甚至要求训练数据是完美线性可分的。然而，在现实世界中，大多数情况下我们面对的是非线性问题，针对此类问题，通过降维技术，如PCA和LDA等，将其转化为线性问题并不是最好的办法。
核函数与核技巧
通过将非线性可分问题映射到维度更高的特征空间，使其在新的特征空间上线性可分。为了将样本 x∈Rd x ∈ R d 转换到维度更高的 k 维子空间，定义如下非线性映射函数 ϕ ϕ :
我们可以将 ϕ ϕ 看做是一个函数，它能够对原始特征进行非线性映射，以将原始的 d 维数据集映射到更高的 k 维特征空间。例如：对于二维（d = 2）特征向量 x∈Rd x ∈ R d 来说，可用如下映射将其转换到三维空间：
换句话说，利用核PCA，可以通过非线性映射将数据转换到一个高维空间，然后在此高维空间中使用标准PCA将其映射到另外一个低维空间中，并通过线性分类器进行划分（前提条件，样本可根据输入空间的密度进行划分）。但是，这种方法的确定是带来高昂的计算成本，这也是为什么要使用核技巧的原因。通过使用核技巧，可以在原始特征空间中计算两个高维特种空间中向量的相似度。
在更深入了解使用核技巧解决计算成本高昂的问题之前，先回顾一下标准PCA方法。两个特征 k 和 j 之间协方差的计算公式如下：
由于在对特征做标准化处理后，其均值为0，所以上述公式可简化为：
由此可得出计算协方差矩阵 Σ Σ 的通用公式：
可以使用 ϕ ϕ 通过在原始特征空间上的非线性特征组合来替代样本间点积的计算：
为了求得此协方差矩阵的特征向量，也就是主成分，需要求解下述公式：
其中， λ λ 和 ν ν 分别为协方差矩阵 Σ Σ 的特征值和特征向量，这里 α α 可以通过提取核（相似）矩阵 K K 的特征向量来得到。
核矩阵的推导过程如下：
首先，使用矩阵符号来表示协方差矩阵，其中 ϕ(X) ϕ ( X ) 是一个 n * k维的矩阵：
现在，可以将特征向量的公式记为：
由于 Σν=λν Σ ν = λ ν ，可以得到：
两边同乘以 ϕ(X) ϕ ( X ) ， 可得：
其中， K K 为相似（核）矩阵：
通过核函数 K K 以避免使用 ϕ ϕ 来精确计算样本集合 X X 中样本对之间的点积，这样就无需对特征向量进行精确的计算：
通过核 PCA ，能够得到已经映射到各成分的样本，而不像标准 PCA 方法那样去构建一个转换矩阵。简单地说，可以将核函数理解为：通过两个向量点积来度量向量间相似度的函数。常用的核函数有：
综合上述讨论，可以通过如下三个步骤来实现一个基于 RBF 核的 PCA ：
核主成分分析实现
from scipy.spatial.distance import pdist, squareform
from scipy import exp
from scipy.linalg import eigh
import numpy as np
def rbf_kernel_pca(X, gamma, n_components):
"""
RBF kernel PCA implementation.
Parameters
__________
X: {Numpy ndarray}, shape = [n_samples, n_features]
gamma: float
Tuning parameters of the RBF kernel
n_components: int
Number of principal components to return
Returns
__________
X_pc: {Numpy ndarray}, shape = [n_samples, k_features]
Projected dataset
"""
# Calculate pairwise squared Euclidean distances
# in the MxN dimensional dataset.
sq_dist = pdist(X, 'sqeuclidean')
# Convert pairwise distances into a square matrix.
mat_sq_dists = squareform(sq_dist)
# Compute the symmetric kernel matrix.
K = exp(-gamma * mat_sq_dists)
# Center the 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 eigenpairs from the centered kernel matrix
# scipy.linalg.eigh returns them in ascending order
eigvals, eigvecs = eigh(K)
# Collect the top K eigenvectors (projected samples)
X_pc = np.column_stack((eigvecs[:, -i] for i in range(1, n_components + 1)))
return X_pc案例1：分离半月形数据
首先创建一个保护100个样本点的二维数据集，以两个半月形状表示：
from sklearn.datasets import make_moons
X, y = make_moons(n_samples=100, random_state=123)
import matplotlib.pyplot as plt
plt.scatter(X[y == 0, 0], X[y == 0, 1], color='red', marker='^', alpha=0.5)
plt.scatter(X[y == 1, 0], X[y == 1, 1], color='blue', marker='o', alpha=0.5)
plt.show()
显然，这两个半月形不是线性可分的，而我们的目标是通过核 PCA 将这两个半月形数据展开，使得数据集成为适用于某一线性分类器的输入数据。
首先，通过标准 PCA 将数据映射到主成分上，并观察其形状：
from sklearn.decomposition import PCA
scikit_pca = PCA(n_components=2)
X_spca = scikit_pca.fit_transform(X)
fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(7, 3))
ax[0].scatter(X_spca[y == 0, 0], X_spca[y == 0, 1], color='red', marker='^', alpha=0.5)
ax[0].scatter(X_spca[y == 1, 0], X_spca[y == 1, 1], color='blue', marker='o', alpha=0.5)
ax[1].scatter(X_spca[y == 0, 0], np.zeros((50, 1)) + 0.02, color='red', marker='^', alpha=0.5)
ax[1].scatter(X_spca[y == 1, 0], np.zeros((50, 1)) - 0.02, color='blue', marker='o', alpha=0.5)
ax[0].set_xlabel('PC1')
ax[0].set_ylabel('PC2')
ax[1].set_ylim([-1, 1])
ax[1].set_yticks([])
ax[1].set_xlabel('PC1')
plt.show()
很明显，经过标准 PCA 的转换后，线性分类器未能很好地发挥其作用。
使用核 PCA 函数：rbf_kernel_pca
from matplotlib.ticker import FormatStrFormatter
X_kpca = rbf_kernel_pca(X, gamma=15, n_components=2)
fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(7, 3))
ax[0].scatter(X_kpca[y == 0, 0], X_kpca[y == 0, 1], color='red', marker='^', alpha=0.5)
ax[0].scatter(X_kpca[y == 1, 0], X_kpca[y == 1, 1], color='blue', marker='o', alpha=0.5)
ax[1].scatter(X_kpca[y == 0, 0], np.zeros((50, 1)) + 0.02, color='red', marker='^', alpha=0.5)
ax[1].scatter(X_kpca[y == 1, 0], np.zeros((50, 1)) - 0.02, color='blue', marker='o', alpha=0.5)
ax[0].set_xlabel('PC1')
ax[0].set_ylabel('PC2')
ax[1].set_ylim([-1, 1])
ax[1].set_yticks([])
ax[1].set_xlabel('PC1')
ax[0].xaxis.set_major_formatter(FormatStrFormatter('%0.1f'))
ax[1].xaxis.set_major_formatter(FormatStrFormatter('%0.1f'))
plt.show()
可以看到，两个类别（圆形和三角形）此时是线性可分的，这使得转换后的数据适合作为线性分类器的训练数据集。
案例2：分离同心圆数据
from sklearn.datasets import make_circles
X, y = make_circles(n_samples=1000, random_state=123, noise=0.1, factor=0.2)
plt.scatter(X[y == 0, 0], X[y == 0, 1], color='red', marker='^', alpha=0.5)
plt.scatter(X[y == 1, 0], X[y == 1, 1], color='blue', marker='o', alpha=0.5)
plt.show()
首先使用标准 PCA 方法：
scikit_pca = PCA(n_components=2)
X_spca = scikit_pca.fit_transform(X)
fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(7, 3))
ax[0].scatter(X_spca[y == 0, 0], X_spca[y == 0, 1], color='red', marker='^', alpha=0.5)
ax[0].scatter(X_spca[y == 1, 0], X_spca[y == 1, 1], color='blue', marker='o', alpha=0.5)
ax[1].scatter(X_spca[y == 0, 0], np.zeros((500, 1)) + 0.02, color='red', marker='^', alpha=0.5)
ax[1].scatter(X_spca[y == 1, 0], np.zeros((500, 1)) - 0.02, color='blue', marker='o', alpha=0.5)
ax[0].set_xlabel('PC1')
ax[0].set_ylabel('PC2')
ax[1].set_ylim([-1, 1])
ax[1].set_yticks([])
ax[1].set_xlabel('PC1')
plt.show()
再一次发现，通过标准 PCA 无法得到适合于线性分类器的训练数据。
X_kpca = rbf_kernel_pca(X, gamma=15, n_components=2)
fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(7, 3))
ax[0].scatter(X_kpca[y == 0, 0], X_kpca[y == 0, 1], color='red', marker='^', alpha=0.5)
ax[0].scatter(X_kpca[y == 1, 0], X_kpca[y == 1, 1], color='blue', marker='o', alpha=0.5)
ax[1].scatter(X_kpca[y == 0, 0], np.zeros((500, 1)) + 0.02, color='red', marker='^', alpha=0.5)
ax[1].scatter(X_kpca[y == 1, 0], np.zeros((500, 1)) - 0.02, color='blue', marker='o', alpha=0.5)
ax[0].set_xlabel('PC1')
ax[0].set_ylabel('PC2')
ax[1].set_ylim([-1, 1])
ax[1].set_yticks([])
ax[1].set_xlabel('PC1')
ax[0].xaxis.set_major_formatter(FormatStrFormatter('%0.1f'))
ax[1].xaxis.set_major_formatter(FormatStrFormatter('%0.1f'))
plt.show()
基于 RBF 的核 PCA 再一次将数据映射到了一个新的子空间中，使得两个类别变得线性可分。
映射新的数据点
我们从聚集核矩阵中得到了特征向量 α α ，这意味着样本已经映射到了主成分轴上。由此，如果我们希望将新的样本 x⋅ x ⋅ 映射到主成分轴，需要进行如下计算：
幸运的是，我们可以使用核技巧，这样就无需精确计算映射 ϕ(x⋅)Tν ϕ ( x ⋅ ) T ν 。需要注意的是，与标准 PCA 相比，核 PCA 是一种基于内存的方法，这意味着每次映射新的样本前，必须再次使用原始训练数据。
在完成新样本与训练数据集内样本间相似度的计算后，还需通过特征向量对应的特征值来对其进行归一化处理。可以通过修改前面实现过的 rbf_kernel_pca 函数来让其返回核矩阵的特征值：
from scipy.spatial.distance import pdist, squareform
from scipy import exp
from scipy.linalg import eigh
import numpy as np
def rbf_kernel_pca(X, gamma, n_components):
"""
RBF kernel PCA implementation.
Parameters
__________
X: {Numpy ndarray}, shape = [n_samples, n_features]
gamma: float
Tuning parameters of the RBF kernel
n_components: int
Number of principal components to return
Returns
__________
X_pc: {Numpy ndarray}, shape = [n_samples, k_features]
Projected dataset
"""
# Calculate pairwise squared Euclidean distances
# in the MxN dimensional dataset.
sq_dist = pdist(X, 'sqeuclidean')
# Convert pairwise distances into a square matrix.
mat_sq_dists = squareform(sq_dist)
# Compute the symmetric kernel matrix.
K = exp(-gamma * mat_sq_dists)
# Center the 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 eigenpairs from the centered kernel matrix
# scipy.linalg.eigh returns them in ascending order
eigvals, eigvecs = eigh(K)
# Collect the top K eigenvectors (projected samples)
alphas = np.column_stack((eigvecs[:, -i] for i in range(1, n_components + 1)))
# Collect the corresponding eigenvalues
lambdas = [eigvals[-i] for i in range(1, n_components + 1)]
return alphas, lambdas
至此，可以创建一个新的半月形数据集，并使用更新过的 RBF 核 PCA 实现将其映射到一个一维子空间上：
X, y = make_moons(n_samples=100, random_state=123)
alphas, lambdas = rbf_kernel_pca(X, gamma=15, n_components=1)
x_new = X[25]
x_proj = alphas[25]
def project_x(x_new, X, gamma, alphas, lambdas):
pair_dist = np.array([np.sum((x_new - row) ** 2) for row in X])
k = np.exp(-gamma * pair_dist)
return k.dot(alphas / lambdas)
x_reproj = project_x(x_new, X, gamma=15, alphas=alphas, lambdas=lambdas)
plt.scatter(alphas[y == 0, 0], np.zeros((50)), color='red', marker='^', alpha=0.5)
plt.scatter(alphas[y == 1, 0], np.zeros((50)), color='blue', marker='o', alpha=0.5)
plt.scatter(x_proj, 0, color='black', label='original projection of point X[25]',
marker='^', s=100)
plt.scatter(x_reproj, 0, color='green', label='remapped point X[25]',
marker='x', s=500)
plt.legend(scatterpoints=1)
plt.show()
scikit-learn中的核主成分分析
from sklearn.decomposition import KernelPCA
from sklearn.datasets import make_moons
import matplotlib.pyplot as plt
X, y = make_moons(n_samples=100, random_state=123)
scikit_kpca = KernelPCA(n_components=2, kernel='rbf', gamma=15)
X_skernpca = scikit_kpca.fit_transform(X)
plt.scatter(X_skernpca[y == 0, 0], X_skernpca[y == 0, 1], color='red', marker='^', alpha=0.5)
plt.scatter(X_skernpca[y == 1, 0], X_skernpca[y == 1, 1], color='blue', marker='o', alpha=0.5)
plt.xlabel('PC1')
plt.ylabel('PC2')
plt.show()
从结果图像中可以得知，通过scikit-learn中的KernelPCA得到的结果与我们自己实现的结果一致。
参考文献：
Python-Machine-Learning/Chapter 5: Compressing Data via Dimensionality Reduction