引言

本节将介绍密度聚类——$\text{DBSCAN}$方法。

对于其他聚类任务的笔记：

• $\text{K-Means}$聚类算法：传送门
• 谱聚类算法$(\text{Spectral clustering})$：传送门
• 高斯混合模型$(\text{Gaussian Mixture Model,GMM})$：传送门

基本思想

$\text{DBSCAN}$全称$\text{Density-Based Spatial Clustering of Application with Noise}$。是一种基于密度的聚类算法$(\text{Density-Based Clustering})$。而这里的密度是指样本分布的紧密程度。而密度聚类的思想假设：样本如果属于同一类别(簇)，那么该类别内的样本点之间紧密相连。

何为紧密相连$?$自然是指样本之间的距离足够小，小到没有办法将其划分给其他类别。我们通过找到一个初始位置后，通过查找与其紧密相连的样本，得到一个聚类簇；再次选择初始位置，反复执行上述操作，直到所有数据均有其归属簇为止。

概念介绍

$\text{DBSCAN}$既然属于聚类任务，说明它依然属于无监督学习任务的范畴。它一共包含两个参数：

• $ϵ$：被称作邻域半径，它描述了某样本邻域的距离阈值；
• $\text{MinPts}$：它描述了某样本，其距离为$ϵ$的邻域中样本数量的阈值。

给定数据集 D = { x ( i ) } i = 1 N ; x ( i ) ∈ R p \mathcal D = \{x^{(i)}\}_{i=1}^N;x^{(i)} \in \mathbb R^p D={x(i)}i=1N​;x(i)∈Rp，对相关概念进行如下定义：

• $ϵ$-邻域：它描述样本集合$\mathcal{D}$中到某样本 x ( j ) ( j ∈ { 1 , 2 , ⋯   , N } ) x^{(j)}(j \in \{1,2,\cdots,N\}) x(j)(j∈{1,2,⋯,N})的距离不大于$ϵ$的样本$x^{(i)}$组成的集合。使用${\mathcal{N}}_{ϵ}(x^{(j)})$表示：
  样本间距离在$\text{K-Means}$中介绍过‘明可夫斯基距离’$(\text{Minkowski Distance})$。其他的距离计算方式先挖一个坑，后续来填。
  N ϵ ( x ( i ) ) = { x ( i ) ∈ D ∣ Dist ( x ( i ) , x ( j ) ) ≤ ϵ } \mathcal N_{\epsilon}(x^{(i)}) = \{x^{(i)} \in \mathcal D \mid \text{Dist}(x^{(i)},x^{(j)}) \leq \epsilon\} Nϵ​(x(i))={x(i)∈D∣Dist(x(i),x(j))≤ϵ}
• 核心对象$(\text{Core Object})$：如果样本$x^{(j)}$的$ϵ$-邻域内的样本数量$|{\mathcal{N}}_{ϵ}(x^{(j)})|\ge \text{MinPts}$，那么称样本点$x^{(j)}$是一个核心对象：
  
• 密度直达$(\text{Directly Density-Reachable})$：在样本点$x^{(i)}$位于以$x^{(j)}$为核心对象的$ϵ$-邻域内，则称$x^{(i)}$由$x^{(j)}$密度直达：
  • 需要注意的是，这里包含一个由核心对象$x^{(j)}$到ε-邻域内样本点$x^{(i)}$的方向性，单向。
  • 密度直达不具备对称性。也就是说，$x^{(i)}$由$x^{(j)}$密度直达，但$x^{(j)}$不一定由$x^{(i)}$密度直达。
    
• 密度可达$(\text{Density-Reachable})$：对于样本点$x^{(i)},x^{(j)}$，如果存在样本序列${\mathcal{P}}_1,{\mathcal{P}}_2,\cdots ,{\mathcal{P}}_n$，其中${\mathcal{P}}_1=x^{(j)},{\mathcal{P}}_n=x^{(i)}$，并且${\mathcal{P}}_{k+1}$由${\mathcal{P}}_k(k=1,2,\cdots ,n-1)$密度直达，则称$x^{(i)}$由$x^{(j)}$密度可达：
  • 密度可达具有直递性。也就是说，如果$x^{(i)}$由$x^{(j)}$密度可达,$x^{(k)}$由$x^{(i)}$密度可达,那么$x^{(k)}$由$x^{(j)}$密度可达。
  • 密度可达同样不具备对称性。从明可夫斯基距离的角度解释对称性，文章见下方链接。如果使用$3$阶明可夫斯基距离($L_3$范数)来描述样本点之间的距离:
    $$\text{Dist}(x^{(i)},x^{(j)})=\sqrt[3]{\sum _{k=1}^p|x_k^{(i)}-x_k^{(j)}{|}^3}=||x^{(i)}-x^{(j)}|{|}_3$$
    那么可能出现根号内的项$\begin{array}{r}\sum _{k=1}^p|x_k^{(i)}-x_k^{(j)}{|}^3\end{array}$是一个负值，从而产生一个‘负距离’;相反，如果$\begin{array}{r}\sum _{k=1}^p|x_k^{(j)}-x_k^{(i)}{|}^3\end{array}$结果是一个‘正距离’，最终导致$\text{Dist}(x^{(i)},x^{(j)})\ne \text{Dist}(x^{(j)},x^{(i)})$。
    
• 密度相连$(\text{Density-Connected})$：对于样本点$x^{(i)},x^{(j)}$，若存在样本点$x^{(k)}$，使得$x^{(i)},x^{(j)}$均由$x^{(k)}$密度可达，则称$x^{(i)},x^{(j)}$密度相连。
  • 需要注意的是，密度相连指的是$x^{(i)},x^{(j)}$之间的关系，$x^{(k)}$仅是一个媒介。
  • 密度相连关系满足对称性。也就是说，$x^{(i)},x^{(j)}$之间的关系是无向的。
    

基于上述概念，$\text{DBSCAN}$对于簇的概念定义为：最大的密度相连样本集合。对于某个簇$\mathcal{C}$，它包含如下属性：

• 连接性：簇$\mathcal{C}$中的任意两个样本点之间密度相连；
• 最大性：已知样本点$x^{(i)}\in \mathcal{C}\Rightarrow$任意由$x^{(i)}$密度可达的样本点均$\in \mathcal{C}$。

算法过程

整个$\text{DBSCAN}$算法的核心在于：找到满足上述两种性质的簇。这个簇的表示为：核心对象$x$密度可达的所有样本组成的集合：
这个集合中自然也可能包含其他的‘核心对象’，并且该集合内任意两个样本之间均‘密度相连’。

X = { x ′ ∈ D ∣ x ⇒ x ′ ( Density-Reachable ) } \mathcal X = \{x' \in \mathcal D \mid x \Rightarrow x'(\text{Density-Reachable})\} X={x′∈D∣x⇒x′(Density-Reachable)}
因此，该算法主要包括两个部分：

• 基于超参数:邻域半径$ϵ$;邻域内样本数量阈值$\text{MinPts}$，找出数据集$\mathcal{D}$内部所有的核心对象，最终构成核心对象集合$\Omega$；
• 以任一核心对象为出发点，找出其所有密度可达的样本，构成簇；直到所有核心对象均被访问为止。
  需要注意的是，算法的迭代结束方式是‘所有核心对象被访问，而不是$\mathcal{D}$中所有样本。数据集’$\mathcal{D}$中不属于任何簇的样本被认为是‘噪声’$(\text{Noise})$或者‘异常’$(\text{Anomaly})$样本。

完整算法描述

输入部分：

• 数据集 D = { x ( i ) } i = 1 N \mathcal D = \{x^{(i)}\}_{i=1}^N D={x(i)}i=1N​；
• 参数：邻域半径$ϵ$；样本数量阈值$\text{MinPts}$

核心对象查找：

• 初始化核心对象集合$\Omega =\varnothing$
• 对每一个样本点$x^{(j)}(j=1,2,\cdots ,N)$进行遍历：
• \quad 计算样本点$x^{(j)}$的$ϵ$-邻域${\mathcal{N}}_{ϵ}(x^{(j)})$；
• \quad 判断邻域样本数量$|{\mathcal{N}}_{ϵ}(x^{(j)})|$和阈值$\text{MinPts}$之间的大小关系；
  • 若$|{\mathcal{N}}_{ϵ}(x^{(j)})|\ge \text{MinPts}\Rightarrow x^{(j)}$是核心对象，加入$\Omega$集合中： Ω = Ω ∪ { x ( j ) } \Omega = \Omega \cup \{x^{(j)}\} Ω=Ω∪{x(j)}
  • 不是核心对象的样本点，$\text{Continue}$即可。
• 最终返回核心对象集合$\Omega$。

寻找最大簇的过程

• 聚类簇数初始化：$k=0$；
• 未访问的样本集合：$\Gamma =\mathcal{D}$；
• 在核心对象集合$\Omega \ne \varnothing$的条件下，执行如下迭代过程：
• \quad 记录当前迭代下，未访问的样本集合${\Gamma }_{old}=\Gamma$；
• \quad 从核心对象集合$\Omega$中随机选取一个核心对象$o$，初始化队列$\mathcal{Q}=<o>$；
• \quad 与此同时，将核心对象$o$从$\Gamma$中去除 Γ = Γ \ { o } \Gamma = \Gamma \backslash \{o\} Γ=Γ\{o}；
  \quad 即将对核心对象$o$的所有密度可达样本进行发掘。反斜杠$\backslash$表示集合之间的相对差集。

  • 在队列$\mathcal{Q}\ne \varnothing$条件下，执行如下迭代过程：
    如果$\mathcal{Q}=\varnothing$,这意味着与核心对象$o$密度可达的所有样本均被找到。这里也有可能包含其他的核心对象。

  • \quad 取出队列中的首个样本$q$，并判别该样本点是否为核心对象；
    这个队列中，初始化是一个随机的‘核心对象‘$o$，但队列中存储的是与$o$密度可达的所有样本点。我们需要从这些样本点里找出‘核心对象’，从而使其继续扩张、延伸。
    如果$|{\mathcal{N}}_{ϵ}(q)|\ge \text{MinPts}$，这意味着$q$是核心对象，并找出$q$的$ϵ$-邻域${\mathcal{N}}_{ϵ}(q)$和未访问样本$\Gamma$之间的重合样本$\Delta$：$\Delta ={\mathcal{N}}_{ϵ}(q)\cap \Gamma$，并将这些样本$\Delta$重新放回至队列$\mathcal{Q}$中(在放回同时，将$\Gamma$中的相应样本一并消除：$\Gamma =\Gamma \backslash \Delta$)。

  • 持续迭代下去，当$\mathcal{Q}$中没有元素时(子循环迭代结束)，意味着这个最大簇中的样本已全部找全。与此同时，$\Gamma$中的样本已经减少了${\Gamma }_{old}-\Gamma$，也就是簇${\mathcal{C}}_k$的样本数量：
    $${\mathcal{C}}_k={\Gamma }_{old}\backslash \Gamma$$

• 本次迭代最后，将簇${\mathcal{C}}_k$中的所有核心对象在$\Omega$中全部消除。也就是说，重新从剩余的核心对象中找出最大簇：
  $$\Omega =\Omega \backslash {\mathcal{C}}_k$$
• 最终可得到一系列簇的结果： { C 1 , C 2 , ⋯   , C k } \{\mathcal C_1,\mathcal C_2,\cdots,\mathcal C_k\} {C1​,C2​,⋯,Ck​}

$\text{DBSCAN}$的优点和缺陷

• 优点：
  和$\text{K-Means}$算法比较，$\text{DBSCAN}$不需要人为输入簇的数量$k$；并且它可以找出任意聚类形状的簇。而$\text{K-Means}$，高斯混合模型它们仅能针对于凸集合的样本聚类。

  在$\text{DBSCAN}$迭代结束后，未访问集合$\Gamma$可能会剩下一些点。这意味着，剩下的点不属于任何聚类簇(噪声、异常)。从这个角度可以看出，在聚类过程可以发现异常样本，并且对其不敏感。

  $\text{DBSCAN}$在初始化时选择核心对象作为初始迭代，而不是随机选择一点。这意味着$\text{DBSCAN}$算法的鲁棒性很强，不会因初始样本对聚类结果产生巨大影响。

• 缺陷：
  如果出现类间差距较大，或者样本集密度不均匀，此时的$\text{DBSCAN}$聚类效果较差。

  它的时间复杂度是不低的。随着样本数量的增加，导致算法收敛时间较长。

  虽然不用人为选择簇的数量，但关于$ϵ,\text{MinPts}$的调节过程是较复杂的。不同的参数组合方式对聚类效果(模型的过拟合、欠拟合)均存在较大影响。

$\text{2023/4/25}$补充：基于$\text{Python}$的代码实现

基于二维特征的数据集分布表示如下：

from sklearn import datasets

NSamples = 150
(DToken,DLabel) = datasets.make_moons(n_samples=NSamples, noise=0.05)

对应的图像结果表示为：

• 基于‘密度聚类’的特性，该算法更适合‘链条状’，并且分布均匀的样本集合。
• 针对聚类任务，这里仅使用$\text{DToken}$信息。
  

$\text{DBSCAN}$聚类算法代码表示如下：

import matplotlib.pyplot as plt
import numpy as np
import random
import math
from queue import Queue
from sklearn import datasets

# NSamples = 100
NSamples = 150
np.random.seed(42)
(DToken,DLabel) = datasets.make_moons(n_samples=NSamples, noise=0.05)


def DrawTestPic(D):

    for (x,y) in D:
        plt.scatter(x,y,c="tab:blue",s=4)
    plt.show()


def DBSCAN(Data,Epsilon,MinPts):

    def CalDistance(Sample1, Sample2):
        """
        Calculate Euclidean distance of Sample1 and Sample2.
        :return:Distance result
        """
        return math.sqrt(((Sample1[0] - Sample2[0]) ** 2) + (Sample1[1] - Sample2[1]) ** 2)

    def GetEpsilonNeighborhood(SamplePoint, Data, Epsilon):
        """
        The simplest way to find,We can use KD-Tree to reduce TimeComplexity.
        :param Sample: SamplePoint
        :return: Epsilon neighborhood of SamplePoint.
        """
        EpsilonNeighList = list()
        for K in Data:
            if tuple(K) == tuple(SamplePoint):
                continue
            else:
                DistKSamplePoint = CalDistance(K, SamplePoint)
                if DistKSamplePoint < Epsilon:
                    EpsilonNeighList.append(tuple(K))
                    
        return EpsilonNeighList

    def DiscrimCoreObject(Data,Epsilon,MinPts):
        """
        Get list of core object.
        :return: CoreObjectList.
        """
        CoreObjectList = list()
        for Sample in Data:
            EpsilonNeighList = GetEpsilonNeighborhood(Sample,Data,Epsilon)
            if len(EpsilonNeighList) >= MinPts:
                CoreObjectList.append(tuple(Sample))

        return CoreObjectList

    def ExecutiveProcess(Data,CoreObjectList):

        def CalRelDifferenceSet(List1,List2):
            """
            Calculate Relative Difference Set of List1 and List2
            :return:
            """
            return list(set(List1).difference(set(List2)))

        def CalIntersection(List1,List2):
            """
            Calculate Intersection Set of List1 and List2.
            :return:
            """
            return list(set(List1).intersection(set(List2)))

        ClusterNum = 0
        ClusterList = list()

        Gamma = [tuple(i) for i in Data.tolist()]
        while CoreObjectList:
            GammaOld = [tuple(i) for i in Gamma]
            RandomIndex = random.randint(0,len(CoreObjectList) - 1)
            RandomCoreObject = CoreObjectList[RandomIndex]
            Q = Queue()
            Q.put(RandomCoreObject)
            Gamma = CalRelDifferenceSet(Gamma,[RandomCoreObject])

            while not Q.empty():
                FirstElem = Q.get()
                EpsilonNeighborL = GetEpsilonNeighborhood(FirstElem,Data,Epsilon)
                if len(EpsilonNeighborL) >= MinPts:
                    Delta = CalIntersection(EpsilonNeighborL,Gamma)
                    for Elem in Delta:
                        Q.put(Elem)
                    Gamma = CalRelDifferenceSet(Gamma,Delta)

            NewCluster = CalRelDifferenceSet(GammaOld,Gamma)
            ClusterList.append(NewCluster)
            CoreObjectList = CalRelDifferenceSet(CoreObjectList,NewCluster)
            ClusterNum += 1

        return ClusterNum,ClusterList

    def PaintCluster(ClusterList):
        ColorList = ["tab:blue","tab:orange","tab:green","tab:red","tab:purple",
                     "tab:brown","tab:pink","tab:gray","tab:olive","tab:cyan"]
        for idx,Cluster in enumerate(ClusterList):
            for (x1,x2) in Cluster:
                plt.scatter(x1,x2,s=4,c=ColorList[idx])
        plt.show()

    ClusterNum,ClusterList = ExecutiveProcess(Data, DiscrimCoreObject(Data, Epsilon, MinPts))
    print(ClusterNum)
    return PaintCluster(ClusterList)

这里已经事先调整好了一组$\text{Epsilon,MinPts}$参数：

if __name__ == '__main__':
	# Check Original Distribution.
	# DrawTestPic(DToken)
    # Two Clusters(standard).
    DBSCAN(DToken,Epsilon=0.2,MinPts=3)

其聚类结果表示如下：

我们再观察另一组$\text{Epsilon,MinPts}$参数：

if __name__ == '__main__':
    # 6 Clusters.
    DBSCAN(DToken, Epsilon=0.13, MinPts=3)

对应聚类结果返回如下：

很明显，由于$ϵ$-邻域过小，导致本该属于同一聚类的样本分段了。这明显是过拟合$(\text{Over-Fitting})$。
$ϵ$-邻域过小，就是‘模型过于复杂’的一种体现。

这种描述范围的思想和$\mathcal{K}$近邻算法之间存在异曲同工之妙：

• $\mathcal{K}$近邻是监督学习，标签都是已知的，仅需要描述范围内的样本数量的分类，再进行比较即可。
• $\text{DBSCAN}$不仅需要设置邻域内样本数量阈值，还要设置邻域半径。它们之间共同点是：都要找最近邻的点。从而通过$\text{KD}$树对样本空间进行划分，这种最近邻样本点查找方式也是不错的选择。

相关参考：
DBSCAN 聚类算法详解
机器学习其中复习
《机器学习》(周志华著) 9.5 密度聚类