精华内容
下载资源
问答
  • 聚类算法概念聚类分析又称群分析,它是研究(样品或指标)分类问题的一种统计分析方法,同时也是数据挖掘的一个重要算法。聚类(Cluster)分析是由若干模式(Pattern)组成的,通常,模式是一个度量(Measurement)的向量,...

    聚类算法概念

    聚类分析又称群分析,它是研究(样品或指标)分类问题的一种统计分析方法,同时也是数据挖掘的一个重要算法。聚类(Cluster)分析是由若干模式(Pattern)组成的,通常,模式是一个度量(Measurement)的向量,或者是多维空间中的一个点。聚类分析以相似性为基础,在一个聚类中的模式之间比不在同一聚类中的模式之间具有更多的相似性。

    聚类的用途是很广泛的。在商业上,聚类可以帮助市场分析人员从消费者数据库中区分出不同的消费群体来,并且概括出每一类消费者的消费模式或者说习惯。它作为数据挖掘中的一个模块,可以作为一个单独的工具以发现数据库中分布的一些深层的信息,并且概括出每一类的特点,或者把注意力放在某一个特定的类上以作进一步的分析;并且,聚类分析也可以作为数据挖掘算法中其他分析算法的一个预处理步骤。

    聚类分析的算法可以分为划分法(PartitioningMethods)、层次法(HierarchicalMethods)、基于密度的方法(density-basedmethods)、基于网格的方法(grid-basedmethods)、基于模型的方法(Model-BasedMethods)。

    聚类算法的分类

    划分法

    划分法(partitioningmethods),给定一个有N个元组或者纪录的数据集,分裂法将构造K个分组,每一个分组就代表一个聚类,K《N。而且这K个分组满足下列条件:

    (1)每一个分组至少包含一个数据纪录;

    (2)每一个数据纪录属于且仅属于一个分组(注意:这个要求在某些模糊聚类算法中可以放宽);

    对于给定的K,算法首先给出一个初始的分组方法,以后通过反复迭代的方法改变分组,使得每一次改进之后的分组方案都较前一次好,而所谓好的标准就是:同一分组中的记录越近越好,而不同分组中的纪录越远越好。

    大部分划分方法是基于距离的。给定要构建的分区数k,划分方法首先创建一个初始化划分。然后,它采用一种迭代的重定位技术,通过把对象从一个组移动到另一个组来进行划分。一个好的划分的一般准备是:同一个簇中的对象尽可能相互接近或相关,而不同的簇中的对象尽可能远离或不同。还有许多评判划分质量的其他准则。传统的划分方法可以扩展到子空间聚类,而不是搜索整个数据空间。当存在很多属性并且数据稀疏时,这是有用的。为了达到全局最优,基于划分的聚类可能需要穷举所有可能的划分,计算量极大。实际上,大多数应用都采用了流行的启发式方法,如k-均值和k-中心算法,渐近的提高聚类质量,逼近局部最优解。这些启发式聚类方法很适合发现中小规模的数据库中小规模的数据库中的球状簇。为了发现具有复杂形状的簇和对超大型数据集进行聚类,需要进一步扩展基于划分的方法。

    使用这个基本思想的算法有:K-MEANS算法、K-MEDOIDS算法、CLARANS算法;

    层次法

    层次法(hierarchicalmethods),这种方法对给定的数据集进行层次似的分解,直到某种条件满足为止。具体又可分为“自底向上”和“自顶向下”两种方案。

    例如,在“自底向上”方案中,初始时每一个数据纪录都组成一个单独的组,在接下来的迭代中,它把那些相互邻近的组合并成一个组,直到所有的记录组成一个分组或者某个条件满足为止。

    层次聚类方法可以是基于距离的或基于密度或连通性的。层次聚类方法的一些扩展也考虑了子空间聚类。层次方法的缺陷在于,一旦一个步骤(合并或分裂)完成,它就不能被撤销。这个严格规定是有用的,因为不用担心不同选择的组合数目,它将产生较小的计算开销。然而这种技术不能更正错误的决定。已经提出了一些提高层次聚类质量的方法。

    代表算法有:BIRCH算法、CURE算法、CHAMELEON算法等;

    密度算法

    基于密度的方法(density-basedmethods),基于密度的方法与其它方法的一个根本区别是:它不是基于各种各样的距离的,而是基于密度的。这样就能克服基于距离的算法只能发现“类圆形”的聚类的缺点。

    这个方法的指导思想就是,只要一个区域中的点的密度大过某个阈值,就把它加到与之相近的聚类中去。

    代表算法有:DBSCAN算法、OPTICS算法、DENCLUE算法等;

    图论聚类法

    图论聚类方法解决的第一步是建立与问题相适应的图,图的节点对应于被分析数据的最小单元,图的边(或弧)对应于最小处理单元数据之间的相似性度量。因此,每一个最小处理单元数据之间都会有一个度量表达,这就确保了数据的局部特性比较易于处理。图论聚类法是以样本数据的局域连接特征作为聚类的主要信息源,因而其主要优点是易于处理局部数据的特性。

    网格算法

    基于网格的方法(grid-basedmethods),这种方法首先将数据空间划分成为有限个单元(cell)的网格结构,所有的处理都是以单个的单元为对象的。这么处理的一个突出的优点就是处理速度很快,通常这是与目标数据库中记录的个数无关的,它只与把数据空间分为多少个单元有关。

    代表算法有:STING算法、CLIQUE算法、WAVE-CLUSTER算法;

    模型算法

    基于模型的方法(model-basedmethods),基于模型的方法给每一个聚类假定一个模型,然后去寻找能够很好的满足这个模型的数据集。这样一个模型可能是数据点在空间中的密度分布函数或者其它。它的一个潜在的假定就是:目标数据集是由一系列的概率分布所决定的。

    通常有两种尝试方向:统计的方案和神经网络的方案。

    基于密度DBSCAN的聚类算法

    DBSCAN算法的原理

    1、基本概念

    DBSCAN(Density-BasedSpatialClusteringofApplicationwithNoise)是一种典型的基于密度的聚类算法,在DBSCAN算法中将数据点分为一下三类:

    核心点。在半径Eps内含有超过MinPts数目的点

    边界点。在半径Eps内点的数量小于MinPts,但是落在核心点的邻域内

    噪音点。既不是核心点也不是边界点的点

    在这里有两个量,一个是半径Eps,另一个是指定的数目MinPts。

    其他的概念

    1)Eps邻域。简单来讲就是与点p的距离小于等于Eps的所有的点的集合,可以表示为

    2112f5a523035547a59e7f63c016cb5b.png

    2)直接密度可达。如果p在核心对象q的Eps邻域内,则称对象p从对象q出发是直接密度可达的。

    3)密度可达。对于对象链

    716f55ac28ade1aa9151aa689f07fe6c.png:,

    36694800846b9d783236fff15a0aee11.png是从

    25751b21cede49c4d759309a7ab9c33c.png关于Eps和MinPts直接密度可达的,则对象

    cddc78942981d43d09be0c054db4618c.png是从对象

    48dc40e1884d3f995d8775aab2e79f05.png关于Eps和MinPts密度可达的。

    2、算法流程

    1de41a00f788579bd5f7c68f66de61e8.png

    实验仿真

    在实验中使用了两个测试数据集,数据集的原始图像如下:

    cc3bf807c6dea52afa1ab9b77ed21e47.png

    (数据集1)

    3414032702b42f8df8fb757017457b60.png

    (数据集2)

    数据集1相对比较简单。显然我们可以发现数据集1共有两个类,数据集2有四个类,下面我们通过DBSCAN算法实现数据点的聚类:

    主程序

    %%DBSCAN

    clearall;

    clc;

    %%导入数据集

    %data=load(‘testData.txt’);

    data=load(‘testData_2.txt’);

    %定义参数Eps和MinPts

    MinPts=5;

    Eps=epsilon(data,MinPts);

    [m,n]=size(data);%得到数据的大小

    x=[(1:m)‘data];

    [m,n]=size(x);%重新计算数据集的大小

    types=zeros(1,m);%用于区分核心点1,边界点0和噪音点-1

    dealed=zeros(m,1);%用于判断该点是否处理过,0表示未处理过

    dis=calDistance(x(:,2:n));

    number=1;%用于标记类

    %%对每一个点进行处理

    fori=1:m

    %找到未处理的点

    ifdealed(i)==0

    xTemp=x(i,:);

    D=dis(i,:);%取得第i个点到其他所有点的距离

    ind=find(D《=Eps);%找到半径Eps内的所有点

    %%区分点的类型

    %边界点

    iflength(ind)》1&&length(ind)《MinPts+1

    types(i)=0;

    class(i)=0;

    end

    %噪音点

    iflength(ind)==1

    types(i)=-1;

    class(i)=-1;

    dealed(i)=1;

    end

    %核心点(此处是关键步骤)

    iflength(ind)》=MinPts+1

    types(xTemp(1,1))=1;

    class(ind)=number;

    %判断核心点是否密度可达

    while~isempty(ind)

    yTemp=x(ind(1),:);

    dealed(ind(1))=1;

    ind(1)=[];

    D=dis(yTemp(1,1),:);%找到与ind(1)之间的距离

    ind_1=find(D《=Eps);

    iflength(ind_1)》1%处理非噪音点

    class(ind_1)=number;

    iflength(ind_1)》=MinPts+1

    types(yTemp(1,1))=1;

    else

    types(yTemp(1,1))=0;

    end

    forj=1:length(ind_1)

    ifdealed(ind_1(j))==0

    dealed(ind_1(j))=1;

    ind=[indind_1(j)];

    class(ind_1(j))=number;

    end

    end

    end

    end

    number=number+1;

    end

    end

    end

    %最后处理所有未分类的点为噪音点

    ind_2=find(class==0);

    class(ind_2)=-1;

    types(ind_2)=-1;

    %%画出最终的聚类图

    holdon

    fori=1:m

    ifclass(i)==-1

    plot(data(i,1),data(i,2),’.r‘);

    elseifclass(i)==1

    iftypes(i)==1

    plot(data(i,1),data(i,2),’+b‘);

    else

    plot(data(i,1),data(i,2),’.b‘);

    end

    elseifclass(i)==2

    iftypes(i)==1

    plot(data(i,1),data(i,2),’+g‘);

    else

    plot(data(i,1),data(i,2),’.g‘);

    end

    elseifclass(i)==3

    iftypes(i)==1

    plot(data(i,1),data(i,2),’+c‘);

    else

    plot(data(i,1),data(i,2),’.c‘);

    end

    else

    iftypes(i)==1

    plot(data(i,1),data(i,2),’+k‘);

    else

    plot(data(i,1),data(i,2),’.k‘);

    end

    end

    end

    holdoff

    距离计算函数

    %%计算矩阵中点与点之间的距离

    function[dis]=calDistance(x)

    [m,n]=size(x);

    dis=zeros(m,m);

    fori=1:m

    forj=i:m

    %计算点i和点j之间的欧式距离

    tmp=0;

    fork=1:n

    tmp=tmp+(x(i,k)-x(j,k)).^2;

    end

    dis(i,j)=sqrt(tmp);

    dis(j,i)=dis(i,j);

    end

    end

    end

    epsilon函数

    function[Eps]=epsilon(x,k)

    %Function:[Eps]=epsilon(x,k)

    %

    %Aim:

    %AnalyticalwayofestimatingneighborhoodradiusforDBSCAN

    %

    %Input:

    %x-datamatrix(m,n);m-objects,n-variables

    %k-numberofobjectsinaneighborhoodofanobject

    %(minimalnumberofobjectsconsideredasacluster)

    [m,n]=size(x);

    Eps=((prod(max(x)-min(x))*k*gamma(.5*n+1))/(m*sqrt(pi.^n))).^(1/n);

    最终的结果

    43be520f14a49bce476679228b30c594.png

    (数据集1的聚类结果)

    0adfc2d6a02a927a6551b83b25d2c2b1.png

    (数据集2的聚类结果)

    在上面的结果中,红色的点代表的是噪音点,点代表的是边界点,十字代表的是核心点。不同的颜色代表着不同的类。

    展开全文
  • 点击上方,选择星标,每天给你送干货!来源:海豚数据科学实验室著作权归作者所有,本文仅作学术分享,若侵权,请联系后台删文处理聚类聚类分析是无监督学习问题。它通常被用作数据分析技术,用于发现...

    点击上方,选择星标,每天给你送干货!


    来源:海豚数据科学实验室

    著作权归作者所有,本文仅作学术分享,若侵权,请联系后台删文处理

    聚类或聚类分析是无监督学习问题。它通常被用作数据分析技术,用于发现数据中的有趣模式,例如基于其行为的客户群。有许多聚类算法可供选择,对于所有情况,没有单一的最佳聚类算法。相反,最好探索一系列聚类算法以及每种算法的不同配置。在本教程中,你将发现如何在 python 中安装和使用顶级聚类算法。

    完成本教程后,你将知道:

    • 聚类是在输入数据的特征空间中查找自然组的无监督问题。

    • 对于所有数据集,有许多不同的聚类算法和单一的最佳方法。

    • 在 scikit-learn 机器学习库的 Python 中如何实现、适配和使用顶级聚类算法。

    让我们开始吧。

    教程概述

    本教程分为三部分:

    1. 聚类

    2. 聚类算法

    3. 聚类算法示例

    • 库安装

    • 聚类数据集

    • 亲和力传播

    • 聚合聚类

    • BIRCH

    • DBSCAN

    • K-均值

    • Mini-Batch K-均值

    • Mean Shift

    • OPTICS

    • 光谱聚类

    • 高斯混合模型

    一.聚类

    聚类分析,即聚类,是一项无监督的机器学习任务。它包括自动发现数据中的自然分组。与监督学习(类似预测建模)不同,聚类算法只解释输入数据,并在特征空间中找到自然组或群集。

    聚类技术适用于没有要预测的类,而是将实例划分为自然组的情况。
    —源自:《数据挖掘页:实用机器学习工具和技术》2016年。

    群集通常是特征空间中的密度区域,其中来自域的示例(观测或数据行)比其他群集更接近群集。群集可以具有作为样本或点特征空间的中心(质心),并且可以具有边界或范围。

    这些群集可能反映出在从中绘制实例的域中工作的某种机制,这种机制使某些实例彼此具有比它们与其余实例更强的相似性。
    —源自:《数据挖掘页:实用机器学习工具和技术》2016年。

    聚类可以作为数据分析活动提供帮助,以便了解更多关于问题域的信息,即所谓的模式发现或知识发现。例如:

    • 该进化树可以被认为是人工聚类分析的结果;

    • 将正常数据与异常值或异常分开可能会被认为是聚类问题;

    • 根据自然行为将集群分开是一个集群问题,称为市场细分。

    聚类还可用作特征工程的类型,其中现有的和新的示例可被映射并标记为属于数据中所标识的群集之一。虽然确实存在许多特定于群集的定量措施,但是对所识别的群集的评估是主观的,并且可能需要领域专家。通常,聚类算法在人工合成数据集上与预先定义的群集进行学术比较,预计算法会发现这些群集。

    聚类是一种无监督学习技术,因此很难评估任何给定方法的输出质量。
    —源自:《机器学习页:概率观点》2012。


    二.聚类算法

    有许多类型的聚类算法。许多算法在特征空间中的示例之间使用相似度或距离度量,以发现密集的观测区域。因此,在使用聚类算法之前,扩展数据通常是良好的实践。

    聚类分析的所有目标的核心是被群集的各个对象之间的相似程度(或不同程度)的概念。聚类方法尝试根据提供给对象的相似性定义对对象进行分组。
    —源自:《统计学习的要素:数据挖掘、推理和预测》,2016年

    一些聚类算法要求您指定或猜测数据中要发现的群集的数量,而另一些算法要求指定观测之间的最小距离,其中示例可以被视为“关闭”或“连接”。因此,聚类分析是一个迭代过程,在该过程中,对所识别的群集的主观评估被反馈回算法配置的改变中,直到达到期望的或适当的结果。scikit-learn 库提供了一套不同的聚类算法供选择。下面列出了10种比较流行的算法:

    1. 亲和力传播

    2. 聚合聚类

    3. BIRCH

    4. DBSCAN

    5. K-均值

    6. Mini-Batch K-均值

    7. Mean Shift

    8. OPTICS

    9. 光谱聚类

    10. 高斯混合

    每个算法都提供了一种不同的方法来应对数据中发现自然组的挑战。没有最好的聚类算法,也没有简单的方法来找到最好的算法为您的数据没有使用控制实验。在本教程中,我们将回顾如何使用来自 scikit-learn 库的这10个流行的聚类算法中的每一个。这些示例将为您复制粘贴示例并在自己的数据上测试方法提供基础。我们不会深入研究算法如何工作的理论,也不会直接比较它们。让我们深入研究一下。

    三.聚类算法示例

    在本节中,我们将回顾如何在 scikit-learn 中使用10个流行的聚类算法。这包括一个拟合模型的例子和可视化结果的例子。这些示例用于将粘贴复制到您自己的项目中,并将方法应用于您自己的数据。

    1.库安装

    首先,让我们安装库。不要跳过此步骤,因为你需要确保安装了最新版本。你可以使用 pip Python 安装程序安装 scikit-learn 存储库,如下所示:

    sudo pip install scikit-learn
    

    接下来,让我们确认已经安装了库,并且您正在使用一个现代版本。运行以下脚本以输出库版本号。

    # 检查 scikit-learn 版本
    import sklearn
    print(sklearn.__version__)
    

    运行该示例时,您应该看到以下版本号或更高版本。

    0.22.1
    

    2.聚类数据集

    我们将使用 make _ classification ()函数创建一个测试二分类数据集。数据集将有1000个示例,每个类有两个输入要素和一个群集。这些群集在两个维度上是可见的,因此我们可以用散点图绘制数据,并通过指定的群集对图中的点进行颜色绘制。

    这将有助于了解,至少在测试问题上,群集的识别能力如何。该测试问题中的群集基于多变量高斯,并非所有聚类算法都能有效地识别这些类型的群集。因此,本教程中的结果不应用作比较一般方法的基础。下面列出了创建和汇总合成聚类数据集的示例。

    # 综合分类数据集
    from numpy import where
    from sklearn.datasets import make_classification
    from matplotlib import pyplot
    # 定义数据集
    X, y = make_classification(n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4)
    # 为每个类的样本创建散点图
    for class_value in range(2):
    # 获取此类的示例的行索引
    row_ix = where(y == class_value)
    # 创建这些样本的散布
    pyplot.scatter(X[row_ix, 0], X[row_ix, 1])
    # 绘制散点图
    pyplot.show()
    

    运行该示例将创建合成的聚类数据集,然后创建输入数据的散点图,其中点由类标签(理想化的群集)着色。我们可以清楚地看到两个不同的数据组在两个维度,并希望一个自动的聚类算法可以检测这些分组。

    已知聚类着色点的合成聚类数据集的散点图

    接下来,我们可以开始查看应用于此数据集的聚类算法的示例。我已经做了一些最小的尝试来调整每个方法到数据集。

    3.亲和力传播

    亲和力传播包括找到一组最能概括数据的范例。

    我们设计了一种名为“亲和传播”的方法,它作为两对数据点之间相似度的输入度量。在数据点之间交换实值消息,直到一组高质量的范例和相应的群集逐渐出现
    —源自:《通过在数据点之间传递消息》2007。

    它是通过 AffinityPropagation 类实现的,要调整的主要配置是将“ 阻尼 ”设置为0.5到1,甚至可能是“首选项”。

    下面列出了完整的示例。

    # 亲和力传播聚类
    from numpy import unique
    from numpy import where
    from sklearn.datasets import make_classification
    from sklearn.cluster import AffinityPropagation
    from matplotlib import pyplot
    # 定义数据集
    X, _ = make_classification(n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4)
    # 定义模型
    model = AffinityPropagation(damping=0.9)
    # 匹配模型
    model.fit(X)
    # 为每个示例分配一个集群
    yhat = model.predict(X)
    # 检索唯一群集
    clusters = unique(yhat)
    # 为每个群集的样本创建散点图
    for cluster in clusters:
    # 获取此群集的示例的行索引
    row_ix = where(yhat == cluster)
    # 创建这些样本的散布
    pyplot.scatter(X[row_ix, 0], X[row_ix, 1])
    # 绘制散点图
    pyplot.show()
    

    运行该示例符合训练数据集上的模型,并预测数据集中每个示例的群集。然后创建一个散点图,并由其指定的群集着色。在这种情况下,我无法取得良好的结果。

    数据集的散点图,具有使用亲和力传播识别的聚类

    4.聚合聚类

    聚合聚类涉及合并示例,直到达到所需的群集数量为止。它是层次聚类方法的更广泛类的一部分,通过 AgglomerationClustering 类实现的,主要配置是“ n _ clusters ”集,这是对数据中的群集数量的估计,例如2。下面列出了完整的示例。

    # 聚合聚类
    from numpy import unique
    from numpy import where
    from sklearn.datasets import make_classification
    from sklearn.cluster import AgglomerativeClustering
    from matplotlib import pyplot
    # 定义数据集
    X, _ = make_classification(n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4)
    # 定义模型
    model = AgglomerativeClustering(n_clusters=2)
    # 模型拟合与聚类预测
    yhat = model.fit_predict(X)
    # 检索唯一群集
    clusters = unique(yhat)
    # 为每个群集的样本创建散点图
    for cluster in clusters:
    # 获取此群集的示例的行索引
    row_ix = where(yhat == cluster)
    # 创建这些样本的散布
    pyplot.scatter(X[row_ix, 0], X[row_ix, 1])
    # 绘制散点图
    pyplot.show()
    

    运行该示例符合训练数据集上的模型,并预测数据集中每个示例的群集。然后创建一个散点图,并由其指定的群集着色。在这种情况下,可以找到一个合理的分组。

    使用聚集聚类识别出具有聚类的数据集的散点图

    5.BIRCH

    BIRCH 聚类( BIRCH 是平衡迭代减少的缩写,聚类使用层次结构)包括构造一个树状结构,从中提取聚类质心。

    BIRCH 递增地和动态地群集传入的多维度量数据点,以尝试利用可用资源(即可用内存和时间约束)产生最佳质量的聚类。
    —源自:《 BIRCH :1996年大型数据库的高效数据聚类方法》

    它是通过 Birch 类实现的,主要配置是“ threshold ”和“ n _ clusters ”超参数,后者提供了群集数量的估计。下面列出了完整的示例。

    # birch聚类
    from numpy import unique
    from numpy import where
    from sklearn.datasets import make_classification
    from sklearn.cluster import Birch
    from matplotlib import pyplot
    # 定义数据集
    X, _ = make_classification(n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4)
    # 定义模型
    model = Birch(threshold=0.01, n_clusters=2)
    # 适配模型
    model.fit(X)
    # 为每个示例分配一个集群
    yhat = model.predict(X)
    # 检索唯一群集
    clusters = unique(yhat)
    # 为每个群集的样本创建散点图
    for cluster in clusters:
    # 获取此群集的示例的行索引
    row_ix = where(yhat == cluster)
    # 创建这些样本的散布
    pyplot.scatter(X[row_ix, 0], X[row_ix, 1])
    # 绘制散点图
    pyplot.show()
    

    运行该示例符合训练数据集上的模型,并预测数据集中每个示例的群集。然后创建一个散点图,并由其指定的群集着色。在这种情况下,可以找到一个很好的分组。

    使用BIRCH聚类确定具有聚类的数据集的散点图

    6.DBSCAN

    DBSCAN 聚类(其中 DBSCAN 是基于密度的空间聚类的噪声应用程序)涉及在域中寻找高密度区域,并将其周围的特征空间区域扩展为群集。

    …我们提出了新的聚类算法 DBSCAN 依赖于基于密度的概念的集群设计,以发现任意形状的集群。DBSCAN 只需要一个输入参数,并支持用户为其确定适当的值
    -源自:《基于密度的噪声大空间数据库聚类发现算法》,1996

    它是通过 DBSCAN 类实现的,主要配置是“ eps ”和“ min _ samples ”超参数。

    下面列出了完整的示例。

    # dbscan 聚类
    from numpy import unique
    from numpy import where
    from sklearn.datasets import make_classification
    from sklearn.cluster import DBSCAN
    from matplotlib import pyplot
    # 定义数据集
    X, _ = make_classification(n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4)
    # 定义模型
    model = DBSCAN(eps=0.30, min_samples=9)
    # 模型拟合与聚类预测
    yhat = model.fit_predict(X)
    # 检索唯一群集
    clusters = unique(yhat)
    # 为每个群集的样本创建散点图
    for cluster in clusters:
    # 获取此群集的示例的行索引
    row_ix = where(yhat == cluster)
    # 创建这些样本的散布
    pyplot.scatter(X[row_ix, 0], X[row_ix, 1])
    # 绘制散点图
    pyplot.show()
    

    运行该示例符合训练数据集上的模型,并预测数据集中每个示例的群集。然后创建一个散点图,并由其指定的群集着色。在这种情况下,尽管需要更多的调整,但是找到了合理的分组。

    使用DBSCAN集群识别出具有集群的数据集的散点图

    7.K均值

    K-均值聚类可以是最常见的聚类算法,并涉及向群集分配示例,以尽量减少每个群集内的方差。

    本文的主要目的是描述一种基于样本将 N 维种群划分为 k 个集合的过程。这个叫做“ K-均值”的过程似乎给出了在类内方差意义上相当有效的分区。
    -源自:《关于多元观测的分类和分析的一些方法》1967年。

    它是通过 K-均值类实现的,要优化的主要配置是“ n _ clusters ”超参数设置为数据中估计的群集数量。下面列出了完整的示例。

    # k-means 聚类
    from numpy import unique
    from numpy import where
    from sklearn.datasets import make_classification
    from sklearn.cluster import KMeans
    from matplotlib import pyplot
    # 定义数据集
    X, _ = make_classification(n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4)
    # 定义模型
    model = KMeans(n_clusters=2)
    # 模型拟合
    model.fit(X)
    # 为每个示例分配一个集群
    yhat = model.predict(X)
    # 检索唯一群集
    clusters = unique(yhat)
    # 为每个群集的样本创建散点图
    for cluster in clusters:
    # 获取此群集的示例的行索引
    row_ix = where(yhat == cluster)
    # 创建这些样本的散布
    pyplot.scatter(X[row_ix, 0], X[row_ix, 1])
    # 绘制散点图
    pyplot.show()
    

    运行该示例符合训练数据集上的模型,并预测数据集中每个示例的群集。然后创建一个散点图,并由其指定的群集着色。在这种情况下,可以找到一个合理的分组,尽管每个维度中的不等等方差使得该方法不太适合该数据集。

    使用K均值聚类识别出具有聚类的数据集的散点图

    8.Mini-Batch K-均值

    Mini-Batch K-均值是 K-均值的修改版本,它使用小批量的样本而不是整个数据集对群集质心进行更新,这可以使大数据集的更新速度更快,并且可能对统计噪声更健壮。

    ...我们建议使用 k-均值聚类的迷你批量优化。与经典批处理算法相比,这降低了计算成本的数量级,同时提供了比在线随机梯度下降更好的解决方案。
    —源自:《Web-Scale K-均值聚类》2010

    它是通过 MiniBatchKMeans 类实现的,要优化的主配置是“ n _ clusters ”超参数,设置为数据中估计的群集数量。下面列出了完整的示例。

    # mini-batch k均值聚类
    from numpy import unique
    from numpy import where
    from sklearn.datasets import make_classification
    from sklearn.cluster import MiniBatchKMeans
    from matplotlib import pyplot
    # 定义数据集
    X, _ = make_classification(n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4)
    # 定义模型
    model = MiniBatchKMeans(n_clusters=2)
    # 模型拟合
    model.fit(X)
    # 为每个示例分配一个集群
    yhat = model.predict(X)
    # 检索唯一群集
    clusters = unique(yhat)
    # 为每个群集的样本创建散点图
    for cluster in clusters:
    # 获取此群集的示例的行索引
    row_ix = where(yhat == cluster)
    # 创建这些样本的散布
    pyplot.scatter(X[row_ix, 0], X[row_ix, 1])
    # 绘制散点图
    pyplot.show()
    

    运行该示例符合训练数据集上的模型,并预测数据集中每个示例的群集。然后创建一个散点图,并由其指定的群集着色。在这种情况下,会找到与标准 K-均值算法相当的结果。

    带有最小批次K均值聚类的聚类数据集的散点图

    9.均值漂移聚类

    均值漂移聚类涉及到根据特征空间中的实例密度来寻找和调整质心。

    对离散数据证明了递推平均移位程序收敛到最接近驻点的基础密度函数,从而证明了它在检测密度模式中的应用。
    —源自:《Mean Shift :面向特征空间分析的稳健方法》,2002

    它是通过 MeanShift 类实现的,主要配置是“带宽”超参数。下面列出了完整的示例。

    # 均值漂移聚类
    from numpy import unique
    from numpy import where
    from sklearn.datasets import make_classification
    from sklearn.cluster import MeanShift
    from matplotlib import pyplot
    # 定义数据集
    X, _ = make_classification(n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4)
    # 定义模型
    model = MeanShift()
    # 模型拟合与聚类预测
    yhat = model.fit_predict(X)
    # 检索唯一群集
    clusters = unique(yhat)
    # 为每个群集的样本创建散点图
    for cluster in clusters:
    # 获取此群集的示例的行索引
    row_ix = where(yhat == cluster)
    # 创建这些样本的散布
    pyplot.scatter(X[row_ix, 0], X[row_ix, 1])
    # 绘制散点图
    pyplot.show()
    

    运行该示例符合训练数据集上的模型,并预测数据集中每个示例的群集。然后创建一个散点图,并由其指定的群集着色。在这种情况下,可以在数据中找到一组合理的群集。

    具有均值漂移聚类的聚类数据集散点图

    10.OPTICS

    OPTICS 聚类( OPTICS 短于订购点数以标识聚类结构)是上述 DBSCAN 的修改版本。

    我们为聚类分析引入了一种新的算法,它不会显式地生成一个数据集的聚类;而是创建表示其基于密度的聚类结构的数据库的增强排序。此群集排序包含相当于密度聚类的信息,该信息对应于范围广泛的参数设置。
    —源自:《OPTICS :排序点以标识聚类结构》,1999

    它是通过 OPTICS 类实现的,主要配置是“ eps ”和“ min _ samples ”超参数。下面列出了完整的示例。

    # optics聚类
    from numpy import unique
    from numpy import where
    from sklearn.datasets import make_classification
    from sklearn.cluster import OPTICS
    from matplotlib import pyplot
    # 定义数据集
    X, _ = make_classification(n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4)
    # 定义模型
    model = OPTICS(eps=0.8, min_samples=10)
    # 模型拟合与聚类预测
    yhat = model.fit_predict(X)
    # 检索唯一群集
    clusters = unique(yhat)
    # 为每个群集的样本创建散点图
    for cluster in clusters:
    # 获取此群集的示例的行索引
    row_ix = where(yhat == cluster)
    # 创建这些样本的散布
    pyplot.scatter(X[row_ix, 0], X[row_ix, 1])
    # 绘制散点图
    pyplot.show()
    

    运行该示例符合训练数据集上的模型,并预测数据集中每个示例的群集。然后创建一个散点图,并由其指定的群集着色。在这种情况下,我无法在此数据集上获得合理的结果。

    使用OPTICS聚类确定具有聚类的数据集的散点图

    11.光谱聚类

    光谱聚类是一类通用的聚类方法,取自线性线性代数。

    最近在许多领域出现的一个有希望的替代方案是使用聚类的光谱方法。这里,使用从点之间的距离导出的矩阵的顶部特征向量。
    —源自:《关于光谱聚类:分析和算法》,2002年

    它是通过 Spectral 聚类类实现的,而主要的 Spectral 聚类是一个由聚类方法组成的通用类,取自线性线性代数。要优化的是“ n _ clusters ”超参数,用于指定数据中的估计群集数量。下面列出了完整的示例。

    # spectral clustering
    from numpy import unique
    from numpy import where
    from sklearn.datasets import make_classification
    from sklearn.cluster import SpectralClustering
    from matplotlib import pyplot
    # 定义数据集
    X, _ = make_classification(n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4)
    # 定义模型
    model = SpectralClustering(n_clusters=2)
    # 模型拟合与聚类预测
    yhat = model.fit_predict(X)
    # 检索唯一群集
    clusters = unique(yhat)
    # 为每个群集的样本创建散点图
    for cluster in clusters:
    # 获取此群集的示例的行索引
    row_ix = where(yhat == cluster)
    # 创建这些样本的散布
    pyplot.scatter(X[row_ix, 0], X[row_ix, 1])
    # 绘制散点图
    pyplot.show()
    

    运行该示例符合训练数据集上的模型,并预测数据集中每个示例的群集。然后创建一个散点图,并由其指定的群集着色。

    在这种情况下,找到了合理的集群。

    使用光谱聚类聚类识别出具有聚类的数据集的散点图

    12.高斯混合模型

    高斯混合模型总结了一个多变量概率密度函数,顾名思义就是混合了高斯概率分布。它是通过 Gaussian Mixture 类实现的,要优化的主要配置是“ n _ clusters ”超参数,用于指定数据中估计的群集数量。下面列出了完整的示例。

    # 高斯混合模型
    from numpy import unique
    from numpy import where
    from sklearn.datasets import make_classification
    from sklearn.mixture import GaussianMixture
    from matplotlib import pyplot
    # 定义数据集
    X, _ = make_classification(n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4)
    # 定义模型
    model = GaussianMixture(n_components=2)
    # 模型拟合
    model.fit(X)
    # 为每个示例分配一个集群
    yhat = model.predict(X)
    # 检索唯一群集
    clusters = unique(yhat)
    # 为每个群集的样本创建散点图
    for cluster in clusters:
    # 获取此群集的示例的行索引
    row_ix = where(yhat == cluster)
    # 创建这些样本的散布
    pyplot.scatter(X[row_ix, 0], X[row_ix, 1])
    # 绘制散点图
    pyplot.show()
    

    运行该示例符合训练数据集上的模型,并预测数据集中每个示例的群集。然后创建一个散点图,并由其指定的群集着色。在这种情况下,我们可以看到群集被完美地识别。这并不奇怪,因为数据集是作为 Gaussian 的混合生成的。

    使用高斯混合聚类识别出具有聚类的数据集的散点图

    说个正事哈

    由于微信平台算法改版,公号内容将不再以时间排序展示,如果大家想第一时间看到我们的推送,强烈建议星标我们和给我们多点点【在看】。星标具体步骤为:

    (1)点击页面最上方深度学习自然语言处理”,进入公众号主页。

    (2)点击右上角的小点点,在弹出页面点击“设为星标”,就可以啦。

    感谢支持,比心

    投稿或交流学习,备注:昵称-学校(公司)-方向,进入DL&NLP交流群。

    方向有很多:机器学习、深度学习,python,情感分析、意见挖掘、句法分析、机器翻译、人机对话、知识图谱、语音识别等。

    记得备注呦

    整理不易,还望给个在看!
    
    展开全文
  • 点击上方“小白学视觉”,选择加"星标"或“置顶”重磅干货,第一时间送达 本文转自:磐创AI1. 典型聚类算法1.1 基于划分的方法代表:kmeans算法·指定k个聚类中心...

    点击上方“小白学视觉”,选择加"星标"或“置顶

    重磅干货,第一时间送达
    
    

    本文转自:磐创AI

    1. 典型聚类算法

    1.1 基于划分的方法

    代表:kmeans算法

    ·指定k个聚类中心
    ·(计算数据点与初始聚类中心的距离)
    ·(对于数据点,找到最近的{i}ci(聚类中心),将分配到{i}ci中)
    ·(更新聚类中心点,是新类别数值的均值点)
    ·(计算每一类的偏差)
    ·返回
    返回第二步

    1.2 基于层次的方法

    代表:CURE算法

    ·每个样本作为单独的一个类别
    ·
    ·合并,
    ·遍历完本次样本,合并成新的类别后,若存在多个类别,则返回第二步
    ·遍历完本次样本,合并成新的类别后,若所有样本为同一类别,跳出循环,输出每层类别

    1.3 基于网格的方法

    代表:STING算法

    ·将数据集合X划分多层网格结构,从某一层开始计算
    ·查询该层网格间的属性值,计算属性值与阈值的关系,判定网格间的相关情况,不相关的网格不作考虑
    ·如果网格相关,则进入下一层的相关区域继续第二步,直到下一层为最底层
    ·返回相关网格结果

    1.4 基于密度的方法

    代表:DBSCAN算法

    ·输入数据集合X,随机选取一点,并找出这个点的所有高密度可达点
    ·遍历此点的所有邻域内的点,并寻找这些密度可达点,判定某点邻域内的点,并寻找这些点密度可达点,判定某点的邻域内的点数是否超过阈值点数,超过则构成核心点
    ·扫描数据集,寻找没有被聚类的数据点,重复第二步
    ·输出划分的类,并输出异常值点(不和其他密度相连)

    1.5 神经网络的方法

    代表:SOM算法

    ·数据集合,权重向量为,归一化处理
    ·寻找获胜的神经元,找到最小距离,对于每一个输入数据,找到与之最相匹配的节点
    的距离,更新权重:
    ·更新临近节点,,其中代表学习率

    1.6 基于图的聚类方法

    代表:谱聚类算法

    ·计算邻接矩阵,度矩阵
    ·计算拉普拉及矩阵
    ·计算归一化拉普拉斯矩阵
    ·计算的特征值和特征向量
    ·对Q矩阵进行聚类,得到聚类结果

    2. 聚类算法的评价指标

    一个好的聚类方法可以产生高品质簇,是的簇内相似度高,簇间相似度低。一般来说,评估聚类质量有两个标准,内部质量评价指标和外部评价指标。

    2.1 内部质量评价标准

    内部评价指标是利用数据集的属性特征来评价聚类算法的优劣。通过计算总体的相似度,簇间平均相似度或簇内平均相似度来评价聚类质量。评价聚类效果的高低通常使用聚类的有效性指标,所以目前的检验聚类的有效性指标主要是通过簇间距离和簇内距离来衡量。这类指标常用的有CH(Calinski-Harabasz)指标等

    CH指标

    CH指标定义为:

    其中表示类间距离差矩阵的迹,表示类内离差矩阵的迹,是整个数据集的均值,是第个簇的均值,代表聚类个数,代表当前的类。值越大,聚类效果越好,主要计算簇间距离与簇内距离的比值

    簇的凝聚度

    簇内点对的平均距离反映了簇的凝聚度,一般使用组内误差平方(SSE)表示:

    簇的邻近度

    簇的邻近度用组间平方和(SSB)表示,即簇的质心到簇内所有数据点的总平均值的距离的平方和

    2.2 外部质量评价标准

    外部质量评价指标是基于已知分类标签数据集进行评价的,这样可以将原有标签数据与聚类输出结果进行对比。外部质量评价指标的理想聚类结果是:具有不同类标签的数据聚合到不同的簇中,具有相同类标签的数据聚合相同的簇中。外部质量评价准则通常使用熵,纯度等指标进行度量。

    熵:

    簇内包含单个类对象的一种度量。对于每一个簇,首先计算数据的类分布,即对于簇,计算簇的成员属于类的概率

    其中表示簇中所有对象的个数,而是簇中类的对象个数。使用类分布,用标准公式:

    计算每个簇的熵,其中K是类个数。簇集合的总熵用每个簇的熵的加权和计算即:

    其中是簇的个数,而是簇内数据点的总和

    纯度:

    簇内包含单个类对象的另外一种度量。簇的纯度为,而聚类总纯度为:

    下载1:OpenCV-Contrib扩展模块中文版教程

    在「小白学视觉」公众号后台回复:扩展模块中文教程即可下载全网第一份OpenCV扩展模块教程中文版,涵盖扩展模块安装、SFM算法、立体视觉、目标跟踪、生物视觉、超分辨率处理等二十多章内容。

    下载2:Python视觉实战项目52讲

    在「小白学视觉」公众号后台回复:Python视觉实战项目即可下载包括图像分割、口罩检测、车道线检测、车辆计数、添加眼线、车牌识别、字符识别、情绪检测、文本内容提取、面部识别等31个视觉实战项目,助力快速学校计算机视觉。

    下载3:OpenCV实战项目20讲

    在「小白学视觉」公众号后台回复:OpenCV实战项目20讲即可下载含有20个基于OpenCV实现20个实战项目,实现OpenCV学习进阶。

    交流群

    欢迎加入公众号读者群一起和同行交流,目前有SLAM、三维视觉、传感器、自动驾驶、计算摄影、检测、分割、识别、医学影像、GAN、算法竞赛等微信群(以后会逐渐细分),请扫描下面微信号加群,备注:”昵称+学校/公司+研究方向“,例如:”张三 + 上海交大 + 视觉SLAM“。请按照格式备注,否则不予通过。添加成功后会根据研究方向邀请进入相关微信群。请勿在群内发送广告,否则会请出群,谢谢理解~

    展开全文
  • 一、数据集和模型文件准备 1.1 数据集下载 使用kaggle猫狗大战的test中的前100张图像作为数据集1:dogs-vs-cats 使用100张红外船舶图像作为数据集2: 1.2 模型文件下载(可忽略) 通过使用更大、更复杂的模型,可以...

    一、数据集和模型文件准备

    1.1 数据集下载

    使用kaggle猫狗大战的test中的前100张图像作为数据集1:dogs-vs-cats

    使用100张红外船舶图像作为数据集2:

    1.2 模型文件下载(可忽略)

    通过使用更大、更复杂的模型,可以获得更高的准确率,预训练模型是一个很好的选择,我们可以直接使用预训练模型来完成分类任务,因为预训练模型通常已经在大型的数据集上进行过训练,通常用于完成大型的图像分类任务。

    tf.keras.applications中有一些预定义好的经典卷积神经网络结构(Application应用):

    我们可以直接调用这些经典的卷积神经网络结构(甚至载入预训练的参数),而无需手动来构建网络结构。

    例如,本文将要用到的模型是由谷歌开发的 MobileNetV2 网络结构,该模型已经在 ImageNet 数据集上进行过预训练,共含有 1.4M 张图像,而且学习了常见的 1000 种物体的基本特征,因此,该模型具有强大的特征提取能力。

    model = tf.keras.applications.MobileNetV2()
    

    当执行以上代码时,TensorFlow会自动从网络上下载 MobileNetV2 网络结构,运行代码后需要等待一会会儿~~。MobileNetV2模型的速度很快,而且耗费资源也不是很多。

    二、K-means聚类实现数据集的聚类

    2.1 K-means的原理和算法

    详细原理:【机器学习】K-means(非常详细)
    定义
    聚类是一个将数据集中在某些方面相似的数据成员进行分类组织的过程,聚类就是一种发现这种内在结构的技术,聚类技术经常被称为无监督学习。

    k均值聚类是最著名的划分聚类算法,由于简洁和效率使得他成为所有聚类算法中最广泛使用的。给定一个数据点集合和需要的聚类数目k,k由用户指定,k均值算法根据某个距离函数反复把数据分入k个聚类中。

    算法
    先随机选取K个对象作为初始的聚类中心。然后计算每个对象与各个种子聚类中心之间的距离,把每个对象分配给距离它最近的聚类中心。聚类中心以及分配给它们的对象就代表一个聚类。一旦全部对象都被分配了,每个聚类的聚类中心会根据聚类中现有的对象被重新计算。这个过程将不断重复直到满足某个终止条件。终止条件可以是以下任何一个:

    • 没有(或最小数目)对象被重新分配给不同的聚类。
    • 没有(或最小数目)聚类中心再发生变化。
    • 误差平方和局部最小。

    2.2 K-means中K值的最合适取值

    学习总结:K-Means算法之K值的选择

    2.2.1 肘部法

    2.2.1.1 手肘法的核心思想
    随着聚类数 k k k的增大,样本划分会更加精细,每个簇的聚合程度会逐渐提高,那么误差平方和SSE自然会逐渐变小。并且,当k小于最佳聚类数时,由于k的增大会大幅增加每个簇的聚合程度,故SSE的下降幅度会很大;而当k到达最佳聚类数时,再增加k所得到的聚合程度回报会迅速变小,所以SSE的下降幅度会骤减;然后随着k值的继续增大而趋于平缓,也就是说SSE和k的关系图是一个手肘的形状,而这个肘部对应的k值就是数据的最佳聚类数。这也是该方法被称为手肘法的原因。

    由下图,y轴为SSE(Sum of the Squared Errors-误差平方和),x轴为k的取值。随着x的增加,SSE会随之降低,当下降幅度明显趋向于缓慢的时候,取该值为K的值。

    1. 对于n个点的数据集,迭代计算k from 1 to n,每次聚类完成后计算每个点到其所属的簇中心的距离的平方和;
    2. 平方和是会逐渐变小的,直到k时平方和为0,因为每个点都是它所在的簇中心本身。
    3. 在这个平方和变化过程中,会出现一个拐点也即“肘”点,下降率突然变缓时即认为是佳的k值。

    2.2.1.2 SSE
    手肘法的评价K值好坏的标准是SSE。
    S S E = ∑ p ∈ C i ∣ p − m i ∣ 2 SSE=\sum_{p∈C_i}|p-m_i|^2 SSE=pCipmi2
    其中 C i C_i Ci代表第 i i i个簇, p p p是簇 C i C_i Ci里的样本点, m i m_i mi是簇的质心。

    2.2.1.3 应用

    from sklearn.datasets import make_blobs
    from sklearn.cluster import KMeans
    from sklearn.metrics import silhouette_score
    import matplotlib.pyplot as plt
    # 生成数据
    X, y = make_blobs(n_samples=300, centers=5, n_features=5, random_state=0)
    
    start_k=2
    end_k=20
    SSE = []
    model = [] #保存每次的模型
    kt=[]
    for i in range(start_k, end_k):
        kMeans = KMeans(n_clusters=i)
        kMeans.fit(X)
        SSE.append(kMeans.inertia_)  # 保存每一个k值的SSE值
        print('{} Means SSE loss = {}'.format(i, kMeans.inertia_))
        model.append(kMeans)
        kt.append(i)
    plt.plot(kt, SSE)
    plt.ylabel('Means SSE loss')
    plt.ylabel('SSE ')
    plt.show()
    
    
    # 求二阶导数,通过sse方法计算最佳k值
    kl=[]
    SSE_d1 = [] #sse的一阶导数
    SSE_d2 = [] #sse的二阶导数
    SSE_length = len(SSE)
    for i in range(1, SSE_length):
        SSE_d1.append((SSE[i - 1] - SSE[i]) / 2)
    for i in range(1, len(SSE_d1) - 1):
        SSE_d2.append((SSE_d1[i - 1] - SSE_d1[i]) / 2)
        kl.append(i)
    best_model = model[SSE_d2.index(max(SSE_d2)) + 2]
    print(best_model)
    

    2.2.2 轮廓法

    2.2.2.1 概述

    通过聚类后的结果label来计算的一种评价指标。内部有效性指标呢设计的时候从三个方面来看聚类的有效性:

    • 度量各个聚类的分离程度,理论上,类分离程度越大,结果越好。
    • 度量每个类内的内在紧致性,紧致性越大,聚类效果越好。
    • 度量各个类表示的复杂度,在可行的类表示中选择简单的。

    在聚类问题中,Silhouette分析用来研究聚类结果的类间距离。Silhouette数值度量在相同类中的点,与不同类中的点相比的紧密程度。Silhouette图可视化这一测度,这样就提供了一种评价类个数的方法。使用Silhouette分析选择一个类个数参数n_clusters的最优值。

    Silhouette 遵循类紧致性。Silhouette值用来描述一个目标对于目标所在簇与其他簇之间的相似性。其范围是从-1~+1,这个值越大表明目标与自己所在簇之间的匹配关系度越高,与其他簇的匹配关系度越低。如果这个值越高,那么聚类结果越好,如果是很小或是负值,那么可能是分簇太多或是太少造成的。Silhouette是通过一些距离矩阵来计算的。

    2.2.2.2 Silhouette的定义

    • 簇内不相似度
      假设数据集我们已经通过聚类算法分成了很多类。对于目标 i i i i ∈ C i i∈C_i iCi得到:
      a ( i ) = 1 ∣ C i − 1 ∣ ∑ j ∈ C i , i ≠ j d ( i , j ) a(i)=\cfrac{1}{|C_i-1|}\displaystyle\sum_{j∈C_i,i≠j}{d(i,j)} a(i)=Ci11jCii=jd(i,j)
      表示i与同簇之间其他目标的平均距离。
      这里的 d ( i , j ) d(i,j) d(i,j)是目标 i i i j j j在簇 C i C_i Ci 中的距离。那么 a ( i ) a(i) a(i)可以说成是 i i i被分配到这个簇的好坏程度。

    • 簇间不相似度
      对于目标 i i i i ∈ C i i∈C_i iCi, C k C_k Ck表示第 k k k个簇:
      b ( i ) = min ⁡ k ≠ i 1 ∣ C k ∣ ∑ j ∈ C k d ( i , j ) b(i)=\min_{k≠i}\cfrac{1}{|C_k|}\sum_{j∈C_k}{d(i,j)} b(i)=k=iminCk1jCkd(i,j)
      表示 i i i到除 C i C_i Ci 簇外其他簇 C k C_k Ck中的点之间的平均距离作为簇之间的平均不相似度。我们用 i i i到其它簇的最小平均距离表示 b ( i ) b(i) b(i)

    • Silhouette值
      根据样本i的簇内不相似度 a ( i ) a(i) a(i)和簇间不相似度 b ( i ) b(i) b(i) ,定义样本 i i i的轮廓系数:
      s ( i ) = { b ( i ) − a ( i ) m a x ( a ( i ) , b ( i ) ) , if  ∣ C i ∣ > 1 0 if  ∣ C i ∣ = 1 s(i)=\begin{cases} \cfrac{b(i)-a(i)}{max(a(i),b(i))}, &\text{if } |C_i|>1 \\ 0 &\text{if } |C_i|=1 \end{cases} s(i)=max(a(i),b(i))b(i)a(i)0if Ci>1if Ci=1
      同时也可以写成:
      s ( i ) = { 1 − a ( i ) b ( i ) , if  a ( i ) < b ( i ) 0 , if  a ( i ) = b ( i ) b ( i ) a ( i ) − 1 , if  a ( i ) > b ( i ) s(i)=\begin{cases} 1-\cfrac{a(i)}{b(i)}, &\text{if } a(i)<b(i) \\ 0 ,&\text{if } a(i)=b(i) \\ \cfrac{b(i)}{a(i)}-1,&\text{if } a(i)>b(i) \end{cases} s(i)=1b(i)a(i)0a(i)b(i)1if a(i)<b(i)if a(i)=b(i)if a(i)>b(i)

    • 轮廓系数范围在[-1,1]之间。该值越大,越合理。
    • s ( i ) s(i) s(i)接近1,则说明样本i聚类合理。对于簇中值 i i i来说 a ( i ) a(i) a(i)越小,那么 i i i被分配到这个簇是很合理的;
    • si接近-1,则说明样本i更应该分类到另外的簇;
    • 若si 近似为0,则说明样本i在两个簇的边界上。

    2.2.2.3 Silhouette coefficient
    所有样本的 s ( i ) s(i) s(i)的均值称为聚类结果的轮廓系数,是该聚类是否合理、有效的度量。silhouette coefficient表示在整个数据集上s(i)的均值的最大值。可得到:
    S C = max ⁡ k s ˉ ( k ) SC=\max_{k}{\bar{s}(k)} SC=kmaxsˉ(k)
    在sklearn包中已经有用python实现的轮廓系数值的计算。

    from sklearn.datasets import make_blobs
    from sklearn.cluster import KMeans
    from sklearn.metrics import silhouette_score
    import matplotlib.pyplot as plt
    
    # 生成数据
    X, y = make_blobs(n_samples=300, centers=5, n_features=5, random_state=0)
    
    # 寻找最合适的K值
    sil = []
    kl = []
    beginK = 3
    endK = 8
    for k in range(beginK, endK):
        kMeans = KMeans(n_clusters=k)
        kMeans.fit(X)  # 聚类
        SC = silhouette_score(X, kMeans.labels_, metric='euclidean')
        sil.append(SC)
        kl.append(k)
    plt.plot(kl, sil)
    plt.ylabel('Silhoutte Score')
    plt.ylabel('K')
    plt.show()
    
    # k-means聚类
    bestK = kl[sil.index(max(sil))]
    km = KMeans(n_clusters=bestK)
    km.fit(X)
    y_predict = km.predict(X)
    # 评估聚类效果
    print(silhouette_score(X, y_predict))
    # 绘制聚类结果图
    color = ["red", "green", "blue", "gray", "yellow"]
    colors = [color[i] for i in y_predict]
    plt.figure()
    plt.scatter(X[:, 1], X[:, 2], color=colors)
    plt.show()
    

    从图可见,当k值为5时最合适。

    关于函数的讲解和具体应用实例官方文档:sklearn.metrics.silhouette_score

    2.3 K-means在图像聚类上的应用

    2.3.1 对猫狗进行聚类

    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.cluster import KMeans
    from sklearn.metrics import silhouette_score
    import cv2
    import os, glob, shutil
    
    
    # 1.获取所有图像
    input_dir = 'datasetsCatDog'
    glob_dir = input_dir + '/*.jpg'
    #opencv读取图像,并将图像大小 resize 为(224,224),以匹配模型输入层的大小以进行特征提取。
    images = [cv2.resize(cv2.imread(file), (224, 224)) for file in glob.glob(glob_dir)]
    paths = [file for file in glob.glob(glob_dir)]
    # 图像数组转换为 float32 类型并reshape,然后做归一化。
    images = np.array(np.float32(images).reshape(len(images), -1) / 255)
    #绘制数据分布图
    plt.scatter(images[:, 0], images[:, 1], c = "red", marker='o', label='origin')
    plt.xlabel('length')
    plt.ylabel('width')
    plt.legend(loc=2)
    plt.show()
    
    
    
    # 2.加载预先训练的模型MobileNetV2来实现图像分类
    model = tf.keras.applications.MobileNetV2(include_top=False, weights='imagenet', input_shape=(224, 224, 3)) #'imagenet' (pre-training on ImageNet),
    predictions = model.predict(images.reshape(-1, 224, 224, 3))
    pred_images = predictions.reshape(images.shape[0], -1)
    
    # 3. 使用轮廓法寻找K值
    sil = []
    kl = []
    kmax = 4 #设置最大的K值
    for k in range(2, kmax + 1):
        kMeans = KMeans(n_clusters=k).fit(pred_images)#构造聚类器 聚类
        labels = kMeans.labels_ #获取聚类标签
        sil.append(silhouette_score(pred_images, labels, metric='euclidean')) # 计算所有样本的平均剪影系数。
        kl.append(k)
    
    bestK = kl[sil.index(max(sil))]
    print(bestK)
    plt.plot(kl, sil)
    plt.ylabel('Silhoutte Score')
    plt.ylabel('K')
    plt.show()
    
    # 4. 使用最合适的K值进行聚类
    k = bestK
    kMeansModel = KMeans(n_clusters=k,  random_state=888)#构造聚类器
    kMeansModel.fit(pred_images)#聚类
    label_pred = kMeansModel.labels_  # 获取聚类标签
    kPredictions = kMeansModel.predict(pred_images)
    print(kPredictions)
    #绘制 k-means结果
    for j in range(0,k):
        imagesRes = images[label_pred == j]
        plt.scatter(imagesRes[:, 0], imagesRes[:, 1],  label=('label'+str(j)))
        plt.xlabel(' length')
        plt.ylabel(' width')
        plt.legend(loc=2)
    plt.show()
    
    
    
    # 5. 保存图像到不同类别的文件夹
    for i in range(1,k+1):
        name="datasetsCatDog/class" + str(i)
        if os.path.isdir(name):
            #os.rmdir(name)# 删除目录 如果该目录非空则不能删除
            shutil.rmtree(name)# 删除目录 如果该目录非空也能删除
        os.mkdir("datasetsCatDog/class" + str(i))
    for i in range(len(paths)):
        for j in range(0,k):
            if kPredictions[i] == j:
                shutil.copy(paths[i], "datasetsCatDog/class"+str(j+1))
    
    

    在这里插入图片描述

    三、问题

    AttributeError: ‘str’ object has no attribute ‘decode’
    卸载原来的h5py模块,安装2.10版本:
    pip install h5py==2.10 -i https://pypi.tuna.tsinghua.edu.cn/simple/

    参考:Tensorflow2.0和keras版本兼容问题

    展开全文
  • sklearn聚类算法实现

    2021-07-20 15:28:55
    sklearn聚类算法实现 主要通过调用python中sklearn库中的函数来实现聚类算法,主要包括:K-MEANS、近邻传播(AffinityPropagation)、均值偏移(MeanShift)...1、生成数据集 通过sklearn中的make_blobs函数主要来生成
  • 一、 K-Means 聚类算法流程、 二、 一维数据的 K-Means 聚类、 1、 第一次迭代、 2、 第二次迭代、 3、 第三次迭代、 4、 第四次迭代
  • 聚类算法总结

    千次阅读 2020-12-27 02:28:20
    文章目录聚类算法聚类算法简介认识聚类算法聚类算法的概念聚类算法与分类算法最大的区别聚类算法api初步使用api介绍案例聚类算法实现流程k-means聚类步骤案例练习小结模型评估误差平方和(SSE \The sum of squares ...
  • 机器学习中常用的聚类数据集生成方法

    千次阅读 多人点赞 2021-05-26 11:51:40
    毕业季又到了,论文里涉及到一些机器学习算法,就想用一些数据样本来对算法的性能做一些可视化,苦于自制数据集的困难,所以本篇就介绍一下scikit-learn自带的一些函数库来生成数据。
  • sklearn实战之聚类算法

    2021-08-25 10:00:20
    六、聚类算法 0、概述 0.1 无监督学习与聚类算法 在之前的五篇文章中,我们学习了决策树,逻辑回归,随机森林,它们虽然有着不同...聚类算法又叫做”无监督分类“,其目的是将数据划分为有意义的或有用的组(或簇)。这
  • 怎样用matlab实现多维K-means聚类算法小编觉得一个好的周末应该是这样的:睡到中午醒来,在床上躺着玩两个小时手机,起床随便吃点东西,下午去超市买一大堆零食,五六点的时候去约小伙伴们吃火锅烧烤,如果是一个人...
  • 常见聚类算法汇总

    2021-07-12 18:01:45
    二、聚类算法的评判标准 1.性能度量 外部指标 内部指标 三、距离计算 1.闵可夫斯基距离 2.欧氏距离 3.曼哈顿距离 3.VDM距离 四、聚类算法 1.原型聚类 a)K均值算法(k-means) b)学习向量化(LVQ) c)KNN算法 2.密度...
  • 密度峰值聚类算法(DPC)

    千次阅读 2021-11-22 15:35:19
    通过学习密度峰值聚类算法(DPC),掌握算法的原理及其优缺点,对改进方法的论文进行总结,最后给出了MATLAB代码实现该算法。
  • 一.K-means均值聚类算法原理 对于给定的样本,按照样本之间的距离大小,将样本划分为K个簇。让簇内的点尽量紧密的连在一起,而让簇间的距离尽量的大。 如果用数据表达式表示,假设簇划分为(C1,C2,…Ck),则我们...
  • clear all;...%% 模糊C均值聚类参数% 设置幂指数为3,最大迭代次数为20,目标函数的终止容限为1e-6options=[3,20,1e-6];% 类别数cncn=4;%% 模拟退火算法参数q =0.8; % 冷却系数T0=100; % 初始温度Tend...
  •  1)对于K-Means算法,首先要注意的是k值的选择,一般来说,我们会根据对数据的先验经验选择一个合适的k值,如果没有什么先验知识,则可以通过交叉验证选择一个合适的k值。  2)在确定了k的个数后,我们需要选择k...
  • 聚类算法实现流程

    2021-04-16 20:14:18
    聚类算法实现流程 k-means其实包含两层内容: ​ K : 初始中心点个数(计划聚类数) ​ means:求中心点到其他数据点距离的平均值 1 k-means聚类步骤 1、随机设置K个特征空间内的点作为初始的聚类中心 2、对于...
  • 1.要指定聚类类别数的算法有K-means和谱聚类;无需指定的有BIRCH和DBSCAN2.K-means是基于质心,谱聚类基于无向图,BIRCH基于层次,DBSCAN基于密度3.无法很...
  • 聚类算法优化

    2021-04-16 21:39:14
    聚类算法优化 【其实就是为了选择质心,保证每个点距离不是很近】 k-means算法小结 优点: ​ 1.原理简单(靠近中心点),实现容易 ​ 2.聚类效果中上(依赖K的选择) ​ 3.空间复杂度o(N),时间复杂度o(IKN) ...
  • 无标签的数据集可通过聚类分析中设定的相似性度量进行分类,形成多个类簇,满足实验的分析需要。因聚类本身是一种具有主观性且能获得良好效果的研究手段,无严格意义上的对错之分,只有“类内的相似和类它的排斥”这...
  • k-means是一种最流行的聚类算法,属于无监督学习 k-means可以在数据集分为相似的组(簇),使得组内数据的相似度较高,组间之间的相似度较低。 k-means算法步骤: 1.从样本中选择k个点作为初始簇中心 2.计算每个...
  • 聚类或聚类分析是无监督学习问题。它通常被用作数据分析技术,用于发现数据中的有趣模式,例如基于其行为的客户群。有许多聚类算法可供选择,对于所有情况,没有单一的最佳...对于所有数据集,有许多不同的聚类算...
  • matlab实现聚类算法

    2021-04-14 22:11:32
    simulate2020625数据集 clear;clc load simulate2020625; k=max(subcluster(:,3));%设置聚类数目 data = subcluster(:,1:2); cata = subcluster; [m,n]=size(data); c1=subcluster(:,3); c1=c1'; %% 实际聚类图 ...
  • 前文我们讲过使用Opencv现有的Kmeans聚类函数来获取COCO数据集anchor框尺寸:基于libtorch的yolov5目标检测网络实现(3)——Kmeans聚类获取anchor框...
  • sklearn聚类算法Kmeans

    2021-02-01 16:46:17
    sklearn聚类算法Kmeans 菜菜的sklearn学习笔记 文章目录sklearn聚类算法Kmeans概述案例...通过sklearn自带的make_blobs函数可以生成聚类所需的数据集,注意,所生成的数据集是几个分簇。 from sklearn.datasets import
  • 数据聚类算法

    2021-02-28 08:02:47
    1.数据流数据流的产生:实时监控系统、气象卫星遥感、网络通信量...数据流挖掘的特点---挑战:(a)数据是海量的,不可能在内存及硬盘上存储整个流数据集。(b)单次线性扫描(单遍扫描)(single pass)的过程;数据元素...
  • 聚类算法简介

    2021-05-12 15:07:40
    因此聚类算法属于无监督算法。 2. 相似度的衡量 之前在k-means算法的简介当中,提及过一个欧式距离。但实际上,相似度的衡量方式有很多种。比如说: 欧式距离(这里列出的是欧式距离的拓展,闵可夫斯基距离): ...
  • 图像聚类算法

    2021-01-31 21:37:47
    文章目录图像聚类算法一、聚类二、聚类常见的算法2.1 K-Means聚类K-means聚类算法的分析流程:K-Means聚类与图像处理2.2 层次聚类2.3 密度聚类 图像聚类算法 一、聚类   从广义上说,聚类就是将数据集中某些方面...
  • DBSCAN聚类算法 1、算法原理 DBSCAN(Density-Based Spatial Clustering of Applications with Noise,具有噪声的基于密度的聚类方法)是一个有代表性的基于密度的空间聚类算法。它将类定义为密度相连的点的最大集合,...
  • 聚类算法综述(案例实现)

    千次阅读 2021-02-07 09:18:34
    聚类分析算法综述1. 聚类相关概念定义方法距离计算相似度计算应用2. 常用传统算法层次方法划分方法K-均值(K-Means)K-中心(K-Medoids)基于密度的方法DBscanMeanShift基于网格的方法...因此,一个聚类算法通常只需要
  • K-Means聚类算法原理

    2021-11-18 14:39:23
    K-Means算法是无监督的聚类算法,它实现起来比较简单,聚类效果也不错,因此应用很广泛。K-Means基于欧式距离认为两个目标距离越近,相似度越大。 1. 牧师-村民模型 2. K-Means原理初探 K-Means算法的思想很...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 69,891
精华内容 27,956
关键字:

聚类算法数据集