谱聚类原理及Python实现

图模型

无向带权图模型 $G=<V,E>$ ，每一条边上的权重 $w_{ij}$ 为两个顶点的相似度，从而可以定义相似度矩阵 $W$ ，此外还可以定义度矩阵 $D$ 和邻接矩阵 $A$ ，从而有拉普拉斯矩阵 $L=D-A$ 。所以本文用到的矩阵总共两个： $L$ 和 $W$ 。

图的分割

一个图 $G$ 可能有很多个子图 $G_i$ （总共 $k$ 个），现在的任务是将大图分成若干小块，要求分法是最佳的。何为“最佳”呢，遍历每一个子图，计算一个切图惩罚，将他们加起来。式中的 $\hat{G}_i$ 表示子图 $G_i$ 的补集，代价函数 $C$ 计算的是连接两个子图之间的权重之和。

C o s t (G_{1}, \dots, G_{k}) = \sum_{i} C (G_{i}, {\hat{G}}_{i}) C (G_{1}, G_{2}) = \sum_{i \in G_{1}, j \in G_{2}} w_{i j}

$Cost(G_1,\cdots, G_k)=\sum_iC(G_i,\hat{G}_i)\\C(G_1,G_2)=\sum_{i\in G_1,j\in G_2} w_{ij}$

根据这个公式，对于下面这个图，假设点7和点8之间的权重值很小，那么很容易有红线所示的划分（假设二分），上面的代价函数计算出来的值很小。但显然绿色线所示才是最佳的分法。

距离度量与邻接矩阵

邻接矩阵某种程度上反映了图中各结点之间的相似性，普通的邻接矩阵元素非0即1，谱聚类中的邻接矩阵用KNN来计算。具体来说，遍历每一个结点 $x_i$ ，根据相似度（或距离）矩阵找出它的 $k$ 个最接近的点，构成 $x_i$ 的邻域 $N_i$ ，然后按以下规则之一构造邻接矩阵。

A_{i j} = A_{j i} = {\begin{matrix} 0 & x_{i} \notin N_{j} a n d x_{j} \notin N_{i} \\ \exp - \frac{| | x_{i} - x_{j} | |^{2}}{2 σ^{2}} & x_{i} \in N_{j} o r x_{j} \in N_{i} \end{matrix}

$A_{ij}=A_{ji}=\left \{ \matrix{0 & x_i\notin N_j\ and x_j \notin \ N_i\\ \exp-\frac{||x_i-x_j||^2}{2\sigma^2} & x_i \in N_j \ or \ x_j \in N_i}\right.$

A_{i j} = A_{j i} = {\begin{matrix} 0 & x_{i} \notin N_{j} o r x_{j} \notin N_{i} \\ \exp - \frac{| | x_{i} - x_{j} | |^{2}}{2 σ^{2}} & x_{i} \in N_{j} a n d x_{j} \in N_{i} \end{matrix}

$A_{ij}=A_{ji}=\left \{ \matrix{0 & x_i\notin N_j\ or \ x_j \notin \ N_i\\ \exp-\frac{||x_i-x_j||^2}{2\sigma^2} & x_i \in N_j \ and \ x_j \in N_i}\right.$

切图聚类

RatioCut 切法

为了解决上面这个局部最优问题，一个很自然的做法就是改进目标函数，要求每个划分出来的子图的结点数尽量大。例如上图，最佳划分对应的两个子图节点数都是4，而局部最优划分有一个子图节点数为1。

R a t i o C u t (G_{1}, \dots, G_{k}) = \sum_{i} \frac{C (G_{i}, {\hat{G}}_{i})}{| {\hat{G}}_{i} |}

$RatioCut(G_1,\cdots, G_k)=\sum_i\frac{C(G_i,\hat{G}_i)}{|\hat{G}_i|}$

为了求解 $\min RatioCut(G_1,\cdots, G_k)$ ，引入指示向量 $f=(f_1,f_2,\cdots,f_k)$ ，每一个 $f_j$ 对应于一个子图 $G_j$ ，是一个 $n$ 维向量，每一维对应图中一个结点。意思就是每个子图 $G_j$ 维护一个 $n$ 维向量，将自己的点指示为常数，其余为0。

h_{j i} = {\begin{matrix} \frac{1}{\sqrt{| G_{j} |}} & v_{i} \in G_{j} \\ 0 & v_{i} \notin G_{j} \end{matrix}

$h_{ji}=\left \{ \matrix{\frac{1}{\sqrt{|G_j|}} & v_i\in G_j\\0 & v_i \notin G_j }\right.$

这样构造矩阵 $H_{k\times n}$ 有个特点，由于子图之间互斥，故 $H$ 每一列只能有一个1，于是 $h_j$ 之间都是正交的（即任意两行正交），因此矩阵相乘有 $H^TH=I$

由拉普拉斯矩阵的性质可知，两个子图的情况：

h_{j}^{T} L h_{j} = \frac{1}{2} \sum_{m} \sum_{n} w_{m n} (h_{j m} - h_{j n})^{2} = \frac{1}{2} (\sum_{m \in G_{j}} \sum_{n \notin G_{j}} w_{m n} (\frac{1}{\sqrt{| G_{j} |}} - 0)^{2} + \sum_{m \notin G_{j}} \sum_{n \in G_{j}} w_{m n} (0 - \frac{1}{\sqrt{| G_{j} |}})^{2}) = \frac{1}{2} (\sum_{m \in G_{j}} \sum_{n \notin G_{j}} \frac{w_{m n}}{| G_{j} |} + \sum_{m \notin G_{j}} \sum_{n \in G_{j}} \frac{w_{m n}}{| G_{j} |}) = \frac{C o s t (G_{j}, {\hat{G}}_{j})}{| G_{j} |} = R a t i o C u t (G_{j}, {\hat{G}}_{j})

$h_j^TLh_j=\frac{1}{2}\sum_m\sum_n w_{mn}(h_{jm}-h_{jn})^2\\ =\frac{1}{2}\left (\sum_{m\in G_j}\sum_{n\notin G_j} w_{mn}(\frac{1}{\sqrt{|G_j|}}-0)^2 +\sum_{m\notin G_j}\sum_{n\in G_j} w_{mn}(0-\frac{1}{\sqrt{|G_j|}})^2 \right )\\ =\frac{1}{2}\left (\sum_{m\in G_j}\sum_{n\notin G_j} \frac{w_{mn}}{|G_j|} +\sum_{m\notin G_j}\sum_{n\in G_j} \frac{w_{mn}}{|G_j|} \right )\\ =\frac{Cost(G_j, \hat{G}_j)}{|G_j|}\\ =RatioCut(G_j, \hat{G}_j)$

好像很长，总结起来就是： $RatioCut(G_j, \hat{G}_j)=h_j^TLh_j$

推广到 $k$ 个子图，于是乎求解 $RatioCut$ 等价于求矩阵 $H^TLH$ 的迹：

R a t i o C u t (G_{1}, G_{2}, \dots, G_{k}) = \sum_{j} h_{j}^{T} L h_{j} = \sum_{j} (H^{T} L H)_{j j} = t r (H^{T} L H)

$RatioCut(G_1,G_2,\cdots,G_k)=\sum_jh_j^TLh_j\\ =\sum_j (H^TLH)_{jj}=tr(H^TLH)$

对于任意一个给定的图，它的拉普拉斯矩阵 $L$ 是固定的，因此优化目标变成求解使得RatioCut最小的 $H$ ，每一个特定的 $H_{n\times k}$ 对应着对图的一种划分方法（ $k$ 分），找到这个 $H$ ，就等于找到了最佳的划分（聚类）。

\begin{matrix} \arg min_{H} t r (H^{T} L H) \\ s . t . & H^{T} H = I \end{matrix}

$\matrix{& \arg \min_H tr(H^TLH) \\s.t. & H^TH = I}$

留意矩阵 $H^TLH$ 是一个 $k\times k$ 对角阵，各元素是 $h_j^TLh_j$ ，想要 $tr$ 最小，即个对角线元素加起来最小，即要求每个优化字母表 $h_j^TLh_j$ 都尽量小。那么要怎么求 $h_j^TLh_j$ 呢？答案是：将问题转化为计算拉普拉斯矩阵 $L$ 的 $k$ 个最小的特征值。
现在我们先做一个归一化，使得任意 $h_{j}$ 满足 $h_{j}^Th_j=1$

h_{j i} \leftarrow \frac{h_{j i}}{{(\sum_{t = 1}^{k} h_{j t}^{2})}^{1 / 2}}

$h_{ji}\leftarrow\frac{h_{ji}}{\left ( \sum_{t=1}^kh^2_{jt}\right )^{1/2}}$

有了这个条件我们就可以利用瑞利熵的性质来求 $L$ 的特征值：

R (L, h_{j}) = \frac{h_{j}^{T} L h_{j}}{h_{j}^{T} h_{j}} = h_{j}^{T} L h_{j} = λ

$R(L,h_j)=\frac{h_j^TLh_j}{h_j^Th_j}=h_j^TLh_j=\lambda$

求得 $k$ 个最小的特征值，对应的 $k$ 个 $n$ 维特征向量拼起来就是我们所需要的 $H$ 矩阵。然而，仅取 $k$ 个特征值的做法会损失信息，因此现在得到的 $H$ 还不能直接用来指示每个结点属于哪个子图。
一般还需要对 $H_{n\times k}$ 做一次 Kmeans 聚类。具体来说，将 $H_{n\times k}$ 的每一行（ $k$ 维向量）当做一个样本的特征向量，然后用Kmeans聚类（设聚类个数是 $K$ ，并没有要求 $K= k$ ），将样本聚成 $C=(c_1,c_2,\cdots, c_K)$ 。

NCut 切法

RatioCut目标函数的分母是子图的点个数，NCut类似，分母换成子图中边的权重之和。

N C u t (G_{1}, \dots, G_{k}) = \sum_{i} \frac{C (G_{i}, {\hat{G}}_{i})}{v o l ({\hat{G}}_{i})} v o l (G =< V, E >) = \sum_{v_{i} \in V} \sum_{v_{j} \in V} w_{i j}

$NCut(G_1,\cdots, G_k)=\sum_i\frac{C(G_i,\hat{G}_i)}{vol(\hat{G}_i)}\\ vol(G=<V,E>)=\sum_{v_i\in V}\sum_{v_j\in V}w_{ij}$

定义指示变量：

h_{j i} = {\begin{matrix} \frac{1}{\sqrt{v o l ({\hat{G}}_{j})}} & v i \in G_{j} \\ 0 & v_{i} \notin G_{j} \end{matrix}

$h_{ji}=\left \{ \matrix{\frac{1}{\sqrt{vol(\hat{G}_j)}} & vi\in G_j\\0 & v_i \notin G_j }\right.$

它的特点是 $H^TDH=I$

h_{j}^{T} D h_{j} = \sum_{j} h_{i j}^{2} d_{j} = \frac{1}{v o l (G_{j})} \sum_{v_{i} \in G_{j}} w_{i} = \frac{v o l (G_{j})}{v o l (G_{j})} = 1

$h_j^TDh_j=\sum_j h^2_{ij}d_j=\frac{1}{vol(G_j)}\sum_{v_i\in G_j}w_i=\frac{vol(G_j)}{vol(G_j)}=1$

同RatioCut，可以推出：

N C u t (G_{j}, {\hat{G}}_{j}) = h_{j}^{T} L h_{j} N C u t (G_{1}, G_{2}, \dots, G_{k}) = \sum_{j} h_{j}^{T} L h_{j} = \sum_{j} (H^{T} L H)_{j j} = t r (H^{T} L H)

$NCut(G_j,\hat{G}_j)=h_j^TLh_j\\ NCut(G_1,G_2,\cdots,G_k)=\sum_jh_j^TLh_j =\sum_j (H^TLH)_{jj}=tr(H^TLH)$

优化目标：

\begin{matrix} \arg min_{H} t r (H^{T} L H) \\ s . t . & H^{T} D H = I \end{matrix}

$\matrix{& \arg \min_H tr(H^TLH) \\s.t. & H^TDH = I}$

令 $H=D^{-1/2}F$ ， $H^TLH=F^TD^{-1/2}LD^{-1/2}F$ ， $H^TDH=F^TF=I$ ，即：

\begin{matrix} \arg min_{F} t r (F^{T} D^{- 1 / 2} L D^{- 1 / 2} F) \\ s . t . & F^{T} F = I \end{matrix}

$\matrix{& \arg \min_F tr(F^TD^{-1/2}LD^{-1/2}F) \\s.t. & F^TF = I}$

所以问题变成了求矩阵 $D^{-1/2}LD^{-1/2}$ 的 $k$ 个最小的特征值。

Python实现

谱聚类整体流程

计算距离矩阵（例如欧氏距离）
利用KNN计算邻接矩阵 $A$
由 $A$ 计算度矩阵 $D$ 和拉普拉斯矩阵 $L$
标准化 $L\rightarrow D^{-1/2}LD^{-1/2}$
对矩阵 $D^{-1/2}LD^{-1/2}$ 进行特征值分解，得到特征向量 $H_{nn}$
将 $H_{nn}$ 当成样本送入 Kmeans 聚类
获得聚类结果 $C=(C_1,C_2,\cdots,C_k)$

1. 距离矩阵

def euclidDistance(x1, x2, sqrt_flag=False):
    res = np.sum((x1-x2)**2)
    if sqrt_flag:
        res = np.sqrt(res)
    return res

def calEuclidDistanceMatrix(X):
    X = np.array(X)
    S = np.zeros((len(X), len(X)))
    for i in range(len(X)):
        for j in range(i+1, len(X)):
            S[i][j] = 1.0 * euclidDistance(X[i], X[j])
            S[j][i] = S[i][j]
    return S

2. 邻接矩阵

def myKNN(S, k, sigma=1.0):
    N = len(S)
    A = np.zeros((N,N))

    for i in range(N):
        dist_with_index = zip(S[i], range(N))
        dist_with_index = sorted(dist_with_index, key=lambda x:x[0])
        neighbours_id = [dist_with_index[m][1] for m in range(k+1)] # xi's k nearest neighbours

        for j in neighbours_id: # xj is xi's neighbour
            A[i][j] = np.exp(-S[i][j]/2/sigma/sigma)
            A[j][i] = A[i][j] # mutually

    return A

3. 标准化的拉普拉斯矩阵

def calLaplacianMatrix(adjacentMatrix):

    # compute the Degree Matrix: D=sum(A)
    degreeMatrix = np.sum(adjacentMatrix, axis=1)

    # compute the Laplacian Matrix: L=D-A
    laplacianMatrix = np.diag(degreeMatrix) - adjacentMatrix

    # normailze
    # D^(-1/2) L D^(-1/2)
    sqrtDegreeMatrix = np.diag(1.0 / (degreeMatrix ** (0.5)))
    return np.dot(np.dot(sqrtDegreeMatrix, laplacianMatrix), sqrtDegreeMatrix)

4. 特征值分解

lam, H = np.linalg.eig(Laplacian) # H'shape is n*n

5. Kmeans

from sklearn.cluster import KMeans
def spKmeans(H):
    sp_kmeans = KMeans(n_clusters=2).fit(H)
    return sp_kmeans.labels_

github

https://github.com/SongDark/SpectralClustering

聚类结果如下，左边是谱聚类，右边是Kmeans聚类，显然谱聚类效果更好。其实sklearn已经有实现谱聚类（sklearn.cluster.SpectralClustering），嫌麻烦的可以直接调用，我只是为了搞懂谱聚类算法的一些细节才参照着其他文章自己用python重新实现了一遍。

总结

谱聚类是一种基于数据相似度矩阵的聚类方法，它定义了子图划分的优化目标函数，并作出改进（RatioCut和NCut），引入指示变量，将划分问题转化为求解最优的指示变量矩阵 $H$ 。然后利用瑞利熵的性质，将该问题进一步转化为求解拉普拉斯矩阵的 $k$ 个最小特征值，最后将 $H$ 作为样本的某种表达，使用传统的聚类方法进行聚类。
我对于谱聚类的理解是，原本相似度矩阵就是对样本点的一种特征表达（特征维数等于样本数），现在进行了谱聚类求得的特征值矩阵，实际上是对原始特征矩阵的一种降维（也可能是升维），总之就是将样本从原始空间变换（可能是线性的也可能是非线性的）到另一个空间，在这个空间中具有良好的全局欧式性。

参考资料

【博客】谱聚类（spectral clustering）原理总结
 【博客】谱聚类（spectral clustering)及其实现详解
 【博客】谱聚类算法(Spectral Clustering)
【Codes】pspectralclustering
【Paper】Parallel Spectral Clustering in Distributed Systems
【API】sklearn.cluster.SpectralClustering
【Demo】Comparing different clustering algorithms on toy datasets

谱聚类（Spectral Clustering）原理及Python实现