局部线性嵌入(LLE)算法的详细推导及Python实现

  局部线性嵌入(Local Linear Embedding, LLE)算法是一种经典的流形学习算法，不同于等度量映射(Isometric Mapping, Isomap)算法考虑结点的全局连接信息，LLE算法只考虑每个结点的k近邻信息，所以速度比Isomap快很多。LLE的思想如下图所示，LLE在低维空间保持了原始高维空间样本邻域内的线性关系，这也是局部线性的一个最直接的解释：高维数据在局部上具有欧式空间的性质，满足线性相关性。

  给定LLE算法的输入 χ = { x 1 , x 2 , . . . , x N } ∈ R D × N \chi=\{x_1, x_2,...,x_N\}\in R^{D\times N} χ={x1​,x2​,...,xN​}∈RD×N，其中$x_i\in R^{D\times 1},i=1,...,N$，即有$N$个样本，每个样本都是维度为$D$的列向量。算法输出为 Y = { y 1 , y 2 , . . . , y N } ∈ R d × N Y=\{y_1, y_2,...,y_N\}\in R^{d\times N} Y={y1​,y2​,...,yN​}∈Rd×N，其中$d<D$，$y_i\in R^{d\times 1},i=1,...,N$。假定原始输入空间的向量$x_i$满足$x_i={\sum }_{j=1}^k{w}_{ji}{x}_{ji}$，$x_{ji}$为$x_i$的第$j$个近邻点，$w_{ji}\in (0,1)$为权重，那么LLE算法认为在低维空间同样应该保持上述线性关系：$y_i={\sum }_{j=1}^k{w}_{ji}{y}_{ji}$，所以LLE算法的核心就是如何根据高维空间的邻域线性关系求解具有同邻域线性关系的低维流形嵌入。
  首先看高维空间。LLE算法第一步是求出原始输入空间的每个样本与其邻域的线性关系，即$${\mathrm{argmin}}_W\sum _{i=1}^N\Vert x_i-\sum _{j=1}^k{w}_{ji}{x}_{ji}{\Vert }^2$$ $$s.t.\sum _{j=1}^k{w}_{ji}=1$$记$$\begin{array}{rl}\Phi (W)& =\sum _{i=1}^N\Vert x_i-\sum _{j=1}^k{w}_{ji}{x}_{ji}{\Vert }^2\\ & =\sum _{i=1}^N\Vert \sum _{j=1}^k(x_i-x_{ji})w_{ji}{\Vert }^2\\ & =\sum _{i=1}^N\Vert (X_i-N_i)W_i{\Vert }^2\\ & =\sum _{i=1}^N{W}_i^T(X_i-N_i{)}^T(X_i-N_i)W_i\end{array}$$ $$s.t.W_i^T{1}_k=1$$ 其中$X_i,N_i\in R^{D\times k},W_i\in R^{k\times 1}$。记$S=(X_i-N_i{)}^T(X_i-N_i)\in R^{k\times k}$，则上述优化目标变成了：$$\Phi (W)=\sum _{i=1}^N{W}_i^{T}S{W}_i$$ $$s.t.W_i^T{1}_k=1$$ 写出该优化目标的拉格朗日方程： $$L=W_i^{T}S{W}_i+\lambda (W_i^T{1}_k-1)$$ 求$L$对$W_i$的偏导数，并令其等于零：$$\frac{\partial L}{\partial W_i}=2S{W}_i+\lambda 1_k=0$$ 则可以求出$W_i$： $$W_i=\frac{S_i^{-1}{1}_k}{1_k^T{S}_i^{-1}{1}_k}$$ 上式中的分母$1_k^T{S}_i^{-1}{1}_k$是为了对$W_i\in R^{k\times 1}$进行归一化，使得$W_i$各维度之和为1，所以这里可以忽略系数$\lambda$，总体的权重系数$W$矩阵为 W = { W 1 , W 2 , . . . , W N } ∈ R k × N W=\{ W_1, W_2,...,W_N \} \in R^{k \times N} W={W1​,W2​,...,WN​}∈Rk×N。
  然后看低维空间 Y = { y 1 , y 2 , . . . , y N } ∈ R d × N Y=\{y_1, y_2,...,y_N\}\in R^{d\times N} Y={y1​,y2​,...,yN​}∈Rd×N，$Y$的每一列都是一个样本，样本长度为$d$，共$N$个样本，因为低维空间要保证局部线性与原始输入空间相同，所以可以表示为：$${\mathrm{argmin}}_Y\sum _{i=1}^N\Vert y_i-\sum _{j=1}^k{w}_{ji}{y}_{ji}{\Vert }^2$$ $$\begin{array}{rl}s.t.& \sum _{i=1}^N{y}_i=0\\ & \sum _{i=1}^N{y}_i{y}_i^T=N{I}_{d\times d}\end{array}$$ 这里有两个约束条件，第一个是说$Y$被中心化，所有的样本在同一个维度上的数值之和为0，第二个约束条件指的是$Y$中的低维样本$y_i$都是单位向量。现建立稀疏矩阵 W ′ = { w i j ′ } ∈ R N × N W'=\{ w'_{ij} \} \in R^{N \times N} W′={wij′​}∈RN×N，且$$w_{ij}^{\prime }=\{\begin{array}{rl}& w_{ij},x_j\in kNN(x_i)\\ & 0,otherwise\end{array}$$ 因此，$$\sum _{j=1}^N{w}_{ji}^{\prime }{y}_{ji}=\sum _{j=1}^k{w}_{ji}{y}_{ji}=Y{W}_i^{\prime }$$ 上式中，$Y\in R^{d\times N}$每一列代表一个样本，$W_i^{\prime }\in R^{N\times 1}$为矩阵$W^{\prime }$的列向量，得到的结果刚好是$y_i\in R^{d\times 1}$。记$$\begin{array}{rl}\Phi (Y)& =\sum _{i=1}^N\Vert y_i-\sum _{j=1}^k{w}_{ji}{y}_{ji}{\Vert }^2\\ & =\sum _{i=1}^N\Vert Y(I_i-W_i^{\prime }){\Vert }^2\\ & =\sum _{i=1}^N[Y(I_i-W_i^{\prime })(I_i-W_i^{\prime }{)}^T{Y}^T]\\ & =tr(Y(I-W^{\prime })(I-W^{\prime }{)}^T{Y}^T)\end{array}$$ 这里用到了矩阵的一个技巧，假定$A=[a_1,a_2,,...,a_n]$，$a_n\in R^{d\times 1}$为列向量，则${\sum }_{i=1}^N{a}_i^2={\sum }_{i=1}^N{a}_i^T{a}_i=tr(A{A}^T)$（结果最后为一个数值，即${\sum }_{i=1}^d{\sum }_{j=1}^N{A}_{ij}^2$），可以使用三元数组举一个toy problem，篇幅所限就不列举出来了。所以同样，${\sum }_{i=1}^N{y}_i^T{y}_i=tr(Y{Y}^T)$。令$M=(I_i-W_i^{\prime })(I_i-W_i^{\prime }{)}^T\in R^{N\times N}$，则优化问题可写为：$$min\Phi (Y)=tr(YM{Y}^T)$$ $$s.t.tr(Y{Y}^T-N{I}_{d\times d})=0$$ 写出拉格朗日方程：$$L=tr[YM{Y}^T+\lambda (Y{Y}^T-N{I}_{d\times d})]$$ 对$Y$求导并令其等于零，则可以得到$$M{Y}_T+2\lambda Y_T=0$$ $$M{Y}_T={\lambda }^{\prime }{Y}_T$$ 最后，要得到降维后的$d$维数据集，只需要取矩阵$M$最小的$d$个特征值对应的特征向量组成的矩阵$Y\in R^{d\times N}$，由于$M$最小的特征值一般为$0$，所以去掉最小的特征值，选择$M$的第$2$到第$d+1$特征值对应的特征向量。这里分析一下为什么$M$最小的特征值为$0$：矩阵$W^{\prime }$的每一列的和都为$1$，那么有$W^{\prime T}{1}_N=1_N$，这里的$1_N$指的是长度为$N$的全$1$列向量，所以有$(W^{\prime T}-I)1_N=0$，即$W^{\prime T}-I$为奇异矩阵，所以$M$也是奇异矩阵，也就是说$0$是$M$的一个特征值。
  然后把代码贴出来，详细代码见我的GitHub，首先是求距离矩阵然后计算K近邻的索引：

def cal_pairwise_dist(data):
	expand_ = data[:, np.newaxis, :]
	repeat1 = np.repeat(expand_, data.shape[0], axis=1)
	repeat2 = np.swapaxes(repeat1, 0, 1)
	D = np.linalg.norm(repeat1 - repeat2, ord=2, axis=-1, keepdims=True).squeeze(-1)
	return D
	
def get_n_neighbors(data, n_neighbors=10):
	dist = cal_pairwise_dist(data)
	dist[dist < 0] = 0
	n = dist.shape[0]
	N = np.zeros((n, n_neighbors))
	for i in range(n):
		# np.argsort 列表从小到大的索引
		index_ = np.argsort(dist[i])[1:n_neighbors+1]
		N[i] = N[i] + index_
	return N.astype(np.int32)                         # [n_features, n_neighbors]

然后是LLE算法的核心：

def lle(data, n_dims=2, n_neighbors=10):
	N = get_n_neighbors(data, n_neighbors)            # k近邻索引
	n, D = data.shape                                 # n_samples, n_features
	# prevent Si to small
	if n_neighbors > D:
		tol = 1e-3
	else:
		tol = 0
	# calculate W
	W = np.zeros((n_neighbors, n))
	I = np.ones((n_neighbors, 1))
	for i in range(n):                                # data[i] => [1, n_features]
		Xi = np.tile(data[i], (n_neighbors, 1)).T     # [n_features, n_neighbors]
		                                              # N[i] => [1, n_neighbors]
		Ni = data[N[i]].T                             # [n_features, n_neighbors]
		Si = np.dot((Xi-Ni).T, (Xi-Ni))               # [n_neighbors, n_neighbors]
		Si = Si + np.eye(n_neighbors)*tol*np.trace(Si)
		Si_inv = np.linalg.pinv(Si)
		wi = (np.dot(Si_inv, I)) / (np.dot(np.dot(I.T, Si_inv), I)[0,0])
		W[:, i] = wi[:,0]
	W_y = np.zeros((n, n))
	for i in range(n):
		index = N[i]
		for j in range(n_neighbors):
			W_y[index[j],i] = W[j,i]
	I_y = np.eye(n)
	M = np.dot((I_y - W_y), (I_y - W_y).T)
	eig_val, eig_vector = np.linalg.eig(M)
	index_ = np.argsort(np.abs(eig_val))[1:n_dims+1]
	Y = eig_vector[:, index_]
	return Y

  最后贴一张实验效果图，瑞士卷降维的：