精华内容
下载资源
问答
  • 层次聚类python实现

    2021-10-31 15:30:54
    层次聚类算法 顾名思义,层次聚类就是一层一层的进行聚类,可以由上向下把大的类别(cluster)分割,叫作分裂法;也可以由下向上对小的类别进行聚合,叫作凝聚法;但是一般用的比较多的是由下向上的凝聚方法。 分裂...

    层次聚类算法

    顾名思义,层次聚类就是一层一层的进行聚类,可以由上向下把大的类别(cluster)分割,叫作分裂法;也可以由下向上对小的类别进行聚合,叫作凝聚法;但是一般用的比较多的是由下向上的凝聚方法。

    分裂法:

    分裂法指的是初始时将所有的样本归为一个类簇,然后依据某种准则进行逐渐的分裂,直到达到某种条件或者达到设定的分类数目。用算法描述:
    输入:样本集合D,聚类数目或者某个条件(一般是样本距离的阈值,这样就可不设置聚类数目)
    输出:聚类结果

    1.将样本集中的所有的样本归为一个类簇;
    repeat:
        2.在同一个类簇(计为c)中计算两两样本之间的距离,找出距离最远的两个样本a,b;
        3.将样本a,b分配到不同的类簇c1和c2中;
        4.计算原类簇(c)中剩余的其他样本点和a,b的距离,若是dis(a)<dis(b),则将样本点归到c1中,否则归到c2中;
    util: 达到聚类的数目或者达到设定的条件
    

    凝聚法:

    凝聚法指的是初始时将每个样本点当做一个类簇,所以原始类簇的大小等于样本点的个数,然后依据某种准则合并这些初始的类簇,直到达到某种条件或者达到设定的分类数目。用算法描述:
    输入:样本集合D,聚类数目或者某个条件(一般是样本距离的阈值,这样就可不设置聚类数目)
    输出:聚类结果

      1.将样本集中的所有的样本点都当做一个独立的类簇;
       repeat:
            2.计算两两类簇之间的距离(后边会做介绍),找到距离最小的两个类簇c1和c2;
            3.合并类簇c1和c2为一个类簇;
       util: 达到聚类的数目或者达到设定的条件
    

    例图:
    在这里插入图片描述

    类簇间距离的计算方法有许多种:
    (1)就是取两个类中距离最近的两个样本的距离作为这两个集合的距离,也就是说,最近两个样本之间的距离越小,这两个类之间的相似度就越大
    (2)取两个集合中距离最远的两个点的距离作为两个集合的距离
    (3)把两个集合中的点两两的距离全部放在一起求一个平均值,相对也能得到合适一点的结果。
    e.g.对于u中所有点i和v中所有点j
    在这里插入图片描述
    其中|u|,|v|是聚类u和v中元素的的个数,这也被称为UPGMA算法(非加权组平均)法。
    (4)取两两距离的中值,与取均值相比更加能够解除个别偏离样本对结果的干扰。
    (5)求每个集合的中心点(就是将集合中的所有元素的对应维度相加然后再除以元素个数得到的一个向量),然后用中心点代替集合再去就集合间的距离

    实现

    接下来以世界银行样本数据集进行简单实现。该数据集以标准格式存储在名为WBClust2013.csv的CSV格式的文件中。其有80行数据和14个变量。数据来源
    在这里插入图片描述
    将数据分为三个聚簇,并且在实现层次聚类之后加入PCA降维与原始结果进行对比。

    from scipy.cluster.hierarchy import linkage, dendrogram, fcluster
    import matplotlib.pyplot as plt
    import pandas as pd
    import numpy as np
    
    data = pd.read_csv('data/WBClust2013.csv')
    data = data[:20]
    country = list(data['Country'])
    data.pop('Country')
    data_zs = 1.0*data/data.max()#归一化
    # print(data_zs)
    
    # 以下代码为仅使用层次聚类
    plt.figure(figsize=(9, 7))
    plt.title("original data")
    mergings = linkage(data_zs, method='average')
    dendrogram(mergings, labels=country, leaf_rotation=45, leaf_font_size=8)
    plt.show()
    
    cluster_assignments = fcluster(mergings, t=3.0, criterion='maxclust')
    print(cluster_assignments)
    for i in range(1, 4):
        print('cluster', i, ':')
        num = 1
        for index, value in enumerate(cluster_assignments):
            if value == i:
                if num % 5 == 0:
                    print()
                num += 1
                print(country[index], end='  ')
        print()
    
    # 以下代码为加入PCA进行对比
    class myPCA():
    
        def __init__(self, X, d=2):
            self.X = X
            self.d = d
    
        def mean_center(self, data):
            """
            去中心化
            :param data: data sets
            :return:
            """
            n, m = data.shape
            for i in range(m):
                aver = np.sum(self.X[:, i])/n
                x = np.tile(aver, (1, n))
                self.X[:, i] = self.X[:, i]-x
    
        def runPCA(self):
    
            # 计算协方差矩阵,得到特征值,特征向量
            S = np.dot(self.X.T, self.X)
            S_val, S_victors = np.linalg.eig(S)
            index = np.argsort(-S_val)[0:self.d]
            Y = S_victors[:, index]
            # 得到输出样本集
            Y = np.dot(self.X, Y)
            return Y
    
    data_for_pca = np.array(data_zs)
    pcaObject=myPCA(data_for_pca,d=2)
    pcaObject.mean_center(data_for_pca)
    res=pcaObject.runPCA()
    
    # plt.figure(figsize=(9, 7))
    # plt.title("after pca")
    # mergings = linkage(res,method='average')
    # print(mergings)
    # dendrogram(mergings,labels=country,leaf_rotation=45,leaf_font_size=8)
    # plt.show()
    
    # cluster_assignments = fcluster(mergings, t=3.0, criterion='maxclust')
    # print(cluster_assignments)
    # for i in range(1,4):
    #     print('cluster', i, ':')
    #     num = 1
    #     for index, value in enumerate(cluster_assignments):
    #         if value == i:
    #             if num % 5 ==0:
    #                 print()
    #             num+=1
    #             print(country[index],end='  ')
    #     print()
    

    原始数据分类后的聚簇:

    cluster 1 :
    Pakistan  Nigeria  Bangladesh  Ethiopia  
    cluster 2 :
    United States  Indonesia  Brazil  Russian Federation  
    Japan  Mexico  Germany  Turkey  Thailand  
    France  United Kingdom  
    cluster 3 :
    China  India  Philippines  Vietnam  
    Egypt, Arab Rep. 
    

    PCA降维后的分类聚簇:

    cluster 1 :
    Pakistan  Nigeria  Bangladesh  Ethiopia  
    cluster 2 :
    China  India  Philippines  Vietnam  
    Egypt, Arab Rep.  
    cluster 3 :
    United States  Indonesia  Brazil  Russian Federation  
    Japan  Mexico  Germany  Turkey  Thailand  
    France  United Kingdom 
    

    可以看出,分类结果都是一样的。

    通过树状图对结果进行可视化

    以下为建树数据(以原始数据为例):

    [[18.         19.          0.21641882  2.        ]
     [15.         20.          0.32365701  3.        ]
     [ 2.          9.          0.39212766  2.        ]
     [16.         21.          0.45344319  4.        ]
     [ 8.         22.          0.50024778  3.        ]
     [ 4.         10.          0.50648091  2.        ]
     [13.         14.          0.51344362  2.        ]
     [23.         24.          0.58762227  7.        ]
     [ 3.         25.          0.58872577  3.        ]
     [11.         26.          0.64184605  3.        ]
     [ 5.          6.          0.71918707  2.        ]
     [17.         28.          0.72310738  4.        ]
     [ 0.          1.          0.84679303  2.        ]
     [ 7.         12.          0.90714675  2.        ]
     [30.         33.          0.97508395  4.        ]
     [27.         31.          1.00112956 11.        ]
     [29.         32.          1.15491503  5.        ]
     [35.         36.          1.29675568 16.        ]
     [34.         37.          1.76337101 20.        ]]
    

    对以上数据解析为:第一列和第二列为聚类簇编号;第三列为两个聚簇之间的距离;第四列为包含的聚簇数量。
    其中聚簇间距离的计算为上文提到的第三种方法。

    原始数据树状图:
    在这里插入图片描述

    PCA降维后的结果:
    在这里插入图片描述

    展开全文
  • 主要介绍了Python聚类算法之凝聚层次聚类的原理与具体使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 主要为大家详细介绍了Python实现简单层次聚类算法以及可视化,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 层次聚类(AGNES)算法(Python) 是聚类算法的一种,通过计算不同类别数据点间的相似度来创建一棵有层次的嵌套聚类树。在聚类树中,不同类别的原始数据点是树的最低层,树的顶层是一个聚类的根节点。AGNES是常用的一种...
  • 广告关闭腾讯云11.11云上盛惠 ,精选... 层次聚类分为两种:合并(自下而上)聚类(agglomerative)分裂(自上而下)聚类(divisive)目前使用较多的是合并聚类 ,本文着重讲解合并聚类的原理。 agens层次聚类原理合并聚...

    o55g08d9dv.jpg广告关闭

    腾讯云11.11云上盛惠 ,精选热门产品助力上云,云服务器首年88元起,买的越多返的越多,最高返5000元!

    单点聚类处在树的最底层,在树的顶层有一个根节点聚类。 根节点聚类覆盖了全部的所有数据点。 层次聚类分为两种:合并(自下而上)聚类(agglomerative)分裂(自上而下)聚类(divisive)目前使用较多的是合并聚类 ,本文着重讲解合并聚类的原理。 agens层次聚类原理合并聚类主要是将n个元素当成n个簇,每个簇与其 欧氏...

    对于库表可以直接勾选,对于普通路径,可填形式如 a - b、c 或者它们的混合,用英文逗号分割(例如0 - 10,15,17 - 19表示第0到10列、15、17到19列总共15列作为特征)。 输出结果路径:路径。 结果格式:结果数据格式,默认为 parquet。 二分 kmeans二分 k 均值算法属于层次聚类,详情可参考 官方文档 。 训练节点...

    l5254rp6hz.jpeg

    层次聚类怎么算层次聚类分为自底向上和自顶向下两种,这里仅采用scikit-learn中自底向上层次聚类法。 将数据集中每一个样本都标记为不同类计算找出其中距离最近的2个类别,合并为一类依次合并直到最后仅剩下一个列表,即建立起一颗完整的层次树以下为看图说话~ 感谢 laugh’sblog借用下说明图把所有数据全部分为不...

    层次聚类(hierarchical clustering算法)层次聚类算法又称为树聚类算法,它根据数据之间的距离,透过一种层次架构方式,反复将数据进行聚合,创建一个层次以分解给定的数据集。 常用于一维数据的自动分组层次聚类方法 hclust(dist)dist样本的距离矩阵距离矩阵的计算方式 dist(data)data 样本数据层次聚类的代码实现...

    前面我们在教程:使用r包deconstructsigs根据已知的signature进行比例推断,顺利的把508个病人,根据11个signature进行了比例推断,得到的比例矩阵以普通的热图,以及pheatmap包自带的层次聚类如下:? 代码是:rm(list=ls())options(stringsasfactors = f)load(file = mut.wt_from_denovo.rdata)a2=mut.wt##...

    hngalg7tx5.png

    假设有n个待聚类的样本,对于层次聚类来说,步骤:1、(初始化)把每个样本归为一类,计算每两个类之间的距离,也就是样本与样本之间的相似度; 2、寻找各个类之间最近的两个类,把他们归为一类(这样类的总数就少了一个); 3、重新计算新生成的这个类与各个旧类之间的相似度; 4、重复2和3直到所有样本点都归为一类...

    3upn7votme.jpeg

    有人不理解分类和聚类的差别,其实这个很简单:分类是一个已知具体有几种情况的变量,预测它到底是哪种情况; 聚类则是尽量把类似的样本聚在一起,不同的样本分开。 举个例子,一个人你判断他是男是女这是分类,让男人站一排女人站一排这是聚类。 聚类分析算法很多,比较经典的有k-means和层次聚类法。 k-means聚类...

    首先抛出了聚类理论中两个关键问题:何为类,何为相似,同时介绍了聚类中常用两种评价指标:内部指标和外部指标。 然后介绍了层次聚类算法:凝聚层次聚类和分裂层次聚类算法,两者皆以样本集作为类表示,常用欧式距离作为相似性度量,分层次聚类。 最后介绍了层次聚类算法的特点,可视化,复杂度。 作者 | 文杰编辑 ...

    之前也做过聚类,只不过是用经典数据集,这次是拿的实际数据跑的结果,效果还可以,记录一下实验过程。 首先:确保自己数据集是否都完整,不能有空值,最好也不要出现为0的值,会影响聚类的效果。 其次:想好要用什么算法去做,k-means,层次聚类还是基于密度算法,如果对这些都不算特别深入了解,那就都尝试一下吧...

    前文说了k均值聚类,他是基于中心的聚类方法,通过迭代将样本分到k个类中,使每个样本与其所属类的中心或均值最近。 今天我们看一下无监督学习之聚类方法的另一种算法,层次聚类:层次聚类前提假设类别直接存在层次关系,通过计算不同类别数据点间的相似度来创建一棵有层次的嵌套聚类树。 在聚类树中,不同类别的原始...

    6pzpq2hab1.jpeg

    比如说,聚类内平方和(within-cluster sum-of-squares)可以测量每个聚类内的方差。 聚类越好,整体 wcss 就越低。 层次聚类(hierarchical clustering)何时使用? 当我们希望进一步挖掘观测数据的潜在关系,可以使用层次聚类算法。 工作方式首先我们会计算距离矩阵(distance matrix),其中矩阵的元素(i,j)...

    mwnrl0o4jw.jpeg

    而且聚类能够作为一个独立的工具获得数据的分布状况,观察每一簇数据的特征,集中对特定的聚簇集合作进一步地分析。 聚类分析还可以作为其他算法(如分类和定性归纳算法)的预处理步骤。 2. 层次聚类分析层次聚类分为凝聚式层次聚类和分裂式层次聚类。 凝聚式层次聚类,就是在初始阶段将每一个点都视为一个簇...

    常用密度聚类算法:dbscan密度最大值算法(1)dbscan算法 dbscan(density-based spatial clusteringof applications with noise)是一个比较有代表性的基于密度的聚类算法,相比于基于划分的聚类方法和层次聚类方法,dbscan算法将簇定义为密度相连的点的最大集合,能够将足够高密度的区域划分为簇,并且在具有噪声的...

    z8r4cd1vu9.png

    层次聚类结果的比较和评估及r操作 层次聚类是探索性分析,而非统计检验的过程。 通过前文对层次聚类的简介,可知数据集的预处理方式、关联系数或距离测度的选择以及聚类方法的选择等将直接影响聚类结果。 因此,选择与分析目标一致的方法非常重要。 本篇简介一些用于比较和评估层次聚类结果的方法,以帮助理解关联...

    duojdlup4a.png

    顾名思义就是要一层一层地进行聚类,可以由上向下把大的类别(cluster)分割,叫作分裂法; 也可以由下向上对小的类别进行聚合,叫作凝聚法; 但是一般用的比较多的是由下向上的凝聚方法。 二、具体1、大致过程:层次聚类方法对给定的数据集进行层次的分解,直到某种条件满足为止。 在已经得到距离值之后,元素间可以...

    层次聚类(hierarchical clustering)基于簇间的相似度在不同层次上分析数据,从而形成树形的聚类结构,层次聚类一般有两种划分策略:自底向上的聚合(agglomerative)策略和自顶向下的分拆(divisive)策略,本文对层次聚类算法原理进行了详细总结。 1. 层次聚类算法原理层次聚类根据划分策略包括聚合层次聚类和拆分...

    3ndid84ub5.png

    k-means算法却是一种方便好用的聚类算法,但是始终有k值选择和初始聚类中心点选择的问题,而这些问题也会影响聚类的效果。 为了避免这些问题,我们可以选择另外一种比较实用的聚类算法-层次聚类算法。 顾名思义,层次聚类就是一层一层的进行聚类,可以由上向下把大的类别(cluster)分割,叫作分裂法; 也可以由下...

    9jlooizqm6.jpeg

    这里再来看看另外一种常见的聚类算法birch。 birch算法比较适合于数据量大,类别数k也比较多的情况。 它运行速度很快,只需要单遍扫描数据集就能进行聚类。 什么是流形学习birch的全称是利用层次方法的平衡迭代规约和聚类(balanced iterativereducing and clustering using hierarchies),其实只要明白它是用层次...

    xe8zf01xdw.jpeg

    实例44 层次聚类分析功能与意义又称系统聚类分析,先将每一个样本看作一类,然后逐渐合并,直至合并为一类的一种合并法,层次聚类分析的优点很明显,他可对样本进行聚类,样本可以为连续或是分类变量,还可以提供多种距离测量方法和结果表示的方法。 数据来源? 分析过程分析-分类-系统聚类? 统计量? 绘制? 保存? 结果...

    1496654823663_5455_1496654823826.png

    所以,讨论数据集应该聚类成多少个簇,通常是在讨论我们在什么尺度上关注这个数据集。 层次聚类算法相比划分聚类算法的优点之一是可以在不同的尺度上(层次)展示数据集的聚类情况。 基于层次的聚类算法(hierarchical clustering)可以是凝聚的(agglomerative)或者分裂的(divisive),取决于层次的划分是“自底...

    展开全文
  • 一文读懂层次聚类Python代码)

    千次阅读 2021-11-21 21:20:01
    本篇想和大家介绍下层次聚类,先通过一个简单的例子介绍它的基本理论,然后再用一个实战案例Python代码实现聚类效果。 首先要说,聚类属于机器学习的无监督学习,而且也分很多种方法,比如大家熟知的有K-means。层次...

    大家好,我是东哥。

    本篇想和大家介绍下层次聚类,先通过一个简单的例子介绍它的基本理论,然后再用一个实战案例Python代码实现聚类效果。

    首先要说,聚类属于机器学习的无监督学习,而且也分很多种方法,比如大家熟知的有K-means。层次聚类也是聚类中的一种,也很常用。下面我先简单回顾一下K-means的基本原理,然后慢慢引出层次聚类的定义和分层步骤,这样更有助于大家理解。

    层次聚类和K-means有什么不同?

    K-means 工作原理可以简要概述为:

    • 决定簇数(k)
    • 从数据中随机选取 k 个点作为质心
    • 将所有点分配到最近的聚类质心
    • 计算新形成的簇的质心
    • 重复步骤 3 和 4

    这是一个迭代过程,直到新形成的簇的质心不变,或者达到最大迭代次数。

    但是 K-means 是存在一些缺点的,我们必须在算法开始前就决定簇数 K 的数量,但实际我们并不知道应该有多少个簇,所以一般都是根据自己的理解先设定一个值,这就可能导致我们的理解和实际情况存在一些偏差。

    层次聚类完全不同,它不需要我们开始的时候指定簇数,而是先完整的形成整个层次聚类后,通过决定合适的距离,自动就可以找到对应的簇数和聚类。

    什么是层次聚类?

    下面我们由浅及深的介绍什么是层次聚类,先来一个简单的例子。

    假设我们有以下几点,我们想将它们分组:

    我们可以将这些点中的每一个分配给一个单独的簇,就是4个簇(4种颜色):

    然后基于这些簇的相似性(距离),将最相似的(距离最近的)点组合在一起并重复这个过程,直到只剩下一个集群:

    上面本质上就是在构建一个层次结构。先了解到这里,后面我们详细介绍它的分层步骤。

    层次聚类的类型

    主要有两种类型的层次聚类:

    • 凝聚层次聚类
    • 分裂层次聚类

    凝聚层次聚类

    先让所有点分别成为一个单独的簇,然后通过相似性不断组合,直到最后只有一个簇为止,这就是凝聚层次聚类的过程,和我们上面刚刚说的一致。

    分裂层次聚类

    分裂层次聚类正好反过来,它是从单个集群开始逐步分裂,直到无法分裂,即每个点都是一个簇。

    所以无论是 10、100、1000 个数据点都不重要,这些点在开始的时候都属于同一个簇:

    现在,在每次迭代中拆分簇中相隔最远的两点,并重复这个过程,直到每个簇只包含一个点:

    上面的过程就是分裂层次聚类

    执行层次聚类的步骤

    上面已经说了层次聚类的大概过程,那关键的来了,如何确定点和点的相似性呢?

    这是聚类中最重要的问题之一了,一般计算相似度的方法是:计算这些簇的质心之间的距离。距离最小的点称为相似点,我们可以合并它们,也可以将其称为基于距离的算法

    另外在层次聚类中,还有一个称为邻近矩阵的概念,它存储了每个点之间的距离。下面我们通过一个例子来理解如何计算相似度、邻近矩阵、以及层次聚类的具体步骤。

    案例介绍

    假设一位老师想要将学生分成不同的组。现在有每个学生在作业中的分数,想根据这些分数将他们分成几组。关于拥有多少组,这里没有固定的目标。由于老师不知道应该将哪种类型的学生分配到哪个组,因此不能作为监督学习问题来解决。下面,我们将尝试应用层次聚类将学生分成不同的组。

    下面是个5名学生的成绩:

    创建邻近矩阵

    首先,我们要创建一个邻近矩阵,它储存了每个点两两之间的距离,因此可以得到一个形状为 n X n 的方阵。

    这个案例中,可以得到以下 5 x 5 的邻近矩阵:

    矩阵里有两点需要注意下:

    • 矩阵的对角元素始终为 0,因为点与其自身的距离始终为 0
    • 使用欧几里得距离公式来计算非对角元素的距离

    比如,我们要计算点 1 和 2 之间的距离,计算公式为:

    ( 10 − 7 ) 2 = 9 = 3 \sqrt{(10-7)^2}=\sqrt{9}=3 (107)2 =9 =3

    同理,按此计算方法完成后填充邻近矩阵其余元素。

    执行层次聚类

    这里使用凝聚层次聚类来实现。

    步骤 1: 首先,我们将所有点分配成单个簇:

    这里不同的颜色代表不同的簇,我们数据中的 5 个点,即有 5 个不同的簇。

    步骤2: 接下来,我们需要查找邻近矩阵中的最小距离并合并距离最小的点。然后我们更新邻近矩阵:

    最小距离是 3,因此我们将合并点 1 和 2:

    让我们看看更新的集群并相应地更新邻近矩阵:

    更新之后,我们取了1、2 两个点中值 (7, 10) 最大的来替换这个簇的值。当然除了最大值之外,我们还可以取最小值或平均值。然后,我们将再次计算这些簇的邻近矩阵:

    第 3 步: 重复第 2 步,直到只剩下一个簇。

    重复所有的步骤后,我们将得到如下所示的合并的聚类:

    这就是凝聚层次聚类的工作原理。但问题是我们仍然不知道该分几组?是2、3、还是4组呢?

    下面开始介绍如何选择聚类数。

    如何选择聚类数?

    为了获得层次聚类的簇数,我们使用了一个概念,叫作树状图

    通过树状图,我们可以更方便的选出聚类的簇数。

    回到上面的例子。当我们合并两个簇时,树状图会相应地记录这些簇之间的距离并以图形形式表示。下面这个是树状图的原始状态,横坐标记录了每个点的标记,纵轴记录了点和点之间的距离:

    当合并两个簇时,将会在树状图中连接起来,连接的高度就是点之间的距离。下面是我们刚刚层次聚类的过程。

    然后开始对上面的过程进行树状图的绘制。从合并样本 1 和 2 开始,这两个样本之间的距离为 3。

    可以看到已经合并了 1 和 2。垂直线代表 1 和 2 的距离。同理,按照层次聚类过程绘制合并簇类的所有步骤,最后得到了这样的树状图:

    通过树状图,我们可以清楚地形象化层次聚类的步骤。树状图中垂直线的距离越远代表簇之间的距离越大。

    有了这个树状图,我们决定簇类数就方便多了。

    现在我们可以设置一个阈值距离,绘制一条水平线。比如我们将阈值设置为 12,并绘制一条水平线,如下:

    从交点中可以看到,聚类的数量就是与阈值水平线与垂直线相交的数量(红线与 2 条垂直线相交,我们将有 2 个簇)。与横坐标相对应的,一个簇将有一个样本集合为 (1,2,4),另一个集群将有一个样本集合 (3,5)。

    这样,我们就通过树状图解决了分层聚类中要决定聚类的数量。

    Python代码实战案例

    上面是理论基础,有点数学基础都能看懂。下面介绍下在如何用代码Python来实现这一过程。这里拿一个客户细分的数据来展示一下。

    数据集和代码在这里:

    https://github.com/xiaoyusmd/PythonDataScience

    分享不易,还请给个star!

    这个数据来源于UCI 机器学习库。我们的目的是根据批发分销商的客户在不同产品类别(如牛奶、杂货、地区等)上的年度支出,对他们进行细分。

    首先对数据进行一个标准化,为了让所有数据在同一个维度便于计算,然后应用层次聚类来细分客户。

    from sklearn.preprocessing import normalize
    data_scaled = normalize(data)
    data_scaled = pd.DataFrame(data_scaled, columns=data.columns)
    
    import scipy.cluster.hierarchy as shc
    plt.figure(figsize=(10, 7))  
    plt.title("Dendrograms")  
    dend = shc.dendrogram(shc.linkage(data_scaled, method='ward'))
    

    x 轴包含了所有样本,y 轴代表这些样本之间的距离。距离最大的垂直线是蓝线,假如我们决定要以阈值 6 切割树状图:

    plt.figure(figsize=(10, 7))  
    plt.title("Dendrograms")  
    dend = shc.dendrogram(shc.linkage(data_scaled, method='ward'))
    plt.axhline(y=6, color='r', linestyle='--')
    

    现在我们有两个簇了,我们要对这 2 个簇应用层次聚类:

    from sklearn.cluster import AgglomerativeClustering
    cluster = AgglomerativeClustering(n_clusters=2, affinity='euclidean', linkage='ward')  
    cluster.fit_predict(data_scaled)
    

    由于我们定义了 2 个簇,因此我们可以在输出中看到 0 和 1 的值。0 代表属于第一个簇的点,1 代表属于第二个簇的点。

    plt.figure(figsize=(10, 7))  
    plt.scatter(data_scaled['Milk'], data_scaled['Grocery'], c=cluster.labels_) 
    

    到这里我们就成功的完成了聚类。

    参考:https://www.analyticsvidhya.com/blog/2019/05/beginners-guide-hierarchical-clustering/

    数据挖掘、机器学习、深度学习干货等原创文章持续更新,可以微信搜一搜「 Python数据科学」第一时间阅读。

    展开全文
  • 起步层次聚类( Hierarchical Clustering )是聚类算法的一种,通过计算不同类别的相似度类创建一个有层次的嵌套的树。层次聚类算法介绍假设有 n 个待聚类的样本,对于层次聚类算法,它的步骤是:步骤一:(初始化)将每...

    起步

    层次聚类( Hierarchical Clustering )是聚类算法的一种,通过计算不同类别的相似度类创建一个有层次的嵌套的树。

    32863.html

    层次聚类算法介绍

    假设有 n 个待聚类的样本,对于层次聚类算法,它的步骤是:

    步骤一:(初始化)将每个样本都视为一个聚类;

    步骤二:计算各个聚类之间的相似度;

    步骤三:寻找最近的两个聚类,将他们归为一类;

    步骤四:重复步骤二,步骤三;直到所有样本归为一类。

    79f3f00b0ae61ff93a007e005769d7f7.png

    整个过程就是建立一棵树,在建立的过程中,可以在步骤四设置所需分类的类别个数,作为迭代的终止条件,毕竟都归为一类并不实际。

    聚类之间的相似度

    聚类和聚类之间的相似度有什么来衡量呢?既然是空间中的点,可以采用距离的方式来衡量,一般有下面三种:

    Single Linkage

    又叫做 nearest-neighbor ,就是取两个类中距离最近的两个样本的距离作为这两个集合的距离。这种计算方式容易造成一种叫做 Chaining 的效果,两个 cluster 明明从“大局”上离得比较远,但是由于其中个别的点距离比较近就被合并了,并且这样合并之后 Chaining 效应会进一步扩大,最后会得到比较松散的 cluster 。

    Complete Linkage

    这个则完全是 Single Linkage 的反面极端,取两个集合中距离最远的两个点的距离作为两个集合的距离。其效果也是刚好相反的,限制非常大。这两种相似度的定义方法的共同问题就是指考虑了某个有特点的数据,而没有考虑类内数据的整体特点。

    Average Linkage 这种方法就是把两个集合中的点两两的距离全部放在一起求均值,相对也能得到合适一点的结果。有时异常点的存在会影响均值,平常人和富豪平均一下收入会被拉高是吧,因此这种计算方法的一个变种就是取两两距离的中位数。

    python 实现层次聚类

    空间中点的距离使用欧式距离:

    import math

    import numpy as np

    def euler_distance(point1: np.ndarray, point2: list) -> float:

    """

    计算两点之间的欧拉距离,支持多维

    """

    distance = 0.0

    for a, b in zip(point1, point2):

    distance += math.pow(a - b, 2)

    return math.sqrt(distance)

    定义聚类数的节点:

    class ClusterNode(object):

    def __init__(self, vec, left=None, right=None, distance=-1, id=None, count=1):

    """

    :param vec: 保存两个数据聚类后形成新的中心

    :param left: 左节点

    :param right: 右节点

    :param distance: 两个节点的距离

    :param id: 用来标记哪些节点是计算过的

    :param count: 这个节点的叶子节点个数

    """

    self.vec = vec

    self.left = left

    self.right = right

    self.distance = distance

    self.id = id

    self.count = count

    vec 表示合并后的聚类中心,是一个点,代表整个聚类的位置;distance 表示左节点和右节点的距离。

    计算层次聚类算法的类:

    class Hierarchical(object):

    def __init__(self, k = 1):

    assert k > 0

    self.k = k

    self.labels = None

    def fit(self, x):

    nodes = [ClusterNode(vec=v, id=i) for i,v in enumerate(x)]

    distances = {}

    point_num, future_num = np.shape(x) # 特征的维度

    self.labels = [ -1 ] * point_num

    currentclustid = -1

    while len(nodes) > self.k:

    min_dist = math.inf

    nodes_len = len(nodes)

    closest_part = None # 表示最相似的两个聚类

    for i in range(nodes_len - 1):

    for j in range(i + 1, nodes_len):

    # 为了不重复计算距离,保存在字典内

    d_key = (nodes[i].id, nodes[j].id)

    if d_key not in distances:

    distances[d_key] = euler_distance(nodes[i].vec, nodes[j].vec)

    d = distances[d_key]

    if d < min_dist:

    min_dist = d

    closest_part = (i, j)

    # 合并两个聚类

    part1, part2 = closest_part

    node1, node2 = nodes[part1], nodes[part2]

    new_vec = [ (node1.vec[i] * node1.count + node2.vec[i] * node2.count ) / (node1.count + node2.count)

    for i in range(future_num)]

    new_node = ClusterNode(vec=new_vec,

    left=node1,

    right=node2,

    distance=min_dist,

    id=currentclustid,

    count=node1.count + node2.count)

    currentclustid -= 1

    del nodes[part2], nodes[part1] # 一定要先del索引较大的

    nodes.append(new_node)

    self.nodes = nodes

    self.calc_label()

    def calc_label(self):

    """

    调取聚类的结果

    """

    for i, node in enumerate(self.nodes):

    # 将节点的所有叶子节点都分类

    self.leaf_traversal(node, i)

    def leaf_traversal(self, node: ClusterNode, label):

    """

    递归遍历叶子节点

    """

    if node.left == None and node.right == None:

    self.labels[node.id] = label

    if node.left:

    self.leaf_traversal(node.left, label)

    if node.right:

    self.leaf_traversal(node.right, label)

    最后将聚类的列表标记保存于 labels 中。

    测试

    与 sklearn 进行对比:

    iris = datasets.load_iris()

    my = Hierarchical(4)

    my.fit(iris.data)

    print(np.array(my.labels))

    sk = cluster.AgglomerativeClustering(4)

    sk.fit(iris.data)

    print(sk.labels_)

    得到输出:

    [3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3

    3 3 3 3 3 3 3 3 3 3 3 3 3 1 1 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1

    1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 0 1 2 1 2 2 2 2 1 2 2 2 2

    2 2 1 1 2 2 2 2 1 2 1 2 1 2 2 1 1 2 2 2 2 2 1 2 2 2 2 1 2 2 2 1 2 2 2 1 2

    2 1]

    [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

    1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 3 2 3 2 3 2 3 3 2 3 2 3 2 3 3 2 3 2 2 2 2

    2 2 2 0 2 3 3 3 3 2 3 2 2 2 3 3 3 2 3 3 3 3 3 2 3 3 0 2 0 0 0 0 3 0 0 0 0

    0 0 2 2 0 0 0 0 2 0 2 0 2 0 0 2 2 0 0 0 0 0 2 2 0 0 0 2 0 0 0 2 0 0 0 2 0

    0 2]

    结果还算是理想的。

    层次聚类的优缺点

    优点:

    一次性得到聚类树,后期再分类无需重新计算;

    相似度规则容易定义;

    可以发现类别的层次关系。

    缺点:

    计算复杂度高,不适合数据量大的;

    算法很可能形成链状。

    附录

    展开全文
  • from scipy.cluster import hierarchy0.层次聚类的概念层次聚类和k-means一样都是很常用的聚类方法。...层次聚类又分为自底而上的聚合层次聚类和自顶而下的分裂层次聚类。0.1 聚合层次聚类每一个点初始为1类,得到N(...
  • python实现层次聚类

    2020-12-02 13:44:13
    BAFIMINARMTO BA0662877255412996 FI6620295468268400 MI8772950754564138 NA2554687540219869 RM4122685642190669 TO9964001388696690 这是... scipy里面关于层次聚类的函数还有不少,我也没有搞懂,这里就不多说了。
  • 本文是Python商业数据挖掘实战的第6篇1 - 基于不平衡数据的反欺诈模型实战2 - Apriori算法实现智能推荐3- 随机森林预测宽带客户离网4 - 多元线性回归模型实战5 -P...
  • 这里,我们来解读一下scipy中给出的层次聚类scipy.cluster.hierarchy的示例: import numpy as np from scipy.cluster.hierarchy import dendrogram, linkage,fcluster from matplotlib import pyplot as plt X = [...
  • 层次聚类步骤:假设有N个待聚类的样本,对于层次聚类来说,基本步骤就是:1、(初始化)把每个样本归为一类,计算每两个类之间的距离,也就是样本与样本之间的相似度;2、按一定规则选取符合距离要求的类别,完成类间...
  • 文章目录一、前言二、自底向上的层次算法三、 python实现层次聚类四、使用Sklearn中的层次聚类五、使用Scipy库中的层次聚类(1). linkage(y, method=’single’, metric=’euclidean’)(2).fcluster(Z, t, criterion=...
  • Python中的凝聚层次聚类示例

    千次阅读 2019-01-02 09:19:07
    层次聚类算法将相似的对象分组到称为聚类的组中。层次聚类算法有两种: 凝聚(Agglomerative )-自下而上的方法。从许多小聚类开始,然后将它们合并到一起,创建更大的聚类。 分裂 (Divisive )- 自上而下的方法...
  • 这篇文章主要介绍了Python聚类算法之凝聚层次聚类的原理与具体使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下 本文实例讲述了Python聚类算法之凝聚层次聚类。分享给大家供大家参考,具体如下: 凝聚层次聚类:...
  • #AGNES(凝聚层次聚类)算法 import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn.cluster import AgglomerativeClustering from sklearn import datasets from sklearn.metrics ...
  • 基于scipy层次聚类python实现

    千次阅读 2017-09-19 22:42:59
    看了sklearn上的层次聚类的库函数,尼玛居然要我指定簇的个数,层次聚类的特点就是无需指定簇的个数嘛!逗我?之后发现scipy下的cluster.hierarchy可以做层次聚类。开干!单词的描述用的是word2vec词向量,挺火的一...
  • 本文将详细介绍如何 利用 Python 实现基于层次聚类的客户分群,主要分为两个部分: 层次聚类详细原理介绍 Python 代码实战讲解 本文源数据与代码在公众号 “ 数据分析与商业实践 “ 后台回复 ” 层次聚类 “ 即可
  • 中科大2019春AI 实验二,包括Kmeans算法,PCA算法和层次聚类算法
  • means########################## ##############################凝聚层次聚类########################## clustering = AgglomerativeClustering(linkage='ward', n_clusters=2) res = clustering.fit(X) print (...
  • python调用包进行层次聚类分析

    千次阅读 2019-03-12 23:09:53
    聚类分析发展至今已经出现了多种不同的算法,层次聚类是其中的典型代表,python作为机器学习编程的有力工具,对多种聚类方法进行了集成,本文主要介绍利用python中集成的包进行层次聚类层次聚类首先需要选定一种...
  • 凝聚层次聚类层次聚类方法凝聚层次聚类算法原理簇间距离计算方法单链法single全链法complete组平均法 averageward法python代码实现绘制层次聚类树状图一些参考 相关文章: 数据挖掘 | [关联规则] 利用apyori库的关联...
  • #采用最小距离作为聚类标准 _min_distance=10000 for x1,y1 in cluster1: for x2,y2 in cluster2: _distance=(x1-x2)**2+(y1-y2)**2 if _distance _min_distance=_distance return _distance groups=get_raw...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,494
精华内容 3,397
关键字:

层次聚类python

python 订阅