精华内容
下载资源
问答
  • 层次聚类 层次聚类
  • 广告关闭腾讯云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),取决于层次的划分是“自底...

    展开全文
  • 基于层次的聚类方法 简介 基于层次的聚类方法 概念 聚合层次聚类 图示 划分层次聚类 图示 基于层次的聚类方法 切割点选取 ...基于层次聚类 ( 聚合层次聚类 ) 算法终止条件 族半径 计算公式 基于层次聚类总结



    基于层次的聚类方法 简介



    1 . 基于层次的聚类方法 : 将 数据集样本对象 排列成 聚类树 , 在 指定 的层次 ( 切割点 ) 进行切割 , 切割点 时刻 的聚类分组 , 就是 最终需要的聚类分组 ; 也就是这个切割点的切割的时刻 , 互相关联的样本 , 划分到一个聚类分组中 ;


    2 . 基于层次聚类方法 的两种方式 :


    ① 聚合层次聚类 : 开始时 , 每个对象都是一个聚类分组 ( 原子聚类 ) , 根据 聚类之间的相似性 , 对原子聚类逐渐合并 , 最终会合并成一个聚类 ; 其 本质是 由 多个聚类分组 切割成 成少数 聚类分组 ;


    ② 划分层次聚类 : 开始时 , 所有的样本都在一个聚类中 , 根据聚类间相似性 , 对聚类进行划分 , 最终 每个样本 都会被划分成一个聚类分组 ( 原子聚类 ) ; 本质是 由 少数 聚类分组 划分成多个 聚类分组 ;



    基于层次的聚类方法 概念



    1 . 基于层次的聚类方法 概念 : 将数 据集样本对象 排列成 树结构 , 称为 聚类树 , 在指定的层次 ( 步骤 ) 上切割数据集样本 , 切割后时刻的 聚类分组 就是 聚类算法的 聚类结果 ;


    2 . 基于层次的聚类方法 : 一棵树可以从叶子节点到根节点 , 也可以从根节点到叶子节点 , 基于这两种顺序 , 衍生出两种方法分支 , 分别是 : 聚合层次聚类 , 划分层次聚类 ;


    3 . 聚合层次聚类 ( 叶子节点到根节点 ) : 开始时 , 每个样本对象自己就是一个聚类 , 称为 原子聚类 , 然后根据这些样本之间的 相似性 , 将这些样本对象 ( 原子聚类 ) 进行 合并 ;

    常用的聚类算法 : 大多数的基于层次聚类的方法 , 都是 聚合层次聚类 类型的 ; 这些方法从叶子节点到根节点 , 逐步合并的原理相同 ; 区别只是聚类间的相似性计算方式不同 ;


    4 . 划分层次聚类 ( 根节点到叶子节点 ) : 开始时 , 整个数据集的样本在一个总的聚类中 , 然后根据样本之间的相似性 , 不停的切割 , 直到完成要求的聚类操作 ;


    5 . 算法性能 : 基于层次的聚类方法的时间复杂度为 O(N2)O(N^2) , 如果处理的样本数量较大 , 性能存在瓶颈 ;



    聚合层次聚类 图示



    1 . 聚合层次聚类 图示 :

    在这里插入图片描述

    ① 初始状态 : 最左侧 五个 数据对象 , 每个都是一个聚类 ;

    ② 第一步 : 分析相似度 , 发现 a,ba , b 相似度很高 , 将 {a,b}\{a ,b\} 分到一个聚类中 ;

    ③ 第二步 : 分析相似度 , 发现 d,ed, e 相似度很高 , 将 {d,e}\{d, e\} 分到一个聚类中 ;

    ④ 第三步 : 分析相似度 , 发现 ccd,ed,e 相似度很高 , 将 cc 数据放入 {d,e}\{d, e\} 聚类中 , 组成 {c,d,e}\{c,d, e\} 聚类 ;

    ⑤ 第四步 : 分析相似度 , 此时要求的相似度很低就可以将不同的样本进行聚类 , 将前几步生成的两个聚类 , 合并成一个聚类 {a,b,c,d,e}\{a, b, c, d, e\} ;


    2 . 切割点说明 : 实际进行聚类分析时 , 不会将所有的步骤走完 , 这里提供四个切割点 , 聚类算法进行聚类时 , 可以在任何一个切割点停止 , 使用当前的聚类分组当做聚类结果 ;


    ① 切割点 11 : 在切割点 11 停止 , 会得到 55 个聚类分组 , {a}\{a\} , {b}\{b\}, {c}\{c\}, {d}\{d\} , {e}\{e\} ;

    ② 切割点 22 : 在切割点 22 停止 , 会得到 44 个聚类分组 , {a,b}\{a, b\} , {c}\{c\}, {d}\{d\} , {e}\{e\} ;

    ③ 切割点 33 : 在切割点 33 停止 , 会得到 33 个聚类分组 , {a,b}\{a, b\} , {c}\{c\}, {d,e}\{d, e\} ;

    ④ 切割点 44 : 在切割点 44 停止 , 会得到 22 个聚类分组 ; {a,b}\{a, b\} , {c,d,e}\{c, d, e\} ;

    ⑤ 走完整个流程 : 会得到 11 个聚类分组 , {a,b,c,d,e}\{a, b ,c, d, e\} ;



    划分层次聚类 图示



    1 . 划分层次聚类 图示 :

    在这里插入图片描述


    ① 初始状态 : 最左侧 五个 数据对象 , 属于一个聚类 ;

    ② 第一步 : 分析相似度 , 切割聚类 , 将 {c,d,e}\{c,d, e\}{a,b}\{a ,b\} 划分成两个聚类 ;

    ③ 第二步 : 分析相似度 , 将 {c,d,e}\{c,d, e\} 中的 {c}\{c\}{d,e}\{d, e\} 划分成两个聚类 ;

    ④ 第三步 : 分析相似度 , 将 {d,e}\{d, e\} 拆分成 {d}\{d\}{e}\{e\} 两个聚类 ;

    ⑤ 第四步 : 分析相似度 , 将 {a,b}\{a ,b\} 拆分成 {a}\{a\}{b}\{b\} 两个聚类 , 至此所有的数据对象都划分成了单独的聚类 ;


    2 . 切割点说明 : 实际进行聚类分析时 , 不会将所有的步骤走完 , 这里提供四个切割点 , 聚类算法进行聚类时 , 可以在任何一个切割点停止 , 使用当前的聚类分组当做聚类结果 ;


    ① 切割点 11 : 在切割点 11 停止 , 会得到 11 个聚类分组 , {a,b,c,d,e}\{a, b ,c, d, e\} ;

    ② 切割点 22 : 在切割点 22 停止 , 会得到 22 个聚类分组 ; {a,b}\{a, b\} , {c,d,e}\{c, d, e\} ;

    ③ 切割点 33 : 在切割点 33 停止 , 会得到 33 个聚类分组 , {a,b}\{a, b\} , {c}\{c\}, {d,e}\{d, e\}$ ;

    ④ 切割点 44 : 在切割点 44 停止 , 会得到 44 个聚类分组 , {a,b}\{a, b\} , {c}\{c\}, {d}\{d\} , {e}\{e\} ;

    ⑤ 走完整个流程 : 会得到 55 个聚类分组 , {a}\{a\} , {b}\{b\}, {c}\{c\}, {d}\{d\} , {e}\{e\} ;



    基于层次的聚类方法 切割点选取



    1 . 算法终止条件 ( 切割点 ) : 用户可以指定聚类操作的算法终止条件 , 即上面图示中的切割点 , 如 :


    ① 聚类的最低个数 : 聚合层次聚类中 , nn 个样本 , 开始有 nn 个聚类 , 逐步合并 , 聚类个数逐渐减少 , 当聚类个数达到最低值 minmin , 停止聚类算法 ;

    ② 聚类最高个数 : 划分层次聚类中 , nn 个样本 , 开始有 11 个聚类 , 逐步划分 , 聚类个数逐渐增加 , 当聚类个数达到最大值 maxmax , 停止聚类算法 ;

    ③ 聚类样本的最低半径 : 聚类的数据样本范围不能无限扩大 , 指定一个阈值 , 只有将该阈值内的样本放入一组 ; 半径指的是所有对象距离其平均点的距离 ;


    2 . 切割点回退问题 : 切割点一旦确定 , 便无法回退 ; 这里以聚合层次聚类为例 :


    ① 处于切割点 44 : 如已经执行到了步骤三 , 此时处于切割点 44 , 聚类分组为 {a,b}\{a, b\} , {c,d,e}\{c, d, e\} ;

    ② 试图回退到 切割点 33 : 想要会回退到切割点 33 的状态 , 视图将聚类分组恢复成 {a,b}\{a, b\} , {c}\{c\}, {d,e}\{d, e\} ;

    ③ 无法回退 : 该操作是无法实现的 , 聚类分组一旦 合并 或 分裂 , 此时就无法回退 ;



    族间距离 概念



    族间距离 :


    ① 作用: 族间距离 , 就是聚类分组之间的距离 , 之前的距离计算都是 样本 之间的距离 , 这里的基于层次聚类时 , 不管是聚合层次聚类 , 还是划分层次聚类 , 其都要进行 聚类分组 间的相似度比较 ,

    ② 聚合层次聚类 : 是 根据 聚类的族间距离 ( 聚类分组相似性 ) 将不同的聚类分组进行合并 ;

    ③ 划分层次聚类 : 是 根据 聚类的族间距离 ( 聚类分组相似性 ) 将不同的聚类分组进行划分 ( 拆分 ) ;



    族间距离 使用到的变量



    公式中 用到的 变量 :


    ① 样本表示 : ppqq 表示 分别 处于两个聚类分组中的 两个样本 ;

    ② 样本距离表示 : d(p,q)d(p, q) 表示 pp 样本对象 与 qq 样本对象的距离 ;

    ③ 聚类 ( 族 ) 表示 : CiC_iCjC_j 分别表示两个 聚类 / 族 / 聚类分组 ;

    ④ 聚类距离表示 : d(Ci,Cj)d(C_i, C_j) 表示 CiC_i 聚类 与 CjC_j 聚类 之间的距离 ;

    ⑤ 聚类中心点 : mim_iCiC_i 聚类的中心点 , mjm_jCjC_j 聚类的中心点 ;

    ⑥ 样本个数 : nin_iCiC_i 聚类的样本个数 , njn_jCjC_j 聚类的样本个数 ;



    族间距离 最小距离



    Ci,CjC_i \,, C_j 族间距离 最小距离 公式 :


    dmin(Ci,Cj)=minpCi,qCjd(p,q)d_{min}(C_i , C_j) = min _{p \in C_i , q \in C_j} d(p, q)


    dmin(Ci,Cj)d_{min}(C_i , C_j) 表示两个聚类的最小距离 ;

    pp 是属于 CiC_i 聚类中的任意样本 ;

    qq 是属于 CjC_j 聚类中的任意样本 ;


    总结 : 两个聚类中两个最近的样本之间的距离就是 聚类间的 最小距离 ;



    族间距离 最大距离



    Ci,CjC_i \,, C_j 族间距离 最大距离 公式 :


    dmax(Ci,Cj)=maxpCi,qCjd(p,q)d_{max }(C_i , C_j) = max _{p \in C_i , q \in C_j} d(p, q)


    dmax(Ci,Cj)d_{max }(C_i , C_j) 表示两个聚类的最大距离 ;

    pp 是属于 CiC_i 聚类中的任意样本 ;

    qq 是属于 CjC_j 聚类中的任意样本 ;


    总结 : 两个聚类中两个最远的样本之间的距离就是 聚类间的 最大距离 ;



    族间距离 中心点距离



    Ci,CjC_i \,, C_j 族间距离 中心点距离 公式 :


    dmean(Ci,Cj)=d(mi,mj)d_{mean }(C_i , C_j) = d(m_i, m_j)


    dmean(Ci,Cj)d_{mean }(C_i , C_j) 表示两个聚类的 中心点距离 ;

    mim_iCiC_i 聚类的中心点 ;

    mjm_jCjC_j 聚类的中心点 ;

    d(mi,mj)d(m_i, m_j) 表示 mim_i 样本 和 mjm_j 样本 之间的距离 ;


    总结 : 两个聚类中的中心点样本之间的距离就是 聚类间的 中心点距离 ;



    族间距离 平均距离



    Ci,CjC_i \,, C_j 族间距离 平均距离 公式 :


    davg(Ci,Cj)=1ninjpCiqCjd(p,q)d_{avg}(C_i , C_j) = \frac{1}{n_i n_j}\sum_{p \in C_i}\sum_{q \in C_j} d(p, q)


    dmean(Ci,Cj)d_{mean }(C_i , C_j) 表示两个聚类的 中心点距离 ;

    pp 是属于 CiC_i 聚类中的任意样本 ;

    qq 是属于 CjC_j 聚类中的任意样本 ;

    nin_iCiC_i 聚类的样本个数 ;

    njn_jCjC_j 聚类的样本个数 ;

    pCiqCjd(p,q)\sum_{p \in C_i}\sum_{q \in C_j} d(p, q) 表示 聚类 CiC_i 中每一个点 到 聚类 CjC_j 中所有点的距离 , 这里 CiC_i 中每个点都对应 njn_j 个距离 , nin_i 个点 , 对应 ni×njn_i \times n_j 个距离 ;


    总结 : 两个聚类中的 平均距离 就是 聚类间的 所有点的距离的平均距离 ;



    基于层次聚类 ( 聚合层次聚类 ) 步骤



    聚合层次聚类步骤 :


    ① 原理 : 根据 聚类分组 的 族间距离 对相似的 聚类分组 进行 逐步合并 ;

    ② 步骤一 : 每个样本都构成 聚类分组 , 称为 原子聚类 ;

    ③ 步骤二 : 计算所有 聚类 之间的距离 ; 可以采用 最小距离 , 最大距离 , 中心点距离 , 平均距离 中的一个 ;

    ④ 步骤三 : 将距离最近的两个 聚类分组 合并 , 聚类的个数 减少 11 个 ;

    ⑤ 步骤四 : 转到 步骤二 计算聚类间距离 , 步骤三 合并近距离聚类 ; 如果满足算法终止条件 , 那么停止聚类 , 否则一直循环迭代 , 最终合并成一个聚类 ;



    基于层次聚类 ( 聚合层次聚类 ) 算法终止条件



    算法终止条件 : 是由 用户 指定的 , 如 :

    ① 聚类分组 ( 族 ) 个数 : 当聚类的个数达到阈值 , 算法终止 ;

    ② 聚类半径 : 每个 聚类的半径 都超过某个阈值 ;



    族半径 计算公式



    族 ( 聚类 ) 半径计算公式 :


    R=1ni=1nd(pim)R=\frac{1}{n}\sum _{i=1}^n d(p_i - m)


    RR 表示聚类半径 ;

    nn 表示聚类中的 样本 个数 ;

    mm 代表聚类中心点 ;

    d(pim)d(p_i - m) 表示聚类中第 ii 个样本距离中心点的距离 ;



    基于层次聚类总结



    1 . 基于层次聚类 的核心 : 是计算 两个 聚类分组 ( 族 ) 之间的距离 , 根据 族间距离 进行 聚类合并 ;


    2 . 适用场景 : 如果 每个 聚类 密度差不多 , 族间距离 分离的很清晰 , 那么使用不同的 族间距离 进行聚类 产生的聚类结果 基本一致 ;


    3 . 算法缺陷 : 基于层次距离不适用于以下情况 ; 聚类分组 分离的不明显 ; 形状不是球形 , 凹形的 ; 聚类间大小不等 ; 各个聚类间样本密度不同 ;

    展开全文
  • 层次聚类

    2020-05-25 16:44:54
    文章目录层次聚类距离度量凝聚层次聚类算法描述:优劣:code 层次聚类 距离度量 层次聚类算法有多种,它们的步骤基本相同,差别在于聚类间距的定义不 同。计算聚类距离间距的计算方法主要有: 凝聚层次聚类 AGNES...

    层次聚类

    距离度量

    层次聚类算法有多种,它们的步骤基本相同,差别在于聚类间距的定义不
    同。计算聚类距离间距的计算方法主要有:
    在这里插入图片描述

    凝聚层次聚类

    AGNES(Agglomerative Nesting) 是凝聚的层次聚类算法,如果簇C1中的一个对象和簇C2中的一个对象之间的距离是所有属于不同簇的对象间欧式距离中最小的,C1和C2可能被合并。这是一种单连接方法,其每个簇可以被簇中的所有对象代表,两个簇之间的相似度由这两个簇中距离最近的数据点对的相似度来确定。

    合并型层次聚类及产生二分树图的基本步骤如下:

    1. 计算n个对象两两之间的距离。
    2. 构造n个单成员聚类C1,C2,...,CnC_1, C_2,..., C_n。,每一类的高度都为0。
    3. 找到两个最近的聚类CiCjC_i,C_j; 合并CiCjC_i,C_j;,聚类的个数减少1,以被合并的两个类间距作为上层的高度。
    4. 计算新生成的聚类与本层中其他聚类的间距,如果满足终止条件,算法结束,否则转(3)。

    算法描述:

    input:包含n个对象的数据库,终止条件簇的数目k
    output:k个簇
    (1)       将每个对象当成一个初始簇
    (2)       Repeat
    (3)                根据两个簇中最近的数据点找到最近的两个簇
    (4)                合并两个簇,生成新的簇的集合
    (5)       Until达到定义的簇的数目
    

    优劣:

    • 简单,但遇到合并点选择困难的情况。
    • 一旦一组对象被合并,不能撤销
    • 算法的复杂度为O(n的平方),不适合大数据集

    code

    python

    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
    
    class Hierarchical(object):
        def __init__(self, pp, k = 1 ):
            # Python assert(断言)用于判断一个表达式,在表达式条件为 false 的时候触发异常。
            # 断言可以在条件不满足程序运行的情况下直接返回错误
            assert k > 0
            # k 聚类数目
            self.k = k
            # 标签
            self.labels = None
            # 预处理的数据处理类
            self.pp = pp
    
        # 数据表 行为记录
        # [
        #   [1,2,...],
        #   [1,2,...],
        #   ...
        # ]
        def fit(self, x):
            # enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)
            # 组合为一个索引序列,同时列出数据 v 和数据下标 i
            # 初始化所有节点(将所有的实例都当作一个节点)
            nodes = [ClusterNode(vec=v, id=i) for i, v in enumerate(x)]
            # 距离字典
            # {
            #   (node1,node2):distance,
            #   (node1,node3):distance,
            #   ...
            # }
            distances = {}
            # 特征的维度
            #   point_num:实例数目(贝叶斯网络中就是变量数目)
            #   future_num :特征(属性)数目(贝叶斯网络中就是实例数目)
            point_num, future_num = np.shape(x)
            # 初始化特征
            self.labels = [ -1 ] * point_num
            # 初试化当前节点ID
            currentclustid = -1
            # 进入凝聚的步骤 第一次循环:每条实例当作一个簇
            # 截止条件:nodes中节点数目不大于 K
            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是节点的ID
                part1, part2 = closest_part
                node1, node2 = nodes[part1], nodes[part2]
                # 构建新的节点中心=======================
                new_vec = [(node1.vec[ind] * node1.count + node2.vec[ind] * node2.count)
                           / (node1.count + node2.count)
                            for ind 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索引较大的
                del nodes[part2], nodes[part1]
                # 新节点加入到nodes容器中
                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)
    
    
    
    
    pp = PreProcess()
    pp.uses()
    
    # print(type(iris.data),iris)
    my = Hierarchical(pp, 25)
    # my.fit(iris.data)
    my.fit(pp.ndarray())
    pp.printVar()
    print(np.array(my.labels))
    my.calc_label()
    

    matlab

    K_cluster = 8;
    %% 初始化底层节点
    node = generate_node();
    % 构建初始节点
    nodes = init_nodes(node, varSize);
    % 当做非叶子节点的id(没什么用)
    currentclustid = -1;
    %% j
    while length(nodes) > K_cluster
        len_nodes = length(nodes);
        
        min_dist = -inf;
        min_pair_node = [];
        %% 选出最近的两个节点
        for ind =1:len_nodes
            for jnd =(ind+1):len_nodes
                node_A = nodes(ind);
                node_B = nodes(jnd);
                distance = average_distance(node_A, node_B, MMatrix);
                % 这儿是互信息,越大越好
                if distance > min_dist
                    min_dist = distance;
                    % 记录
                    min_pair_node = [ind jnd];
                end
            end
        end
        %% 合并最近的两个节点
        ind = min_pair_node(1);
        jnd = min_pair_node(2);
        node_A = nodes(ind);
        node_B = nodes(jnd);
        % 构建新的节点
        new_node = merge_two_node(node_A, node_B,distance,currentclustid);
        % 删除nodes中的node_A,node_B
        nodes(ind) = [];
        % ind位置删除之后,jnd需要减一位
        nodes(jnd-1) = [];
        % 添加 new_node 到 nodes
        nodes(length(nodes)+1) = new_node;
        % nodes = [nodes [new_node]];
        % 更新节点
        currentclustid = currentclustid -1;
    end
    
    function nodes = init_nodes(node, varSize)
    % 模板节点 node
    % 变量数目
    % 根据一个节点模板生成 varSize 个叶子节点
        nodes = repmat(node, varSize, 1);
        for ind =1:varSize
            nodes(ind).vec = [ind];
            nodes(ind).left = [];
            nodes(ind).right = [];
            nodes(ind).distance = 0;
            nodes(ind).id = ind;
            nodes(ind).count = 1;
            nodes(ind).leafnode = [ind];
        end
    end
    
    function node = generate_node()
        % 保存两个数据聚类后形成新的中心
        node.vec = [];
        % 左节点
        node.left = [];
        % 右节点
        node.right = [];
        % 左右两个节点的距离
        node.distance = [];
        % 用来标记哪些节点是计算过的
        node.id = [];
        % 这个节点的叶子节点个数(叶子节点的数目)
        node.count = [];
        % 这个节点的所以叶子节点(叶子节点集合)
        node.leafnode = [];
    end
    
    
    function node = merge_two_node(node_A, node_B,distance,currentclustid)
        % 保存两个数据聚类后形成新的中心
        % node = generate_node();
        node.vec = [];
        % 左节点
        node.left = node_A;
        % 右节点
        node.right = node_B;
        % 左右两个节点的距离
        node.distance = distance;
        % 用来标记哪些节点是计算过的
        node.id = currentclustid;
        % 这个节点的叶子节点个数(叶子节点的数目)
        node.count = node_A.count + node_B.count ;
        % 这个节点的所以叶子节点(叶子节点集合)
        node.leafnode = [node_A.leafnode  node_B.leafnode];
    end
    
    function distance = average_distance(node_A, node_B, MMatrix)
    % Average distance
    %   A 节点
    %   B 节点
    %   距离矩阵
        sum_distance = 0;
        % 计算 sum distance   
        lenA = length(node_A.leafnode) ;
        lenB = length(node_B.leafnode);
        % 计算平均距离
        for i=1:lenA
            for j=1:lenB
                X = node_A.leafnode(i);
                Y = node_B.leafnode(j);
                dist = MMatrix(X,Y);
                sum_distance = sum_distance + dist;
            end
        end
        %   数  目
        n_i_n_j = node_A.count*node_B.count;
        distance = sum_distance/n_i_n_j;
    end
    
    展开全文
  • 起步层次聚类( Hierarchical Clustering )是聚类算法的一种,通过计算不同类别的相似度类创建一个有层次的嵌套的树。层次聚类算法介绍假设有 n 个待聚类的样本,对于层次聚类算法,它的步骤是:步骤一:(初始化)将...

    起步

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

    层次聚类算法介绍

    假设有 n 个待聚类的样本,对于层次聚类算法,它的步骤是:步骤一:(初始化)将每个样本都视为一个聚类;

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

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

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

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

    聚类之间的相似度

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

    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]

    结果还算是理想的。

    层次聚类的优缺点

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

    相似度规则容易定义;

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

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

    算法很可能形成链状。

    附录

    展开全文
  • 层次聚类和Kmeans

    2020-12-21 20:56:12
    文章目录层次聚类层次聚类流程层次聚类优缺点Kmeans聚类Kmeans聚类流程K-Means的优缺点 层次聚类 层次聚类流程 (1) 计算两两样本之间的距离; (2) 将距离最小的两个类合并成一个新类; (3) 重新计算新类与所有类之间...
  • 层次聚类介绍

    2020-06-08 17:19:38
    层次聚类介绍 1.什么层次聚类 层次聚类(Hierarchical clustering)是聚类算法的一种,通过计算不同类别数据点间的相似度...层次聚类可以弥补Kmeans聚类的不足,层次聚类不需要提前确定K值,而且层次聚类可以处理不规
  • 层次聚类代码

    2018-05-02 16:26:22
    自己做的层次聚类 有可视化 有数据集 基于熵特征的聚类
  • 聚类算法之层次聚类

    万次阅读 多人点赞 2018-04-30 01:13:32
    一、原型聚类和层次聚类原型聚类也称基于原型的聚类(prototype-based clustering),这类算法假设聚类结构能够通过一组原型刻画,先对原型进行初始化,然后对原型进行迭代更新求解。采用不同的原型表示、不同的求解...
  • matlab 层次聚类

    千次阅读 2018-12-10 20:07:11
    这里最简单的实例说明以下层次聚类原理和应用发法。 层次聚类是基于距离的聚类方法,MATLAB中通过pdist、linkage、dendrogram、cluster等函数来完成。层次聚类的过程可以分这么几步: (1) 确定对象(实际上就是...
  • 层次聚类AHP

    2018-06-05 11:12:11
    一般通过给定网络的拓扑结构定义网络节点间的相似性或距离,然后采用单连接层次聚类或全连接层次聚类将网络节点组成一个树状图层次结构
  • 层次聚类算法

    2018-03-30 09:10:18
    关于层次聚类的一些算法的vvvvvv 懂得而奥迪哥如果该打发额而发阿打发
  • 层次聚类(Hierarchical Clustering)一.概念层次聚类不需要指定聚类的数目,首先它是将数据中的每个实例看作一个类,然后将最相似的两个类合并,该过程迭代计算只到剩下一个类为止,类由两个子类构成,每个子类又由更...
  • 使用 PHA 方法执行快速层次聚类。 该函数将从输入距离矩阵生成层次聚类树 (Z)。 输出 Z 类似于 Matlab 函数“linkage”的输出。 [主要特征] 1.比matlab联动功能更快。 2. 对混合正态分布的集群具有出色的性能。 3. ...
  • 层次聚类程序

    2013-12-04 15:23:07
    简单的层次聚类算法matlab程序,可以对txt文本数据进行聚类
  • 机器学习 层次聚类

    2021-07-17 22:01:56
    "层次聚类"(Hierarchical Clustering)是1类聚类算法.这种算法会根据不同数据点间的相似度来逐级将数据点分入不同类别,从而创建出1 棵有层次的聚类树.原始数据点是这颗树的最低层,树的顶层则是包含全部数据的根节点....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,878
精华内容 10,751
关键字:

层次聚类可以用什么