引言
 
其实对于所有的聚类问题，都有一个核心点，那就是以什么样的规则来划分两个点是不是同一类。密度聚类，本质上就是基于一种密度的概念来进行聚类。而密度的定义本质上也是来自于两点的距离，所以其实对于聚类的算法来看，大家本质上都差不多，谁也别笑话谁。下面我们来总结介绍一种叫做DBSCAN的密度算法。
 
DBSCAN
 
DBSCAN 的全称是 Density-Based Spatial Clustering of Applications with Noise 
 单词里面有个noise,这就说明我们的算法是能抗噪声的，并且我们的算法是可以在空间中聚类为任意形状的聚类的，这点是一些其他的聚类算法不具备的性质，如下所示：
 
 
 具有这样的性能，就是因为我们的算法引入了“邻域”（其参数为$(\varepsilon, MinPts )$）的概念来刻画样本的紧密程度的算法。
 
下面我们来介绍一下这个算法，在具体算法之前，我们先看几个定义，非常简单，但是可能比较绕，懂了这几个定义，下面的算法就是小菜一碟了。
 
基于密度的几个概念
 
$\varepsilon -$邻域：
 
对$x_j \in D$，其$\varepsilon -$邻域是指样本集$D$中与$x_j$距离不大于$\varepsilon$的样本，即$N_{\varepsilon}(x_j) = \left \{ x_j \in D | dist(x_i,x_j) \leq \varepsilon  \right \}$
 
核心对象：
 
对象$x_j$的$\varepsilon -$邻域中至少包含$MinPts$个样本，即$N_{\varepsilon}(x_j) \geq MinPts$，则称$x_j$为核心对象。
 
密度直达：
 
若$x_j$位于$x_i$的$\varepsilon -$邻域中，且$x_i$是核心对象，则称$x_j$由$x_i$密度直达。
 
密度可达：
 
对$x_j$与$x_i$，存在样本序列$p_1,p_2,...,p_n$且$p_1 = x_j , p_n = x_i$ 且$p_{i+1}$由$p_{i}$密度直达，则称$x_j$由$x_i$密度可达。
 
其实这个概念本质上要求$p_2,...,p_n$都是核心对象
 
密度相连：
 
对$x_j$与$x_i$，若存在$x_k$使得$x_j$与$x_i$均由$x_k$密度可达，则称$x_j$由$x_i$密度相连。
 
下图直观的表示了这几个概念
 
 
基于上面的概念，可以定义DBSCAN算法里面的簇的定义
 
簇： 由密度可达关系导出的最大的密度相连的样本集合。
 
因此实际上簇$C \subseteq D$满足下面的两个条件：
 
连接性：$x_i \in C,x_j \in C \Rightarrow$ $x_i$与$x_j$密度相连
 
最大性：$x_i \in C$ 且$x_j$由$x_i$密度可达 $\Rightarrow x_j \in C$
 
实际上就是核心对象以及与其密度可达的所有的点的集合
 
本质上相当于一些核心对象以及边界点组成了簇，簇中核心的点就是核心对象。
 
具体算法描述
 
实际上就是核心对象以及与其密度可达的所有的点的集合
 
 
 
输入
 
 
 
  
样本集 $D = \left \{ x_1,...,x_N \right \}$
邻域参数$(\varepsilon, MinPts )$
 
 
 
 
算法流程
 
 
 
  

  

 
   
找出所有的核心对象，放入集合中 $\Omega$
初始化未访问的样本集合：$\Gamma = D$
$while( \Omega \neq \varnothing)$ 

  
 
  
 
   

   

 
    
$\Gamma_{old} = D$ 
随机选取一个核心对象$o \in \Omega$，初始化$Q = <o>$ 
$\Gamma = \Gamma \setminus  \left \{ o \right \}$ 
$while( Q \neq \varnothing)$ 

   
 
   
 
    

    

 
     
从 $Q$中取出样本$q$ 
$if (q$是核心对象$)$ 

    
 
    
 
     
另$\Delta = N_{\varepsilon}(q) \cap \Gamma$， 即获取核心对象$q$邻域内的点 

          
将$\Delta$内的点加入到$Q$中 
$\Gamma = \Gamma \setminus  \Delta$ 
$end \quad if$ 
$end \quad while$ 
$k = k+1$,并且生成聚类簇$C_k = \Gamma_{old} \setminus  \Gamma$ 
$\Omega = \Omega \setminus C_k$
$end \quad while$
 
    
 
   
 
  
 
 
 
 
输出
 
 
 
  
簇划分$C = \left \{ C_1,...,C_K \right \}$
 
 
 
 
算法的优缺点
 
优点：
 
算法不需要指定聚类的数目，但是算法实际上需要另外两个参数$(\varepsilon, MinPts )$，所以这个优点也是勉强。
可以聚成任意形状的类，就像开始的图所示
能够识别出噪声点
 
缺点：
 
对高维数据效果不算好
如果样本的密度不均， 效果会不理想

这篇博客使用scikit的相关API创建模拟数据，然后使用DBSCAN密度聚类算法进行数据聚类操作，并比较DBSCAN算法在不同参数情况下的密度聚类效果。
 
API
 
 
 
class sklearn.cluster.DBSCAN(eps=0.5, min_samples=5, metric=‘euclidean’, metric_params=None, algorithm=‘auto’, leaf_size=30, p=None, n_jobs=None)
 
 
代码
 
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
import sklearn.datasets as ds
import matplotlib.colors
from sklearn.cluster import DBSCAN
from sklearn.preprocessing import StandardScaler

## 设置属性防止中文乱码及拦截异常信息
mpl.rcParams['font.sans-serif'] = [u'SimHei']
mpl.rcParams['axes.unicode_minus'] = False

### 创建模拟数据
N = 1000
centers = [[1, 2], [-1, -1], [1, -1], [-1, 1]]
data1, y1 = ds.make_blobs(N, n_features=2, centers=centers, cluster_std=(1,0.75, 0.5,0.25), random_state=0)
data1 = StandardScaler().fit_transform(data1)
params1 = ((0.15, 5), (0.2, 10), (0.2, 15), (0.3, 5), (0.3, 10), (0.3, 15))

t = np.arange(0, 2 * np.pi, 0.1)
data2_1 = np.vstack((np.cos(t), np.sin(t))).T
data2_2 = np.vstack((2*np.cos(t), 2*np.sin(t))).T
data2_3 = np.vstack((3*np.cos(t), 3*np.sin(t))).T
data2 = np.vstack((data2_1, data2_2, data2_3))
y2 = np.vstack(([0] * len(data2_1), [1] * len(data2_2), [2] * len(data2_3)))
params2 = ((0.5, 3), (0.5, 5), (0.5, 10), (1., 3), (1., 10), (1., 20))

datasets = [(data1, y1,params1), (data2, y2,params2)]

def expandBorder(a, b):
    d = (b - a) * 0.1
    return a-d, b+d

colors = ['r', 'g', 'b', 'y', 'c', 'k']
cm = mpl.colors.ListedColormap(colors)

for i,(X, y, params) in enumerate(datasets):
    x1_min, x2_min = np.min(X, axis=0)
    x1_max, x2_max = np.max(X, axis=0)
    x1_min, x1_max = expandBorder(x1_min, x1_max)
    x2_min, x2_max = expandBorder(x2_min, x2_max)
    
    plt.figure(figsize=(12, 8), facecolor='w')
    plt.suptitle(u'DBSCAN聚类-数据%d' % (i+1), fontsize=20)
    plt.subplots_adjust(top=0.9,hspace=0.35)
    
    for j,param in enumerate(params):
        eps, min_samples = param
        model = DBSCAN(eps=eps, min_samples=min_samples)
        #eps 半径，控制邻域的大小，值越大，越能容忍噪声点，值越小，相比形成的簇就越多
        #min_samples 原理中所说的M，控制哪个是核心点，值越小，越可以容忍噪声点，越大，就更容易把有效点划分成噪声点
        
        model.fit(X)
        y_hat = model.labels_

        unique_y_hat = np.unique(y_hat)
        n_clusters = len(unique_y_hat) - (1 if -1 in y_hat else 0)
        print ("类别:",unique_y_hat,"；聚类簇数目:",n_clusters)
        
        
        core_samples_mask = np.zeros_like(y_hat, dtype=bool)
        core_samples_mask[model.core_sample_indices_] = True
        
        ## 开始画图
        plt.subplot(3,3,j+1)
        for k, col in zip(unique_y_hat, colors):
            if k == -1:
                col = 'k'
                
            class_member_mask = (y_hat == k)
            xy = X[class_member_mask & core_samples_mask]
            plt.plot(xy[:, 0], xy[:, 1], 'o', markerfacecolor=col, markeredgecolor='k', markersize=14)
            xy = X[class_member_mask & ~core_samples_mask]
            plt.plot(xy[:, 0], xy[:, 1], 'o', markerfacecolor=col, markeredgecolor='k', markersize=6)
        plt.xlim((x1_min, x1_max))
        plt.ylim((x2_min, x2_max))
        plt.grid(True)
        plt.title('$\epsilon$ = %.1f  m = %d，聚类簇数目：%d' % (eps, min_samples, n_clusters), fontsize=16)
    ## 原始数据显示
    plt.subplot(3,3,7)
    plt.scatter(X[:, 0], X[:, 1], c=y, s=30, cmap=cm, edgecolors='none')
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.title('原始数据，聚类簇数目:%d' % len(np.unique(y)))
    plt.grid(True)
    plt.show()   
 
 
 
类别: [-1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15] ；聚类簇数目: 16
 类别: [-1 0 1 2 3 4] ；聚类簇数目: 5
 类别: [-1 0 1 2 3 4] ；聚类簇数目: 5
 类别: [-1 0 1 2] ；聚类簇数目: 3
 类别: [-1 0] ；聚类簇数目: 1
 类别: [-1 0] ；聚类簇数目: 1
 
 

 发现，由于边界不明显，DB很难划分开。
 
 
 
类别: [0 1 2] ；聚类簇数目: 3
 类别: [-1 0 1] ；聚类簇数目: 2
 类别: [-1 0] ；聚类簇数目: 1
 类别: [0] ；聚类簇数目: 1
 类别: [-1 0] ；聚类簇数目: 1
 类别: [-1 0] ；聚类簇数目: 1
 
 

 选择合适的ε和m，是可以很好的分开的，用k-means是很难分开的。但实际中，还是用k-means比较多，为什么？像这种数据，我们其实是可以转换的，比如类似SVM中的升维操作，转换后，就可以用k-means了。

前言
 
DBSCAN(Density-Based Spatial Clustering of Applications with Noise，具有噪声的基于密度的空间聚类方法)是一种很典型的密度聚类算法，和 K-Means ， BIRCH 这些一般只适用于凸样本集的聚类相比，DBSCAN 既可以适用于凸样本集，也可以适用于非凸样本集。
 
一、基于密度的聚类思想
 
DBSCAN 是一种基于密度的聚类算法，这类密度聚类算法一般假定类别可以通过样本分布的紧密程度决定。同一类别的样本，他们之间是紧密相连的，也就是说，在该类别任意样本周围不远处一定有同类别的样本存在。
 
通过将紧密相连的样本划为一类，这样就得到了一个聚类类别。通过将所有各组紧密相连的样本划为各个不同的类别，则我们就得到了最终的所有聚类类别结果。
 
二、DBSCAN密度定义
 
在上一小节我们定性描述了密度聚类的基本思想，本节我们就看看DBSCAN是如何描述密度聚类的。DBSCAN是基于一组邻域来描述样本集的紧密程度的，参数($ϵ$, MinPts)用来描述邻域的样本分布紧密程度。其中，$ϵ$ 描述了某一样本的邻域距离阈值，MinPts 描述了某一样本的距离为 $ϵ$ 的邻域中样本个数的阈值。
 
假设我的样本集是 $D=(x_1,x_2,...,x_m)$ ，则DBSCAN具体的密度描述定义如下：
 
① $ϵ$ - 邻域：对于 $x_j\in D$ ，其 $ϵ$ - 邻域包含样本集 $D$ 中与 $x_j$ 的距离不大于 $ϵ$ 的子样本集，即 
     
      
       
        
         
          N
         
         
          ϵ
         
        
        
         (
        
        
         
          x
         
         
          j
         
        
        
         )
        
        
         =
        
        
         {
        
        
         
          x
         
         
          i
         
        
        
         ∈
        
        
         D
        
        
         ∣
        
        
         d
        
        
         i
        
        
         s
        
        
         t
        
        
         a
        
        
         n
        
        
         c
        
        
         e
        
        
         (
        
        
         
          x
         
         
          i
         
        
        
         ,
        
        
         
          x
         
         
          j
         
        
        
         )
        
        
         ≤
        
        
         ϵ
        
        
         }
        
       
       
        N_{\epsilon}(x_j) = \{x_i \in D | distance(x_i, x_j) \leq \epsilon \}
       
      
     Nϵ​(xj​)={xi​∈D∣distance(xi​,xj​)≤ϵ} ，这个子样本集的个数记为 $|N_{ϵ}(x_j)|$ ；
② 核心对象：对于任一样本 $x_j\in D$ ，如果其 $ϵ$ - 邻域对应的 $N_{ϵ}(x_j)$ 至少包含MinPts个样本，即如果 $|N_{ϵ}(x_j)|\ge MinPts$，则 $x_j$ 是核心对象；
③ 密度直达：如果 $x_i$ 位于 $x_j$ 的 $ϵ$ - 邻域中，且 $x_j$ 是核心对象，则称 $x_i$ 由 $x_j$ 密度直达。注意反之不一定成立，即此时不能说 $x_j$ 由 $x_i$ 密度直达，除非且 $x_i$ 也是核心对象；
④ 密度可达：对于 $x_i$ 和 $x_j$ ，如果存在样本序列 $p_1,p_2,...,p_T$ ，满足 $p_1=x_i,p_T=x_j$ ，且 $p_{t+1}$ 由 $p_t$ 密度直达，则称 $x_j$ 由 $x_i$ 密度可达。也就是说，密度可达满足传递性。此时序列中的传递样本 $p_1,p_2,...,p_{T-1}$ 均为核心对象，因为只有核心对象才能使其他样本密度直达。注意密度可达也不满足对称性，这个可以由密度直达的不对称性得出；
⑤ 密度相连：对于 $x_i$ 和 $x_j$ ,如果存在核心对象样本 $x_k$ ，使 $x_i$ 和 $x_j$ 均由 $x_k$ 密度可达，则称 $x_i$ 和 $x_j$ 密度相连。注意密度相连关系是满足对称性的。
 
从下图可以很容易理解上述定义，图中 MinPts=5 ，红色的点都是核心对象，因为其 $ϵ$ - 邻域至少有 5 个样本。黑色的样本是非核心对象。所有核心对象密度直达的样本在以红色核心对象为中心的超球体内，如果不在超球体内，则不能密度直达。图中用绿色箭头连起来的核心对象组成了密度可达的样本序列。在这些密度可达的样本序列的 $ϵ$ - 邻域内所有的样本相互都是密度相连的。
 
 有了上述定义，DBSCAN的聚类定义就简单了。
 
三、DBSCAN密度聚类思想
 
DBSCAN的聚类定义很简单：由密度可达关系导出的最大密度相连的样本集合，即为我们最终聚类的一个类别，或者说一个簇。
 
这个DBSCAN的簇里面可以有一个或者多个核心对象。如果只有一个核心对象，则簇里其他的非核心对象样本都在这个核心对象的 $ϵ$ -邻域里；如果有多个核心对象，则簇里的任意一个核心对象的 $ϵ$ -邻域中一定有一个其他的核心对象，否则这两个核心对象无法密度可达。这些核心对象的 $ϵ$ -邻域里所有的样本的集合组成的一个DBSCAN聚类簇。
 
那么怎么才能找到这样的簇样本集合呢？DBSCAN使用的方法很简单，它任意选择一个没有类别的核心对象作为种子，然后找到所有这个核心对象能够密度可达的样本集合，即为一个聚类簇。接着继续选择另一个没有类别的核心对象去寻找密度可达的样本集合，这样就得到另一个聚类簇。一直运行到所有核心对象都有类别为止。
 
基本上这就是DBSCAN算法的主要内容了，是不是很简单？但是我们还是有三个问题没有考虑。
 
第一个是一些异常样本点或者说少量游离于簇外的样本点，这些点不在任何一个核心对象的周围，在DBSCAN中，我们一般将这些样本点标记为噪音点。
 
第二个是距离的度量问题，即如何计算某样本和核心对象样本的距离。在DBSCAN中，一般采用最近邻思想，采用某一种距离度量来衡量样本距离，比如欧式距离。这和KNN分类算法的最近邻思想完全相同。对应少量的样本，寻找最近邻可以直接去计算所有样本的距离，如果样本量较大，则一般采用KD-tree或者ball-tree来快速的搜索最近邻。
 
第三种问题比较特殊，某些样本可能到两个核心对象的距离都小于 $ϵ$ ，但是这两个核心对象由于不是密度直达，又不属于同一个聚类簇，那么如果界定这个样本的类别呢？一般来说，此时DBSCAN采用先来后到，先进行聚类的类别簇会标记这个样本为它的类别。也就是说DBSCAN的算法不是完全稳定的算法。
 
四、DBSCAN聚类算法的实现流程
 
输入：样本集 $D=(x_1,x_2,...,x_m)$，邻域参数( $ϵ$ ，MinPts)，样本距离度量方式。
 
输出： 簇划分（样本所属类别）$C$ 。
 
① 初始化核心对象集合 $\Omega =\varphi$ ，初始化聚类簇数 $k=0$ ，初始化未访问样本集合 $\Gamma =D$ ，簇划分 $C=\varphi$ ；
② 对于 $j=1,2,...,m$ ，按下面的步骤找出所有的核心对象：
 a) 通过距离度量方式，找到样本 $x_j$ 的 $ϵ$ - 邻域子样本集 $N_{ϵ}(x_j)$ ；
 b) 如果子样本集的样本个数满足 $|N_{ϵ}(x_j)|\ge MinPts$ ， 将样本 $x_j$ 加入核心对象样本集合：
     
      
       
        
         Ω
        
        
         =
        
        
         Ω
        
        
         ∪
        
        
         {
        
        
         
          x
         
         
          j
         
        
        
         }
        
       
       
        \Omega = \Omega \cup \{x_j\}
       
      
     Ω=Ω∪{xj​} 。
③ 如果核心对象集合 $\Omega =\varphi$，则算法结束，否则转入步骤④；
④ 在核心对象集合 $\Omega$ 中，随机选择一个核心对象 $o$ ，初始化当前簇核心对象队列 
     
      
       
        
         
          Ω
         
         
          
           c
          
          
           u
          
          
           r
          
         
        
        
         =
        
        
         {
        
        
         o
        
        
         }
        
       
       
        \Omega_{cur} = \{o\}
       
      
     Ωcur​={o} ，初始化类别序号 $k=k+1$，初始化当前簇样本集合 
     
      
       
        
         
          C
         
         
          k
         
        
        
         =
        
        
         {
        
        
         o
        
        
         }
        
       
       
        C_k = \{o\}
       
      
     Ck​={o} ，更新未访问样本集合 
     
      
       
        
         Γ
        
        
         =
        
        
         Γ
        
        
         −
        
        
         {
        
        
         o
        
        
         }
        
       
       
        \Gamma = \Gamma − \{o\}
       
      
     Γ=Γ−{o} ；
⑤ 如果当前簇核心对象队列 ${\Omega }_{cur}=\varphi$ ，则当前聚类簇 $C_k$ 生成完毕，更新簇划分 
     
      
       
        
         C
        
        
         =
        
        
         {
        
        
         
          C
         
         
          1
         
        
        
         ,
        
        
         
          C
         
         
          2
         
        
        
         ,
        
        
         .
        
        
         .
        
        
         .
        
        
         ,
        
        
         
          C
         
         
          k
         
        
        
         }
        
       
       
        C=\{C_1, C_2, ..., C_k\}
       
      
     C={C1​,C2​,...,Ck​} ，更新核心对象集合 $\Omega =\Omega -C_k$ ，转入步骤③；
⑥ 在当前簇核心对象队列 ${\Omega }_{cur}$ 中取出一个核心对象 $o^{\prime }$ ，通过邻域距离阈值 $ϵ$ 找出所有的 $ϵ$ - 邻域子样本集 $N_{ϵ}(o^{\prime })$，令 $\Delta =N_{ϵ}(o^{\prime })\cap \Gamma$ ，更新当前簇样本集合 $C_k=C_k\cup \Delta$ ，更新未访问样本集合 $\Gamma =\Gamma -\Delta$ ，更新 ${\Omega }_{cur}={\Omega }_{cur}\cup (\Delta \cap \Omega )-o^{\prime }$ ，转入步骤⑤。
 
输出结果为： 簇划分 
    
     
      
       
        C
       
       
        =
       
       
        {
       
       
        
         C
        
        
         1
        
       
       
        ,
       
       
        
         C
        
        
         2
        
       
       
        ,
       
       
        .
       
       
        .
       
       
        .
       
       
        ,
       
       
        
         C
        
        
         k
        
       
       
        }
       
      
      
       C = \{C_1, C_2, ..., C_k\}
      
     
    C={C1​,C2​,...,Ck​} 。
 
五、总结
 
和传统的 K-Means 算法相比，DBSCAN 最大的不同就是不需要输入类别数k ，当然它最大的优势是可以发现任意形状的聚类簇，而不是像K-Means，一般仅仅使用于凸的样本集聚类。同时它在聚类的同时还可以找出异常点，这点和BIRCH算法类似。
 
那么我们什么时候需要用DBSCAN来聚类呢？一般来说，如果数据集是稠密的，并且数据集不是凸的，那么用DBSCAN会比K-Means聚类效果好很多。如果数据集不是稠密的，则不推荐用DBSCAN来聚类。
 
DBSCAN的主要优点有：
 
 
① 可以对任意形状的稠密数据集进行聚类，相对的，K-Means之类的聚类算法一般只适用于凸数据集。
 
 
② 可以在聚类的同时发现异常点，对数据集中的异常点不敏感。
 
 
③ 聚类结果没有偏倚，相对的，K-Means之类的聚类算法初始值对聚类结果有很大影响。
 
 
DBSCAN的主要缺点有：
 
 
① 如果样本集的密度不均匀、聚类间距相差很大时，聚类质量较差，这时用DBSCAN聚类一般不适合。
 
 
② 如果样本集较大时，聚类收敛时间较长，此时可以通过在搜索最近邻时建立的KD-tree或者ball-tree进行规模限制来改进。
 
 
③ 调参相对于传统的K-Means之类的聚类算法稍复杂，主要需要对距离阈值 $ϵ$ ，邻域样本数阈值 $MinPts$ 联合调参，不同的参数组合对最后的聚类效果有较大影响。
 
 
六、参考文献
 
① DBSCAN密度聚类算法 - 刘建平

1、DBSCAN概念 
 

 基于密度的带噪声的空间聚类应用算法，它是将簇定义为密度相连的点的大集合，能够把足够高密度的区域划分为簇，并且可在噪声的空间数据集中发现任意形状的聚类。
 
2、密度聚类和距离聚类
 
密度聚类：只要临近区域的密度、对象、或者数据点的数目超过耨个阈值，就继续聚类，可以根据与周伟特点进行聚类
 
kmeans和分层聚类都是基于距离进行聚类，只能发现球状的簇，五发现其他形式的簇
 
3、其他概念
 
01密度：空间中任意一点的密度是以该点为圆形，以Eps为半径的圆区域内包含的点数目。
 
02 领域： 空间中任意一点的领域是以该点为圆心、以Eps为半径的圆区域内包含的点数目。
 
03 核心点：空间某一点的密度，如果大于某一给定阈值MInPts，则称为边界点。
 
04 噪声点：数据集中不属于核心点，也不属于边界点的点，也就是密度值为1的点
 
4、聚类方法
 
 
 
model=sklearn.cluster.DBSCAN(eps,min_samples)
 
eps 领域的大小，使用圆的半径表示
 min_samples 点的个数的阈值
 
model.fit_predict(data)
 
data 数据
 
训练模型并且进行预测的方法
 
5、案例
 
import pandas as pd

import matplotlib.pyplot as plt


data = pd.read_csv('D:\\DATA\\pycase\\number2\\7.2\\data.csv')

plt.plot(
        data['x'],
        data['y'],
        '.',
        color='r'
        )
# 只能画出一种颜色，scatter可以根据标签类型区分绘画分类


# 导入DBSCN训练算法

from sklearn.cluster import DBSCAN

eps=0.2 # 领域的大小，使用圆的半径表示

MinPts=5 # 领域内，点个数的阈值

model=DBSCAN(eps,MinPts)

# 数据匹配
data['type']=model.fit_predict(data)

# 绘图
plt.scatter(
        data['x'],
        data['y'],
        c=data['type'] # 表示颜色
        )