精华内容
下载资源
问答
  • 2019-05-02 21:41:54

    一. 层次聚类

    层次聚类(hierarchical clustering)是一种基于原型的聚类算法,试图在不同层次对数据集进行划分,从而形成树形的聚类结构。数据集的划分可采用"自底向上"的聚合策略,也可以采用"自顶向下"的分拆策略。层次聚类算法的优势在于,可以通过绘制树状图(dendrogram),帮助我们使用可视化的方式来解释聚类结果。层次聚类的另一个优点就是,它不需要事先指定簇的数量。

    二. 凝聚层次聚类

    层次聚类可以分为凝聚(agglomerative)层次聚类和分裂(divsive)层次聚类。分裂层次聚类采用的就是"自顶而下"的思想,先将所有的样本都看作是同一个簇,然后通过迭代将簇划分为更小的簇,直到每个簇中只有一个样本为止。凝聚层次聚类采用的是"自底向上"的思想,先将每一个样本都看成是一个不同的簇,通过重复将最近的一对簇进行合并,直到最后所有的样本都属于同一个簇为止。
    在凝聚层次聚类中,判定簇间距离的两个标准方法就是单连接(single linkage)和全连接(complete linkage)。单连接,是计算每一对簇中最相似两个样本的距离,并合并距离最近的两个样本所属簇。全连接,通过比较找到分布于两个簇中最不相似的样本(距离最远),从而来完成簇的合并。
    在这里插入图片描述凝聚层次聚类除了通过单连接和全连接来判断两个簇之间的距离之外,还可以通过平均连接(average linkage)和ward连接。使用平均连接时,合并两个簇所有成员间平均距离最小的两个簇。使用ward连接,合并的是使得SSE增量最小的两个簇。

    三. 全连接的凝聚层次聚类

    基于全连接的凝聚层次聚类主要包括下面几个步骤:
    1、获取所有样本的距离矩阵
    2、将每个数据点作为一个单独的簇
    3、基于最不相似(距离最远)样本的距离,合并两个最接近的簇
    4、更新样本的距离矩阵
    5、重复2到4,直到所有样本都属于同一个簇为止

    更多相关内容
  • 关于层次聚类(hierarchical clustering)的基本步骤: 1、假设每个样本为一类,计算每个类的距离,也就是相似度 2、把最近的两个合为一新类,这样类别数量就少了一个 3、重新新类与各个旧类(去了那两个合并的类)之间...
  • 层次聚类概述

    2022-04-17 19:45:24
    文章目录层次聚类聚合式聚类簇间距离的计算单链接(single-linkage)全链接(complete-linkage)平均链接(average-linkage)三种距离方式的比较分拆式聚类层次聚类算法总结 层次聚类 层次聚类(hierarchical clustering...

    层次聚类

    • 层次聚类(hierarchical clustering)试图在不同层次对数据集进行划分,从而形成树形的聚类结构,
    • 数据集的划分可采用“自底向上(合并)”的聚合策略,也可采用“自顶向下(拆分)”的分析策略。依据采用的策略可以将层次聚类方法分为:
      • 聚合式聚类(agglomerative clustering)
      • 分拆式聚类(divisive clustering)
    • 两种方法均是启发式的策略,没有去优化一个明确的目标函数来实现聚类,很难严格评价聚类的效果。
    • 层次聚类得到的结果是 "树状图"

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z34BaNpQ-1650195896617)(C:\Users\wzq20\AppData\Roaming\Typora\typora-user-images\image-20220417190150643.png)]

    根据不同虚线的位置,可以得到不同数量的聚类

    聚合式聚类

    • 在开始时把每个样本都每个样本都当成一簇,然后在每一次迭代中将最相似的(距离最近)的两个簇合并,直到把所有簇合并为包含所有样本的一簇

    流程

    1. 将每个样本看做一个簇: C i ← { i } , i = 1 , 2 , . . . , n C_i \leftarrow \{i\}, i = 1,2,...,n Ci{i},i=1,2,...,n
    2. 初始化可供合并的簇集: S ← { 1 , 2 , . . . , n } S \leftarrow \{1,2,...,n\} S{1,2,...,n}
    3. 计算出簇间距离矩阵
    4. 重复迭代如下步骤直至没有可供合并的簇:
      1. 选择两个最相似的簇进行合并: ( j , k ) ← a r g min ⁡ j , k ∈ S d j , k (j,k) \leftarrow arg\min_{j,k \in S} d_{j,k} (j,k)argminj,kSdj,k
      2. 创建新簇 C l ← C j ∪ C k C_l \leftarrow C_j \cup C_k ClCjCk
      3. S S S 中取出已合并的 j j j k k k S ← S ∖ { j , k } S \leftarrow S\setminus\{ j,k\} SS{j,k}
      4. 如果 C l ≠ { 1 , 2 , . . . , n } C_l \neq \{ 1,2,...,n\} Cl={1,2,...,n},那么增加一个可合并集 S ← S ∪ { l } S \leftarrow S \cup \{l\} SS{l}
      5. 对于每个 i ∈ S i \in S iS ,更新簇间距离矩阵 d ( i , l ) d(i,l) d(i,l)

    簇间距离的计算

    单链接(single-linkage)

    ​ 也称为最近邻距离,即簇 G G G 和簇 H H H之间的距离定义为两簇之间最近的成员之间的距离:
    d s l ( G , h ) = min ⁡ i ∈ G , i ′ ∈ H d i , i ′ d_{sl}(G,h) = \min_{i \in G, i^{'} \in H}d_{i,i^{'}} dsl(G,h)=iG,iHmindi,i
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nVJ3AqxQ-1650195896619)(C:\Users\wzq20\AppData\Roaming\Typora\typora-user-images\image-20220417182009402.png)]

    全链接(complete-linkage)

    ​ 也称为最远邻距离,即簇G和簇H之间的距离定义为两簇之间最远的成员之间的距离。
    d c l ( G , H ) = max ⁡ i ∈ G , i ′ ∈ H d i , i ′ d_{cl}(G,H) = \max_{i \in G, i^{'} \in H}d_{i,i^{'}} dcl(G,H)=iG,iHmaxdi,i
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ilNdjrs8-1650195896619)(C:\Users\wzq20\AppData\Roaming\Typora\typora-user-images\image-20220417182432648.png)]

    平均链接(average-linkage)

    • 表示两簇之间所有成员对的平均距离

    d a v g ( G , H ) = 1 n G n H ∑ i ∈ G ∑ i ′ ∈ H d i , i ′ d_{avg}(G,H) = \frac 1{n_Gn_H}\sum_{i \in G}\sum _{i^{'} \in H}d_{i,i^{'}} davg(G,H)=nGnH1iGiHdi,i

    • n G n_G nG n H n_H nH 是簇G和簇H的样本个数。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tQAH1B2A-1650195896620)(C:\Users\wzq20\AppData\Roaming\Typora\typora-user-images\image-20220417182643242.png)]

    三种距离方式的比较

    • 单链接(single-linkage)
      • 只需要考虑两簇之间有成员对距离足够近就将两簇合并,而并没有考虑其他簇内其他成员的距离。因此单连接法形成的簇很有可能违背紧致性特征,即簇内成员应该尽可能相似
    • 全连接法(complete-linkage):
      • 只有两簇的联合的成员间的距离相对较小时,才将两簇合并,因此完整连接法倾向于生成紧致簇
    • 均连接法(average-linkage)
      • 介于单连接和全连接之间的方法
      • 易于生成相对紧致的簇同时簇间距离较远。

    分拆式聚类

    ​ 分拆聚类将所有样本集合看作一簇,以自上而下的方式,递归地将现有的簇分拆为两个子簇。

    ​ 利用不同的启发式方法进行分拆方式的选择:

    • 二分K-means聚类

      • 选择半径最大的簇,对该簇进行K(2)-means聚类分为两个子簇
      • 重复此过程直到到达想要的簇个数
    • 最小生成树法

      • 将每个样本看作一个图节点,将样本间距离看作节点边的权重,根据此图建立最小生成树。
      • 从权重最大处将该簇分拆为两簇,然后重复此过程直到达到想要的簇个数。实际上,该方法得到的聚类结果和单连接的聚合聚类得到的结果一致。

    层次聚类算法总结

    • 层次聚类一次性地得到了整个聚类的过程,想要分多少个簇都可以直接根据“树状图”来得到结果,改变簇的数目不再需要再次计算数据点的归属类别;
    • 单连接和全连接代表了簇间距离度量的两个极端,它们对离群点或噪声数据过分敏感
    • 平均连接时一种计算量大,而且错分在层次聚类中时不可修正的,一旦某个样本被分到某个聚类中,则该样本永远停留在该聚类中。
    • 层次聚类的缺点是:
      • 计算量大
      • 而且错分在聚合式聚类中是不可修正的,一旦某个样本被分到某个聚类中,则该样本永远停留在该聚类中。
    展开全文
  • 本篇想和大家介绍下层次聚类,先通过一个简单的例子介绍它的基本理论,然后再用一个实战案例Python代码实现聚类效果。首先要说,聚类属于机器学习的无监督学习,而且也分很多种方法,比如大家熟知...

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

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

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

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

    • 决定簇数(k)

    • 从数据中随机选取 k 个点作为质心

    • 将所有点分配到最近的聚类质心

    • 计算新形成的簇的质心

    • 重复步骤 3 和 4

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

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

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

    什么是层次聚类?

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

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

    65ba2e5e98ec533c8a52ac1ecf78cc6d.png

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

    82fcde7917c45c29201befe7f06f2735.png

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

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

    层次聚类的类型

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

    • 凝聚层次聚类

    • 分裂层次聚类

    凝聚层次聚类

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

    分裂层次聚类

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

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

    139ebe32564391bb84cc4f2cfde4e05d.png

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

    72e6f01bcf97fece7af6c872b77b55ec.png

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

    执行层次聚类的步骤

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

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

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

    案例介绍

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

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

    21a87482a1232469a6c6ab6d77f93ac7.png

    创建邻近矩阵

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

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

    a3d1a80c858af8bf67ce31a58f15e9de.png

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

    • 矩阵的对角元素始终为 0,因为点与其自身的距离始终为 0

    • 使用欧几里得距离公式来计算非对角元素的距离

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

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

    执行层次聚类

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

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

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

    步骤2:接下来,我们需要查找邻近矩阵中的最小距离并合并距离最小的点。然后我们更新邻近矩阵:dc993ffeafa0c76cc99243192a23110b.png最小距离是 3,因此我们将合并点 1 和 2:5643277eec89aaa05ee05e5073ad10aa.png让我们看看更新的集群并相应地更新邻近矩阵:eb02ea01b64c4b0b1e67751f74ebf142.png

    更新之后,我们取了1、2 两个点中值 (7, 10) 最大的来替换这个簇的值。当然除了最大值之外,我们还可以取最小值或平均值。然后,我们将再次计算这些簇的邻近矩阵:fc912a4a38eaef6f9dee6f02cf0dc362.png第 3 步:重复第 2 步,直到只剩下一个簇。

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

    c219f86f2462373bf8a78ac536bbe964.png

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

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

    如何选择聚类数?

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

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

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

    1b6f476a20ce2c5962e06b615007f751.png

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

    174441e6bf8f98af7ce370d7690b7f62.png

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

    d69c3fa4ccc084044f6cf44e26a43fb1.png

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

    a9f93d9ce88352b5d0d2076ab06a5516.png

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

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

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

    99b458a3f9fa4965a97c8f3d446286e1.png

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

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

    Python代码实战案例

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

    数据集和代码在我的GitHub里,欢迎star!

    https://github.com/xiaoyusmd/PythonDataScience

    这个数据来源于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'))
    f9ab03df1f911b312d225d60377f2624.png

    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='--')
    636abf12cb9c4e843c7ef6c91d4b540a.png

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

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

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

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

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

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

    END -

    
     
    对比Excel系列图书累积销量达15w册,让你轻松掌握数据分析技能,可以在全网搜索书名进行了解:
    展开全文
  • HypHC:双曲层次聚类

    2021-04-01 01:14:42
    基于相似性的层次聚类(HC)是一种经典的无监督机器学习算法,传统上已使用诸如平均链接之类的启发式算法进行了求解。 最近,Dasgupta通过引入衡量给定树质量的全局成本函数,将HC重新构架为离散的优化问题。 在这...
  • 层次聚类(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
    from sklearn import datasets,cluster
    
    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_)

    得到输出:

    层次聚类的优缺点:

    优点:

    • 一次性得到聚类树,后期再分类无需重新计算;
    • 相似度规则容易定义;
    • 可以发现类别的层次关系。

    缺点:

    • 计算复杂度高,不适合数据量大的;
    • 算法很可能形成链状。

     

    展开全文
  • 层次聚类 层次聚类(Hierarchical Clustering)是聚类算法的一种,通过计算不同类别数据点间的相似度来创建一棵有层次的嵌套聚类树。在聚类树中,不同类别的原始数据点是树的最低层,树的顶层是一个聚类的根节点。创建...
  • 层次聚类简介

    2017-03-27 14:43:25
    层次聚类简介
  • 层次聚类算法的实现

    千次阅读 多人点赞 2022-04-12 16:00:32
    层次聚类算法介绍2.1 层次聚类算法原理2.2 层次聚类算法步骤2.3 层次聚类算法分类3.层次聚类算法实现(代码如下)3.1 相关包导入3.2 生成测试数据集3.3 层次聚类实现&画出树状图3.4 获取聚类结果3.5 对比不同方法...
  • 层次聚类matlab代码层次聚类算法 matlab代码,采用了单链接,完全链接和平均链接算法的层次聚类算法。
  • 层次聚类python实现

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

    2022-03-06 10:48:28
    最近在自学图灵教材《Python机器学习基础教程》,在csdn以博客的形式做些笔记。 凝聚聚类算法简述 ...还有一些链接(linkage)准则,规定如何度量“最相似的簇”。这种度量总是定义在两个现有的簇之间。 scikit
  • python 实现层次聚类一. scipy实现1. 函数说明主要是两个函数:linkage,fcluster1). linkage:def linkage(y, method=‘single’, metric=‘euclidean’, optimal_ordering=False):函数功能解释:执行层次/聚集聚类...
  •   层次聚类和K-means聚类以及DBSCAN聚类又截然不同。层次聚类的核心思想是试图在不同层次对数据集进行划分,形成树形的结构。本章主要介绍层次聚类的思想,算法具体步骤和Matlab编程实践。 算法原理   层次聚类...
  • 层次聚类

    2020-05-22 05:25:25
    层次聚类,也称为层次聚类分析,是一种将相似对象分组为聚类的算法。 端点是一组群集,其中每个群集彼此都不相同,并且每个群集内的对象彼此大致相似。 分层聚类技术: 层次聚类是一种流行且易于理解的聚类技术。此...
  • 层次聚类算法介绍

    2020-07-15 00:23:38
    3合并算法思想1)重心法2)最短距离法3)最长距离法4)组间平均连接法5)组内平均链接法4算法流程程序执行过程:5 示例与分析5.1基于最小值的层次聚类优缺点5.2 基于最大值的层次聚类优缺点5.3基于组平均优缺点 ...
  • R中的层次聚类

    2021-12-04 20:13:27
    R中的层次聚类 聚类是最常见的无监督学习形式,是一种用于从未标记数据中得出推论的机器学习算法。 在本教程中,您将学习在 R 中对数据集执行层次聚类。更具体地说,您将了解: 什么是聚类,何时使用及其...
  • 机器学习实战——层次聚类算法

    千次阅读 2019-01-24 16:02:27
    机器学习实战——层次聚类算法1 层次聚类概述2 sklearn中的实现 1 层次聚类概述 层次聚类试图在不同层次对数据集进行划分,从而形成树形的聚类结构。 数据集的划分可采用"自底向上"的聚合策略,也可采用&...
  • 基于层次聚类方法,是对给定的数据进行层次的分解,直到某种条件满足为止。首先将数据点组成一颗聚类树,根据层次,自底向上或是自顶向下分解。层次的方法可以分为凝聚的方法和分裂的方法。 凝聚的方法,也称为自...
  • Python学习3-层次聚类

    千次阅读 2021-12-08 20:37:38
    0.层次聚类的概念 层次聚类和k-means一样都是很常用的聚类方法。层次聚类是对群体的划分,最终将样本划分为树状的结构。他的基本思路是每个样本先自成一类,然后按照某种规则进行合并,直到只有一类或者某一类的...
  • 层次聚类方法 给出N个数据的数据集和一个N×N的距离矩阵,层次聚 类的基本算法如下: 步骤1将每个数据点作为一个簇,簇间的距离(相似)等于相应数据点的距离。 步骤2找到最相近(最相似)的两个簇,然后把它们合并...
  • 层次聚类的定义、实现方法,以及实现工具。
  • 层次聚类1.1 凝聚聚类1.2 层次图1.3 不同凝聚算法比较2. Sklearn 实现2.1 层次图可视化参考文献 1. 层次聚类 层次聚类(hierarchical clustering)试图在不同层次对数据集进行划分,从而形成树形的聚类结构。数据...
  • 层次聚类-Hierarchical Clustering

    千次阅读 2021-07-24 10:09:28
    层次聚类(Hierarchical Clustering)是聚类算法的一种,通过计算不同类别数据点间的相似度来创建一棵有层次的嵌套聚类树,距离越小,相似度越高。在聚类树中,不同类别的原始数据点是树的最低层,树的顶层是一个聚类...
  • 机器学习(聚类六)——层次聚类

    千次阅读 2020-04-13 16:28:34
    这篇博客开始另外一种聚类——层次聚类层次聚类和K-Means是同一类的,属于划分聚类。层次聚类方法对给定的数据集进行层次的分解,直到满足某种条件为止.
  • 聚类分析 之 凝聚层次聚类

    千次阅读 2019-12-17 19:46:59
    两种产生层次聚类的基本方法: 凝聚的: 从点作为个体簇开始,每一步合并两个最近的簇, 需要定义簇的邻近性概念(开始每个点都是一个簇,然后不断合并减少簇的数量)。 分裂的; 从包含所有点的某个簇开始,每...
  • 层次聚类算法是建立簇的层次,每个结点是一个簇,且又包含了子簇结点。层次聚类算法包括聚集聚类算法和分裂聚集算法。分裂聚集是从一个大的簇划分为小的结点。而聚集聚类是反过来的,从单个结点到一个大的簇。 2 ...
  • 聚类分析–处理无标签数据 from IPython.display import Image %matplotlib inline 1.使用K-Means方法按照相似度对对象进行分组 1.1使用sklearn实现K-Means聚类 from sklearn.datasets import make_blobs X, y = ...
  • 先介绍下聚类的不同类型,通常有以下几种:(1)层次的与划分的:如果允许簇具有子簇,则我们得到一个层次聚类层次聚类是嵌套簇的集族,组织成一棵树。划分聚类简单地将数据对象划分成不重叠的子集(簇),使得每个...
  • 聚类算法(4)--Hierarchical clustering层次聚类

    万次阅读 多人点赞 2018-11-07 17:45:47
    一、层次聚类 1、层次聚类的原理及分类 2、层次聚类的流程 3、层次聚类的优缺点 二、python实现 1、sklearn实现 2、scipy实现 树状图分类判断 一、层次聚类 1、层次聚类的原理及分类 1)层次法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,613
精华内容 3,045
关键字:

层次聚类的单链接

友情链接: CSharpPAE-Map-query.rar