DBSCAN密度聚类算法

最新推荐文章于 2024-03-09 22:02:54 发布

处女座程序员的朋友

最新推荐文章于 2024-03-09 22:02:54 发布

阅读量2.2k

点赞数

DBSCAN(Density-Based Spatial Clustering of Applications with Noise，基于密度的抗噪聚类方法)。和K-Means，BIRCH这些一般只适用于凸样本集的聚类相比，DBSCAN既可以适用于凸样本集，也可以适用于非凸样本集。
1. 密度聚类原理
DBSCAN是一种基于密度的聚类算法，这类密度聚类算法一般假定类别可以通过样本 分布的紧密程度决定。同一类别的样本，他们之间紧密相连，也就是说，在该类别任意样本周围不远处一定有同类别的样本存在。
通过将紧密相连的样本划为一类，这样就得到了一个聚类类别。通过将所有各组紧密相连的样本划为各个不同的类别，我们就得到了最终的所有聚类类别结果。
2. DBSCAN密度定义
DBSCAN是基于一组邻域来描述样本集的紧密程度的，参数(

ϵϵ, MinPts)用来描述邻域的样本分布紧密程度。其中，

ϵϵ描述了某一样本邻域的距离阈值(与该样本的距离至少要小于该值才能算该样本领域中的样本)，

MinPtsMinPts描述了某一样本的距离为

ϵϵ的邻域中样本个数的阈值（与该样本距离小于

ϵϵ的样本个数超过

MinPtsMinPts才可能构成一个类）。
假设我的样本集是

D=(x1,x2,…,xm)D=(x1,x2,…,xm),则DBSCAN具体的密度描述定义如下：
1）

ϵϵ-邻域：对于

xj∈Dxj∈D，其

ϵϵ-邻域包含样本集D中与

xjxj的距离不大于

ϵϵ的子样本集，即

Nϵ(xj)={xi∈D|distance(xi,xj)≤ϵ}Nϵ(xj)={xi∈D|distance(xi,xj)≤ϵ}, 这个子样本集的个数记为

|Nϵ(xj)||Nϵ(xj)|。
2) 核心对象：对于任一样本

xj∈Dxj∈D，如果其

ϵϵ-邻域对应的

Nϵ(xj)Nϵ(xj)至少包含

MinPtsMinPts个样本，即如果

|Nϵ(xj)|≥MinPts|Nϵ(xj)|≥MinPts，则

xjxj是核心对象。
3）密度直达：如果

xixi位于

xjxj的

ϵϵ-邻域中，且

xjxj是核心对象，则称

xixi由

xjxj密度直达。注意反之不一定成立，即此时不能说

xjxj由

xixi密度直达, 除非且

xixi也是核心对象。
4）密度可达：对于

xixi和

xjxj,如果存在样本序列

p1,p2,...,pTp1,p2,...,pT,满足

p1=xi,pT=xjp1=xi,pT=xj, 且

pt+1pt+1由

ptpt，式中

1≤t≤T−11≤t≤T−1密度直达，则称

xjxj由

xixi密度可达。也就是说，密度可达满足传递性。此时序列中的传递样本

p−1,p−2,...,pT−1p−1,p−2,...,pT−1均为核心对象，因为只有核心对象才能使其他样本密度直达。密度可达可以理解为本来直达不了，但通过一系列中间点架桥的方式到达了，而且是由核心点可达另一个点。发起方一定是核心对象。
注意密度可达也不满足对称性，这个可以由密度直达的不对称性得出。
5）密度相连：对于

xixi和

xjxj,如果存在核心对象样本

xkxk，使

xixi和

xjxj均由

xkxk密度可达，则称

xixi和

xjxj密度相连。注意密度相连关系是满足对称性的。密度相连可以理解为密度可达的升级版，

xixi通过一系列的核心对象密度可达，

xjxj也可以通过同一系列对象密度可达，这样就把

xixi和

xjxj连起来了。

从下图可以很容易看出上述定义，图中MinPts=5，红色的点都是核心对象，因为其ϵ-邻域至少有5个样本。黑色的样本是非核心对象。所有核心对象密度直达的样本在以红色核心对象为中心的超球体内，如果不在超球体内，则不能密度直达。图中用绿色箭头连起来的核心对象组成了密度可达的样本序列。在这些密度可达的样本序列的ϵ-邻域内所有的样本相互都是密度相连的。

3. DBSCAN密度聚类思想

DBSCAN的聚类定义很简单：由密度可达关系导出的最大密度相连的样本集合，即为我们最终聚类的一个类别，或者说一个簇。
这个DBSCAN的簇里面可以有一个或者多个核心对象。如果只有一个核心对象，则簇里其他的非核心对象样本都在这个核心对象的ϵ-邻域里；如果有多个核心对象，则簇里的任意一个核心对象的ϵ-邻域中一定有一个其他的核心对象，否则这两个核心对象无法密度可达。这些核心对象的ϵ-邻域里所有的样本的集合组成的一个DBSCAN聚类簇。
那么怎么才能找到这样的簇样本集合呢？DBSCAN使用的方法很简单，它任意选择一个没有类别的核心对象作为种子，然后找到所有这个核心对象能够密度可达的样本集合，即为一个聚类簇。接着继续选择另一个没有类别的核心对象去寻找密度可达的样本集合，这样就得到另一个聚类簇。一直运行到所有核心对象都有类别为止。

基本上这就是DBSCAN算法的主要内容了，是不是很简单？但是我们还是有三个问题没有考虑。
第一个是一些异常样本点或者说少量游离于簇外的样本点，这些点不在任何一个核心对象在周围，在DBSCAN中，我们一般将这些样本点标记为噪音点。
第二个是距离的度量问题，即如何计算某样本和核心对象样本的距离。在DBSCAN中，一般采用最近邻思想，采用某一种距离度量来衡量样本距离，比如欧式距离。这和KNN分类算法的最近邻思想完全相同。对应少量的样本，寻找最近邻可以直接去计算所有样本的距离，如果样本量较大，则一般采用KD树或者球树来快速的搜索最近邻。最近邻的思想，距离度量，KD树和球树可参考原文作者的另一篇文章《K近邻法(KNN)原理小结》。
第三种问题比较特殊，某些样本可能到两个核心对象的距离都小于ϵ，但是这两个核心对象由于不是密度直达，又不属于同一个聚类簇，那么如果界定这个样本的类别呢？一般来说，此时DBSCAN采用先来后到，先进行聚类的类别簇会标记这个样本为它的类别。也就是说BDSCAN的算法不是完全稳定的算法。

4. DBSCAN聚类算法

下面我们对DBSCAN聚类算法的流程做一个总结。
输入：样本集D=(x1,x2,...,xm)，邻域参数(ϵ,MinPts), 样本距离度量方式
输出：簇划分C.　
1）初始化核心对象集合Ω=∅, 初始化聚类簇数k=0，初始化未访问样本集合Γ=D, 簇划分C=∅（初始化的时候是最坏的结果：没有核心对象，没有聚类簇）
2) 对于j=1,2,...m, 按下面的步骤找出所有的核心对象：
a) 通过距离度量方式，找到样本xj的ϵ-邻域子样本集Nϵ(xj)
b) 如果子样本集样本个数满足|Nϵ(xj)|≥MinPts，将样本xj加入核心对象样本集合：Ω=Ω⋃{xj}
3）如果核心对象集合Ω=∅，则算法结束，否则转入步骤4.(没有核心对象无法聚类)
4）在核心对象集合Ω中，随机选择一个核心对象o，初始化当前簇核心对象队列Ωcur=o, 初始化类别序号k=k+1，初始化当前簇样本集合Ck={o}, 更新未访问样本集合Γ=Γ−{o}。（可以从任务一个核心对象开始进行簇集合的搜索）
5）如果当前簇核心对象队列Ωcur=∅，则当前聚类簇Ck生成完毕, 更新簇划分C=C1,C2,...,Ck, 更新核心对象集合Ω=Ω−Ck，转入步骤3。
6）在当前簇核心对象队列Ωcur中取出一个核心对象o′,通过邻域距离阈值ϵ找出所有的ϵ-邻域子样本集Nϵ(o')，令Δ=Nϵ(o')⋂Γ, 更新当前簇样本集合Ck=Ck⋃Δ, 更新未访问样本集合Γ=Γ−Δ, 更新Ωcur=Ωcur⋃(Nϵ(o')⋂Ω)，转入步骤5.
输出结果为：簇划分C={C1,C2,...,Ck}

5. DBSCAN小结

DBSCAN的主要优点有：
1）可以对任意形状的稠密数据集进行聚类，相对的，K-Means之类的聚类算法一般只适用于凸数据集。
2）可以在聚类的同时发现异常点，对数据集中的异常点不敏感。
3）聚类结果没有偏倚，相对的，K-Means之类的聚类算法初始值对聚类结果有很大影响。

DBSCAN的主要缺点有：
1）如果样本集的密度不均匀、聚类间距差相差很大时，聚类质量较差，这时用DBSCAN聚类一般不适合。
2）如果样本集较大时，聚类收敛时间较长，此时可以对搜索最近邻时建立的KD树或者球树进行规模限制来改进。
3）调参相对于传统的K-Means之类的聚类算法稍复杂，主要需要对距离阈值ϵ，邻域样本数阈值MinPts联合调参，不同的参数组合对最后的聚类效果有较大影响。

6. DBSCAN Python实现

来源
计算过程

Created with Raphaël 2.1.0开始读入数据找一未分类点扩散是否还有未分类数据输出结果结束yesno

样本样例

/* 788points.txt */
15.55,28.65
14.9,27.55
14.45,28.35
14.15,28.8
13.75,28.05
13.35,28.45
13,29.15
13.45,27.5
13.6,26.5
12.8,27.35
12.4,27.85
12.3,28.4
12.2,28.65
13.4,25.1
12.95,25.95

代码实现

# -*- coding: utf-8 -*-
__author__ = 'Wsine'

import numpy as np
import matplotlib.pyplot as plt
import math
import time
import sys

UNCLASSIFIED = False
NOISE = 0

def loadDataSet(fileName, splitChar='\t'):
    """
    输入：文件名
    输出：数据集
    描述：从文件读入数据集
    """
    dataSet = []
    with open(fileName) as fr:
        for line in fr.readlines():
            curline = line.strip().split(splitChar)
            fltline = list(map(float, curline))
            dataSet.append(fltline)
    return dataSet

def dist(a, b):
    """
    输入：向量A, 向量B
    输出：两个向量的欧式距离
    """
    return math.sqrt(np.power(a - b, 2).sum())

def eps_neighbor(a, b, eps):
    """
    输入：向量A, 向量B
    输出：是否在eps范围内
    """
    return dist(a, b) < eps

def region_query(data, pointId, eps):
    """
    输入：数据集, 查询点id, 半径大小
    输出：查询点eps范围内的点的其他点id（包括查询点本身）
    """
    nPoints = data.shape[1]
    seeds = []
    for i in range(nPoints):
        if eps_neighbor(data[:, pointId], data[:, i], eps):#如果距离小于eps即被记录
            if i !=pointId:
                seeds.append(i)
    return seeds

def expand_cluster(data, clusterResult, pointId, clusterId, eps, minPts):
    """
    输入：数据集, 分类结果, 待分类点id, 簇id, 半径大小, 最小点个数
    输出：能否成功分类
    #这个核心函数中，会判断某个点是不同是否是核心对象，如果不是，暂时将其判断噪声点，可能会误判，但会在其他点的判断中得到纠正
    #如果是核心对象，则会以此点为基础生成一个聚类，并将其周围eps距离内的点标识为同一类；在此基础上，寻找该核心对象eps距离内的其他核心对象，将另一核心对象及另一核心对象周围点划分原始
    #核心对象同一类，并不判断扩展，直至找不到核心对象
    """
    seeds = region_query(data, pointId, eps)
    if len(seeds) < minPts: # 不满足minPts条件的为噪声点（应该是非核心对象）
        clusterResult[pointId] = NOISE#某点不是核心对象，暂时判其为噪声点（类别用0来表示），但如果该点虽然自己不是核心对象，但在其他点判断时，如果其他点是核心对象，
        # 而它又在另一点的eps距离内，它仍然会被重新分到另一类中，因而这里不用担心被误判
        return False
    else:
        clusterResult[pointId] = clusterId # 划分到该簇（由核心对象来代表该簇）
        for seedId in seeds:
            clusterResult[seedId] = clusterId#将周围的点一同划分到该簇

        while len(seeds) > 0: # 通过判断周围的点是否为核心对象，持续扩张
            currentPoint = seeds[0]
            if clusterResult[currentPoint]!=0:
                queryResults = region_query(data, currentPoint, eps)
                #这里可以优化，因为如果之前已经判断为非核心对象则对应clusterResult为0,没必要再算一次，从来没判断过的其实是False,两者还是有区别的
                #同是在seed中应该排除原始核心对象，否则在扩展时会重复算；同时利他其他核心对象扩展时，也就排除其他核心对象。修改的方法应该是region_query函数的返回值就不应该包括查询点本身。
                if len(queryResults) >= minPts:#eps距离内的某一点是核心对象
                    for i in range(len(queryResults)):
                        resultPoint = queryResults[i]
                        if clusterResult[resultPoint] == UNCLASSIFIED:#因为两个距离在eps内的核心对象会将彼此周围的点连成一片，即距离可达，因而这些点被判断为原始核心对象同一类
                            #并且将这些点也归到原始核心对象的周围点中去，从而实现不同扩展，这是整个程序中最巧妙和关键的地方。
                            seeds.append(resultPoint)
                            clusterResult[resultPoint] = clusterId
                        elif clusterResult[resultPoint] == NOISE:#将另一核心对象周围的非核心对象标识为原始核心对象同一类，
                            clusterResult[resultPoint] = clusterId
            seeds = seeds[1:]#不断更新，已经判断过点会被移除，直至seed为空；即原始核心对象eps距离内的点都进行了是否为核心对象的判断。
        return True

def dbscan(data, eps, minPts):
    """
    输入：数据集, 半径大小, 最小点个数
    输出：每个样本的类别，和总的类别数
    """
    clusterId = 1#类别号从1开始，用什么来标识类型本来是无所谓的，但如果从1开始，得到聚类结果的同时也就得到簇的个数。
    nPoints = data.shape[1]
    clusterResult = [UNCLASSIFIED] * nPoints#初始每个样本的类别为False，即还未参考聚类过程，最终聚类后的结果为类别标识，即上面的clusterId
    for pointId in range(nPoints):#逐个点进行类别判定
        point = data[:, pointId]
        if clusterResult[pointId] == UNCLASSIFIED:#如果还未被聚到某一类（虽然是逐个点判断，但只要之前已经生成了该点类别就会跳过去）
            if expand_cluster(data, clusterResult, pointId, clusterId, eps, minPts):#这里没有定义全局变量，expand_cluster也只返回True和False但clusterResult却得到了更新
                clusterId = clusterId + 1#以某一点为核心对象进行扩展，连成一片，之后就是一个类别自然就加1了。
    return clusterResult, clusterId - 1

def plotFeature(data, clusters, clusterNum):
    nPoints = data.shape[1]
    matClusters = np.mat(clusters).transpose()
    fig = plt.figure()
    scatterColors = ['black', 'blue', 'green', 'yellow', 'red', 'purple', 'orange', 'brown']
    ax = fig.add_subplot(111)
    for i in range(clusterNum + 1):
        colorSytle = scatterColors[i % len(scatterColors)]#如果类别很多，就可能存在颜色重复
        subCluster = data[:, np.nonzero(matClusters[:, 0].A == i)]
        ax.scatter(subCluster[0, :].flatten().A[0], subCluster[1, :].flatten().A[0], c=colorSytle, s=50)

def main():
    filePath="%s/788points.txt"%(sys.path[0])
    dataSet = loadDataSet(filePath, splitChar=',')
    dataSet = np.mat(dataSet).transpose()#将数据变成一列一个样本
    # print(dataSet)
    clusters, clusterNum = dbscan(dataSet, 2, 14)
    print("cluster Numbers = ", clusterNum)
    # print(clusters)
    plotFeature(dataSet, clusters, clusterNum)


if __name__ == '__main__':
    start = time.clock()
    main()
    end = time.clock()
    print('finish all in %s' % str(end - start))
    plt.show()

结果如下：
这里写图片描述

阅读全文

处女座程序员的朋友

关注

0
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
DBSCAN密度聚类算法

DBSCAN(Density-Based Spatial Clustering of Applications with Noise，基于密度的抗噪聚类方法)。和K-Means，BIRCH这些一般只适用于凸样本集的聚类相比，DBSCAN既可以适用于凸样本集，也可以适用于非凸样本集。 1. 密度聚类原理 DBSCAN是一种基于密度的聚类算法，这类密度聚类算法一般假定类别可以通过样本分布的紧密程度决...
复制链接

扫一扫