机器学习（八）：DBSCAN算法（基础篇）

最新推荐文章于 2024-03-04 11:08:25 发布

Auraros

最新推荐文章于 2024-03-04 11:08:25 发布

阅读量1.3k

点赞数 1

分类专栏： # 机器学习文章标签：密度聚类 DBSCAN算法 DBSCAN 密度聚类算法实现 DBSCAN算法python实现

本文链接：https://blog.csdn.net/qq_43634001/article/details/95938145

版权

机器学习专栏收录该内容

26 篇文章 21 订阅

订阅专栏

机器学习（八）：DBSCAN算法（基础篇）

K-Means算法和 Mean Shift算法都是基于距离的聚类算法，基于距离的聚类算法的聚类结果是球状的簇，当数据集中的聚类结果是非球状结构时，基于距离的聚类算法的聚类效果并不好。
在这里插入图片描述
与基于距离的聚类算法不同的是，基于密度的聚类算法可以发现任意形状的聚类。在基于密度的聚类算法中，通过在数据集中寻找被低密度区域分离的高密度区域，将分离出的高密度区域作为一个独立的类别。

密度聚类

密度聚类也被称作“基于密度的聚类”（density-based clustering），此算法假设聚类结构能通过样本分布的紧密程度确定，通常情况下，密度聚类算法从样本密度的角度来考察样本之间的可连接性，并基于可连接样本不断扩展聚类以获取最终的聚类结果。

DBSCAN算法

DBSCAN算法是一种著名的聚类算法，它基于一组“邻域”（neighborhood)参数来刻画样本分布的紧密程度。想要了解DBSCAN算法，DBSCAN是一种很典型的密度聚类算法，和K-Means，BIRCH这些一般只适用于凸样本集的聚类相比，DBSCAN既可以适用于凸样本集，也可以适用于非凸样本集。首先需要知道下面几个概念：

给定数据集$D={x_1,x_2,…,x_m} $:,则：

$\epsilon$ -邻域：对 $x_i\in D$ ，其 $\in$ -邻域包含样本集D中于 $x_j$ 不大于 $\epsilon$ 的样本，即 $N_{\epsilon}(x_j)=\{x_i\in D|dist(x_i, x_j )\le \epsilon\}$ 其中，dist()默认情况下为欧式距离。（可以将邻域理解为一个圆，圆内包含着一定数量的样本）
核心对象：若 $x_j$ 的 $\epsilon$ -邻域至少包含 $M i n P t s$ 个样本，即 $|N_{\epsilon}| \ge MinPts$ ,则 $x_j$ 是一个核心对象。(简单理解就是：圆的中心(即核心对象)周围必须超过MinPts个样本。）
密度直达：若 $x_j$ 位于 $x_i$ 的 $\epsilon$ -邻域中，且 $x_i$ 是核心对象，则称 $x_j$ 由 $x_i$ 密度直达。（可以理解为点 $x_j$ 在以 $x_i$ 为圆心的圆中）
密度可达:对 $x_i$ 于 $x_j$ ，若存在样本序列 $p_1,p_2,...,p_n$ ,其中 $p_1=x_i,p_n=x_j$ ,且 $p_{i+1}$ 由 $p_i$ 密度直达，则称 $x_i$ 与 $x_j$ 密度可达。( $p_1,p_2，p_3,....p_{n-1}都为核心对象，但是p_n不为核心对象）$
密度相连：对 $x_i$ 和 $x_j$ ,若存在 $x_k$ 使得 $x_i$ 与 $x_j$ 均由 $x_k$ 密度可达，则称 $x_i$ 与 $x_j$ 密度相连。（可以理解为 $x_i和x_j$ 都不是核心对象，但是 $x_k$ 为核心对象，并且作为媒介可以密度直达对方。）

在这里插入图片描述
基于密度的聚类算法通过寻找被低密度区域分离的高密度区域，并将高密度区域作为一个聚类的“簇”。在DBSCAN算法中，聚类“簇”定义为：由密度可达关系导出的最大的密度连接样本的集合。

DBSCAN算法流程

在DBSCAN算法中，有核心对象出发，找到与该核心对象密度可达的所有样本形成“簇”。DBSCAN算法的流程为：

根据给定的邻域参数Eps和MinPts确定所有的核心对象
对每一个核心对象
选择一个未处理过的核心对象，找到由其密度可达的的样本生成聚类“簇
重复以上过程

数据集：UCI上的iris数据集进行算法测试。
网址：http://archive.ics.uci.edu/ml/index.php
伪代码如下：

在这里插入图片描述
我们来看看代码实现：

#-*- coding:utf-8 -*-
import numpy as np
import pandas as pd
import math

def distance(data):
    """
    计算样本之间的距离
    :param data: 样本
    :return: dis(mat)样本之间的距离
    """
    m, n = np.shape(data)
    dis = np.mat(np.zeros((m, m)))
    for i in range(m):
        for j in range(i, m):
            #计算i和j之间的欧式距离
            tmp = 0
            for k in range(n):
                tmp += (data[i, k] - data[j, k]) * (data[i, k] - data[j, k])
            dis[i, j] = np.sqrt(tmp)
            dis[j, i] = dis[i, j]
    return dis

def find_eps(distance_D, eps):
    """
    找到距离的《=esp的索引
    :param distance_D: 样本i与其他样本直接按的距离
    :param eps: 半径的大小
    :return: ind与样本i之间的距离《=eps的样本索引
    """
    ind = []
    n = np.shape(distance_D)[1]
    for j in range(n):
        if distance_D[0, j] <= eps:
            ind.append(j)
    return ind

def dbscan(data, eps, MinPts):
    """
    DBSCAN算法
    :param data:需要聚类的数据集
    :param eps: 半径
    :param MinPts: 半径内最少的数据点
    :return:
            types:每个样本类型，核心点，边界点，噪音点
            sub_class：每个样本所属的类别
    """
    m = np.shape(data)[0]
    # 在types中，1为核心点，0为边界点，-1为噪音点
    types = np.mat(np.zeros((1, m)))
    sub_class = np.mat(np.zeros((1, m)))
    # 用于判断该点是否处理过，0表示未处理过
    dealt = np.mat(np.zeros((m, 1)))
    # 计算每个数据点之间的距离
    dis = distance(data)
    # 用于标记类别
    number = 1

    # 对每一个点进行处理
    for i in range(m):
        # 找到未处理的点
        if dealt[i, 0] == 0:
            # 找到第i个点到其他所有点的距离
            D = dis[i,]
            # 找到半径eps内的所有点
            ind = find_eps(D, eps)
            # 区分点的类型
            # 边界点
            if len(ind) > 1 and len(ind) < MinPts + 1:
                types[0, i] = 0
                sub_class[0, i] = 0
            # 噪音点
            if len(ind) == 1:
                types[0, i] = -1
                sub_class[0, i] = -1
                dealt[i, 0] = 1
            # 核心点
            if len(ind) >= MinPts + 1:
                types[0, i] = 1
                for x in ind:
                    sub_class[0, x] = number
                # 判断核心点是否密度可达
                while len(ind) > 0:
                    dealt[ind[0], 0] = 1
                    D = dis[ind[0],]
                    tmp = ind[0]
                    del ind[0]
                    ind_1 = find_eps(D, eps)

                    if len(ind_1) > 1:  # 处理非噪音点
                        for x1 in ind_1:
                            sub_class[0, x1] = number
                        if len(ind_1) >= MinPts + 1:
                            types[0, tmp] = 1
                        else:
                            types[0, tmp] = 0

                        for j in range(len(ind_1)):
                            if dealt[ind_1[j], 0] == 0:
                                dealt[ind_1[j], 0] = 1
                                ind.append(ind_1[j])
                                sub_class[0, ind_1[j]] = number
                number += 1

    # 最后处理所有未分类的点为噪音点
    ind_2 = ((sub_class == 0).nonzero())[1]
    for x in ind_2:
        sub_class[0, x] = -1
        types[0, x] = -1

    return types, sub_class

def epsilon(data, MinPts):
    '''计算最佳半径
    input:  data(mat):训练数据
            MinPts(int):半径内的数据点的个数
    output: eps(float):半径
    '''
    m, n = np.shape(data)
    xMax = np.max(data, 0)
    xMin = np.min(data, 0)
    eps = ((np.prod(xMax - xMin) * MinPts * math.gamma(0.5 * n + 1)) / (m * math.sqrt(math.pi ** n))) ** (1.0 / n)
    return eps

def loadDataSet(filename):
    """
    函数说明：从文件中下载数据，并将分离除连续型变量和标签变量
    :parameter:
            data - Iris数据集
            attributes - 鸢尾花的属性
            type - 鸢尾花的类别
            sl-花萼长度 , sw-花萼宽度, pl-花瓣长度, pw-花瓣宽度
    :return:
    """
    iris_data = pd.read_csv(filename)   #打开文件
    iris_data = pd.DataFrame(data=np.array(iris_data), columns=['sl', 'sw', 'pl', 'pw', 'type'], index=range(149))   #给数据集添加列名，方便后面的操作
    attributes = iris_data[['sl', 'sw', 'pl', 'pw']]   #分离出花的属性
    iris_data['type'] = iris_data['type'].apply(lambda x: x.split('-')[1])  # 最后类别一列，感觉前面的'Iris-'有点多余即把class这一列的数据按'-'进行切分取切分后的第二个数据
    labels = iris_data['type']     #分理出花的类别
    attriLabels = []      #建立一个标签列表
    for label in labels:        #为了更方便操作，将三中不同的类型分别设为1，2，3
        if label == 'setosa':    #如果类别为setosa的话，设为1
            attriLabels.append(1)
        elif label == 'versicolor':  #如果是versicolor的时候设为2
            attriLabels.append(2)
        elif label == 'virginica':  #如果是virginica的时候设为3
            attriLabels.append(3)
    return attributes, attriLabels

if __name__ == '__main__':
    attributes, attriLabels = loadDataSet('iris.data')
    data = np.mat(attributes)
    eps = epsilon(data, 3)
    types, sub_class = dbscan(data, eps, 3)
    # print(sub_class)
    m = len (attributes)
    right = 0
    sub_class  = sub_class.tolist()[0]
    for lens in range(m):
       if int(sub_class[lens]) == attriLabels[lens]:
             right += 1
    a = 100*(m-right)/m
    print("错误率:",a, "%")

结果如下：
在这里插入图片描述
由于数据集的一些原因，导致算法并不能特别好的进行分类。

Auraros

关注

1
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
机器学习（八）：DBSCAN算法（基础篇）

机器学习（八）：DBSCAN算法（基础篇） K-Means算法和 Mean Shift算法都是基于距离的聚类算法，基于距离的聚类算法的聚类结果是球状的簇，当数据集中的聚类结果是非球状结构时，基于距离的聚类算法的聚类效果并不好。与基于距离的聚类算法不同的是，基于密度的聚类算法可以发现任意形状的聚类。在基于密度的聚类算法中，通过在数据集中寻找被低密度区域分离的高密度区域，将分离出的高密度区域作...
复制链接

扫一扫