层次聚类

最新推荐文章于 2022-10-21 15:28:41 发布
最新推荐文章于 2022-10-21 15:28:41 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： 其他

1. 层次聚类

层次聚类算法与之前所讲的顺序聚类有很大不同，它不再产生单一聚类，而是产生一个聚类层次。说白了就是一棵层次树。介绍层次聚类之前，要先介绍一个概念——嵌套聚类。讲的简单点，聚类的嵌套与程序的嵌套一样，一个聚类中R1包含了另一个R2，那这就是R2嵌套在R1中，或者说是R1嵌套了R2。具体说怎么算嵌套呢？聚类R1={{x1,x2},{x3},{x4,x5}嵌套在聚类R2={{x1,x2,x3},{x4,x5}}中，但并不嵌套在聚类R3={{x1,x4},{x3},{x2,x5}}中。

层次聚类算法产生一个嵌套聚类的层次，算法最多包含N步，在第t步，执行的操作就是在前t-1步的聚类基础上生成新聚类。主要有合并和分裂两种实现。我这里只讲合并，因为前一阶段正好课题用到，另外就是合并更容易理解和实现。当然分裂其实就是合并的相反过程。

令g(Ci,Cj)为所有可能的X聚类对的函数，此函数用于测量两个聚类之间的近邻性，用t表示当前聚类的层次级别。通用合并算法的伪码描述如下：

1. 初始化：

a) 选择Â0={{x1},…,{xN}}

b) 令t=0

2. 重复执行以下步骤：

a) t=t+1

b) 在Ât-1中选择一组(Ci,Cj)，满足

c) 定义Cq=CiÈCj，并且产生新聚类Ât=(Ât-1-{Ci,Cj})È{Cq}

直到所有向量全被加入到单一聚类中。

这一方法在t层时将两个向量合并，那么这两个向量在以后的聚类过程中的后继聚类都是相同的，也就是说一旦它们走到一起，那么以后就不会再分离……（很专一哦O(∩_∩)O~）。这也就引出了这个算法的缺点，当在算法开始阶段，若出现聚类错误，那么这种错误将一直会被延续，无法修改。在层次t上，有N-t个聚类，为了确定t+1层上要合并的聚类对，必须考虑(N-t)(N-t-1)/2个聚类对。这样，聚类过程总共要考虑的聚类对数量就是(N-1)N(N+1)/6，也就是说整个算法的时间复杂度是O(N3)。

举例来说，如果令X={x1, x2, x3, x4, x5}，其中x1=[1, 1]T, x2=[2, 1]T, x3=[5, 4]T, x4=[6, 5]T, x5=[6.5, 6]T。那么合并算法执行的过程可以用下面的图来表示。

    P(X)是不相似矩阵

该算法从核心过程上来讲，就是先计算出数据集中向量之间的距离，记为距离矩阵（也叫不相似矩阵）。接着通过不断的对矩阵更新，完成聚类。矩阵更新算法的伪码描述如下：

1. 初始化：

a) Â0={{x1},…,{xN}}

b) P0=P(X) (距离矩阵)

c) t=0

2. 重复执行以下步骤：

a) t=t+1

b) 合并Ci和Cj为Cq，这两个聚类满足d(Ci,Cj)=minr,s=1,…,N,r≠sd(Cr,Cs)

c) 删除第i和j行，第i和j列，同时插入新的行和列，新的行列为新合并的类Cq与所有其他聚类之间的距离值

直到将所有向量合并到一个聚类中

大家可以看到，层次聚类算法的输出结果总是一个聚类，这往往不是我们想要的，我们总希望算法在得到我们期望的结果后就停止。那么我们如何控制呢？常用的做法就是为算法限制一个阈值，矩阵更新过程中，总是将两个距离最近的聚类合并，那么我们只要加入一个阈值判断，当这个距离大于阈值时，就说明不需要再合并了，此时算法结束。这样的阈值引入可以很好的控制算法结束时间，将层次截断在某一层上。

2. 算法实现

       MATLAB实现了层次聚类算法，基本语句如下：

1X = [1 2;2.5 4.5;2 2;4 1.5;4 2.5] ;
2Y = pdist(X,'euclid'); 
3Z = linkage(Y,'single'); 
4T = cluster(Z,'cutoff',cutoff);

MATLAB还有一个简化的层次聚类版本，一句话搞定

1T = clusterdata(X,cutoff)

Java实现的版本：

package util; 
 
import java.util.*; 
 
public class Clusterer { 
	 private List[] clusterList; 
   DisjointSets ds; 
   private static final int MAX = Integer.MAX_VALUE; 
   private int n; 
   private int cc; 

   // private double ori[] = {1,2,5,7,9,10}; 

   public Clusterer(int num) { 
       ds = new DisjointSets(num); 
       n = num; 
       cc = n; 
       clusterList = new ArrayList[num]; 
       for (int i = 0; i < n; i++) 
           clusterList[i] = new ArrayList(); 
   } 

   public List[] getClusterList() { 
       return clusterList; 
   } 

   public void setClusterList(List[] clusterList) { 
       this.clusterList = clusterList; 
   } 

   public void output() { 
       int ind = 1; 
       for (int i = 0; i < n; i++) { 
           clusterList[ds.find(i)].add(i); 
       } 
       for (int i = 0; i < n; i++) { 
           if (clusterList[i].size() != 0) { 
               System.out.print("cluster " + ind + " :"); 
               for (int j = 0; j < clusterList[i].size(); j++) { 
                   System.out.print(clusterList[i].get(j) + " "); 
               } 
               System.out.println(); 
               ind++; 
           } 
       } 
   } 

   /** *//** 
    * this method provides a hierachical way for clustering data. 
    * 
    * @param r 
    *            denote the distance matrix 
    * @param n 
    *            denote the sample num(distance matrix's row number) 
    * @param dis 
    *            denote the threshold to stop clustering 
    */ 
   public void cluster(double[][] r, int n, double dis) { 
       int mx = 0, my = 0; 
       double vmin = MAX; 
       for (int i = 0; i < n; i++) { // 寻找最小距离所在的行列 
           for (int j = 0; j < n; j++) { 
               if (j > i) { 
                   if (vmin > r[i][j]) { 
                       vmin = r[i][j]; 
                       mx = i; 
                       my = j; 
                   } 
               } 
           } 
       } 
       if (vmin > dis) { 
           return; 
       } 
       ds.union(ds.find(mx), ds.find(my)); // 将最小距离所在的行列实例聚类合并 
       double o1[] = r[mx]; 
       double o2[] = r[my]; 
       double v[] = new double[n]; 
       double vv[] = new double[n]; 
       for (int i = 0; i < n; i++) { 
           double tm = Math.min(o1[i], o2[i]); 
           if (tm != 0) 
               v[i] = tm; 
           else 
               v[i] = MAX; 
           vv[i] = MAX; 
       } 
       r[mx] = v; 
       r[my] = vv; 
       for (int i = 0; i < n; i++) { // 更新距离矩阵 
           r[i][mx] = v[i]; 
           r[i][my] = vv[i]; 
       } 
       cluster(r, n, dis); // 继续聚类，递归直至所有簇之间距离小于dis值 
   } 

   /** *//** 
    * 
    * @param r 
     * @param cnum 
     *            denote the number of final clusters 
     */ 
    public void cluster(double[][] r, int cnum) { 
        /**//*if(cc< cnum) 
            System.err.println("聚类数大于实例数");*/ 
        while (cc > cnum) {// 继续聚类，循环直至聚类个数等于cnum 
            int mx = 0, my = 0; 
            double vmin = MAX; 
            for (int i = 0; i < n; i++) { // 寻找最小距离所在的行列 
                for (int j = 0; j < n; j++) { 
                    if (j > i) { 
                        if (vmin > r[i][j]) { 
                            vmin = r[i][j]; 
                            mx = i; 
                            my = j; 
                        } 
                    } 
                } 
            } 
            ds.union(ds.find(mx), ds.find(my)); // 将最小距离所在的行列实例聚类合并 
            double o1[] = r[mx]; 
            double o2[] = r[my]; 
            double v[] = new double[n]; 
            double vv[] = new double[n]; 
            for (int i = 0; i < n; i++) { 
                double tm = Math.min(o1[i], o2[i]); 
                if (tm != 0) 
                    v[i] = tm; 
                else 
                    v[i] = MAX; 
                vv[i] = MAX; 
            } 
            r[mx] = v; 
            r[my] = vv; 
            for (int i = 0; i < n; i++) { // 更新距离矩阵 
                r[i][mx] = v[i]; 
                r[i][my] = vv[i]; 
            } 
            cc--; 
        } 
    } 
 
    public static void main(String args[]) { 
        double[][] r = { { 0, 1, 4, 6, 8, 9 }, { 1, 0, 3, 5, 7, 8 }, 
                { 4, 3, 0, 2, 4, 5 }, { 6, 5, 2, 0, 2, 3 }, 
                { 8, 7, 4, 2, 0, 1 }, { 9, 8, 5, 3, 1, 0 } }; 
        Clusterer cl = new Clusterer(6); 
        //cl.cluster(r, 6, 1); 
        cl.cluster(r, 3); 
        cl.output(); 
    } 
 
}


 

3. 小结
       层次聚类算法是非常常用的聚类算法，同时也是被广泛研究的聚类算法。层次聚类本身分为合并和分裂两种实现，在合并算法中，又分基于矩阵理论的合并和基于图论的合并。本文只是初学聚类的一点体会，因此只实现了基于矩阵理论的算法，同时，用于大数据集合的层次算法如CURE，ROCK和Chameleon算法都没有涉及，这些算法如果以后有时间，会整理发布。还有截断点的选择，最佳聚类数的确定都是可以研究的问题。

4. 参考文献及推荐阅读
[1]Pattern Recognition Third Edition, Sergios Theodoridis, Konstantinos Koutroumbas

[2]模式识别第三版, Sergios Theodoridis, Konstantinos Koutroumbas著, 李晶皎, 王爱侠, 张广源等译

http://www.blogjava.net/changedi/archive/2010/03/19/315963.html

http://ishare.iask.sina.com.cn/f/12149552.html?from=like

Jun-H
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
层次聚类代码
05-02
自己做的层次聚类 有可视化 有数据集 基于熵特征的聚类
聚类算法伪代码
yingzi的技术博客
05-16 1484
基于层次的聚类算法（以BIRCH算法为例）
12-03
基于层次的聚类算法（以BIRCH算法为例） 输入：包含N个对象的数据集合D 输出：簇集合。
层次聚类_层次聚类MATLAB实现_
09-30
层次聚类（Hierarchical Clustering）是一种数据挖掘技术，用于将数据集中的对象根据相似性或距离进行分组，形成一个层次结构。这种算法可以分为两种类型：凝聚型（Agglomerative）和分裂型（Divisive）。在这个...
Python实现简单层次聚类算法以及可视化
09-19
标题中的"Python实现简单层次聚类算法以及可视化"是指使用Python编程语言来实施层次聚类（Hierarchical Clustering）算法，并通过图形化展示聚类结果的过程。层次聚类是一种无监督学习方法，常用于数据挖掘领域，...
matlab层次聚类算法
12-26
在IT领域，尤其是在数据分析和机器学习中，层次聚类（Hierarchical Clustering）是一种常见的无监督学习方法，用于将数据集中的对象分组成具有相似性的集合，即“簇”。MATLAB作为一款强大的数学计算软件，提供了...
层次聚类算法
03-30
关于层次聚类的一些算法的vvvvvv 懂得而奥迪哥如果该打发额而发阿打发
凝聚层次聚类的matlab代码.zip_层次聚类_层次聚类 MATLAB_层次聚类MATLAB_层次聚类算法_聚类
07-14
本资源提供的是基于MATLAB实现的层次聚类算法，这是一套强大的工具，用于理解数据的内在结构。下面将详细阐述层次聚类的基本概念、MATLAB实现以及提供的文件内容。 层次聚类是一种自底向上的或自顶向下的方法，它...
层次分析法(AHP)源码
10-24
层次分析法(AHP)源码，新手亲测亲写，写的比较简单，有问题留言回复
层次聚类算法C++
06-22
层次聚类算法是一种数据挖掘中的无监督学习方法，主要用于对数据进行分类或分组，而无需预先知道数据的标签或类别。在C++中实现层次聚类，通常涉及到多个步骤和核心概念，如距离计算、聚类合并和树状结构...
Diana.rar_DIANA算法_层次 聚类_层次聚类diana_聚类算法diana
07-14
经典层次聚类算法DIANA，MATLAB编程，简单易懂，可以运行
层次聚类的评价
06-28
关于层次聚类的评价指标
Python聚类算法之凝聚层次聚类实例分析
09-21
凝聚层次聚类（Agglomerative Clustering）是一种典型的层次聚类方法，它通过逐步合并相似度高的对象来构建聚类树（Dendrogram）。在Python中，我们可以利用各种库，如`sklearn`，来进行凝聚层次聚类。在这个实例中...
聚类--KM、DBACSN，层次聚类
weixin_42774642的博客
03-06 975
1. 聚类 对于聚类，关键一步是要告诉计算机怎样计算两个数据点的相似性，不同的算法需要的相似性是不一样的。 1.1. DBSCAN 1.1.1. DBSCAN原理 DBSCAN核心原理就是密度聚类的原理：寻找出稠密的地方，把它们当做一个簇，也就是密度相连的区域，我们把它当成一个簇。 ​ “DBSCAN如何发现簇？”初始，给定数据集D中的所有对象都被为‘unv...
层次聚类分析及代码实现
小八四爱吃甜食的博客
10-21 1685
如果对计算距离矩阵和聚类的算法有特定要求，可以参考下面的参数介绍。3，闵科夫斯基距离：minkowski。4，切比雪夫距离：chebyshev。5，马氏距离：mahalanobis。2，欧氏距离：euclidean。4，最长距离法：complete。1，绝对距离：manhattan。6，蓝氏距离：canberra。7，密度估计法：density。1，类平均法：average。2，重心法：centroid。3，中间距离法:median。5，最短距离法：single。6，离差平方和法：ward。
层次聚类（1）
Expressing Youself Using Code
01-09 4951
层次聚类算法不同于其它算法，主要体现在它不是只生成一个分类结果，而是产生一系列原模式集合的分类结果，每个分类结果满足一些限制。 1、概念 X = {x_i, i = 1,...,N}; 是N个l维特征向量组成的集合，我们就是要对这个集合中的特征向量分类。 Clustering ： R = {C_j, j = 1,...,m}。是某个聚类结果，就叫他类簇吧，我想这样叫，也许别人已经定义
层次聚类 python代码
最新发布
05-27
层次聚类是一种基于树形结构的聚类算法，它通过计算样本之间的相似度来构建一棵树形结构，树的叶子节点就是样本，而树的根节点则是所有样本的最近公共祖先。层次聚类分为两种：自上而下的聚合式层次聚类和自下而上的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值