精华内容
下载资源
问答
  • Kmeans聚类算法详解

    万次阅读 多人点赞 2018-05-16 18:41:40
    摘要:本文通过图文详细介绍Kmeans聚类算法的原理和程序实现,以及如何选取类簇中心点。本文首先介绍利用该算法的原理及理解,详细介绍基于MATLAB设计一个自定义的Kmeans函数过程,然后利用该函数对UCI的数据集进行...

    摘要:本文详细介绍Kmeans聚类算法的原理和程序实现。首先介绍利用该算法的原理及理解,详细介绍基于MATLAB设计一个自定义的Kmeans函数过程,然后利用该函数对UCI的数据集进行聚类以测试聚类结果。后续章节将介绍的主要部分有:

    • Kmeans算法的原理及理解
    • 编程实现
    • 聚类结果评价
    • 类簇中心点的选取

    点击下载:本文Kmeans算法M函数及测试完整文件


    1. 前言

    作为无监督聚类算法中的代表——K均值聚类(Kmeans)算法,该算法的主要作用是将相似的样本自动归到一个类别中。所谓的监督算法,就是输入样本没有对应的输出或标签。聚类(clustering)试图将数据集中的样本划分为若干个通常是不相交的子集,每个子集称为一个“簇(cluster)”,聚类既能作为一个单独过程,用于找寻数据内在的分布结构,也可作为分类等其他学习任务的前去过程。——《Machine Learning》

    聚类算法也许是机器学习中“新算法”出现最多、最快的领域,一个重要的原因是聚类不存在客观标准,给定数据集总能从某个角度找到以往算法未覆盖的某种标准从而设计出新算法。Kmeans算法十分简单易懂而且非常有效,但是合理的确定K值和K个初始类簇中心点对于聚类效果的好坏有很大的影响。众多的论文基于此都提出了各自行之有效的解决方案,新的改进算法仍然不断被提出,此类文章大家可以在Web Of Science中搜索。

    尽管Kmeans算法在MATLAB、Python等语言的工具箱函数中都有自带的函数可供调用,但作为机器学习的研究者新来说要设计出新的算法,有时就得“定制”自己的Kmeans函数了。自己动手编写无疑也更加能理解算法的具体过程,接下来就让我们进入正题吧


    2. Kmeans算法的原理与理解

    Kmeans算法是最常用的聚类算法,主要思想是:在给定K值和K个初始类簇中心点的情况下,把每个点(亦即数据记录)分到离其最近的类簇中心点所代表的类簇中,所有点分配完毕之后,根据一个类簇内的所有点重新计算该类簇的中心点(取平均值),然后再迭代的进行分配点和更新类簇中心点的步骤,直至类簇中心点的变化很小,或者达到指定的迭代次数。

    2.1 基本原理

    假定给定数据样本X,包含了n个对象X={X1,X2,X3,...,Xn}X=\left \{ X_{1} ,X_{2},X_{3},...,X_{n}\right \},其中每个对象都具有m个维度的属性。Kmeans算法的目标是将n个对象依据对象间的相似性聚集到指定的k个类簇中,每个对象属于且仅属于一个其到类簇中心距离最小的类簇中。对于Kmeans,首先需要初始化k个聚类中心{C1,C2,C3,...,Ck},1<kn\left \{ C_{1} ,C_{2},C_{3},...,C_{k}\right \},1<k\leq n,然后通过计算每一个对象到每一个聚类中心的欧式距离,如下式所示dis(Xi,Cj)=t=1m(XitCjt)2dis(X_{i},C_{j})=\sqrt{\sum_{t=1}^{m}(X_{it}-C_{jt})^{2}}
    上式中,XiX_{i}表示第i个对象1in1\leq i\leq n,CjC_{j}表示第j个聚类中心的1jk1\leq j\leq kXitX_{it}表示第i个对象的第t个属性,1tm1\leq t\leq mCjtC_{jt}表示第j个聚类中心的第t个属性。

    依次比较每一个对象到每一个聚类中心的距离,将对象分配到距离最近的聚类中心的类簇中,得到k个类簇{S1,S2,S3,...,Sk}\left \{ S_{1},S_{2},S_{3},...,S_{k} \right \}

    Kmeans算法用中心定义了类簇的原型,类簇中心就是类簇内所有对象在各个维度的均值,其计算公式如下Ct=XiSlXiSlC_{t}=\frac{\sum_{X_{i}\in S_{l}}X_{i}}{\left | S_{l} \right |}
    式中,ClC_{l}表示第l个聚类的中心,1lk1\leq l\leq kSl\left | S_{l} \right |表示第l个类簇中对象的个数,XiX_{i}表示第l个类簇中第i个对象,1iSl1\leq i\leq\left | S_{l} \right |

    2.2 算法流程

    输入:样本集D={x1,x2,x3,...,xm}D=\left \{ x_{1},x_{2},x_{3},...,x_{m} \right \};聚类簇数k.
    过程:
    1:从D中随机选择k个样本作为初始均值向量{μ1,μ2,μ3,...,μk}\left \{ \mu _{1},\mu _{2},\mu _{3},...,\mu _{k} \right \}

    2:repeat
    3: 令Ci=(1ik)C_{i}=\varnothing (1\leqslant i\leqslant k)
    4: for j=1,2,…,m do
    5: 计算样本xjx_{j}与各均值向量μi(1ik)\mu_{i}(1\leqslant i\leqslant k)的距离:dji=xjμi2d_{ji}=\left \| x_{j}-\mu_{i} \right \|_{2};
    6: 根据距离最近的均值向量确定xjx_{j}的簇标记:λj=argmini{1,2,3,...,k}dji\lambda _{j}=arg min_{i\in \left \{ 1,2,3,...,k \right \}}d_{ji}
    7: 将样本xjx_{j}划入相应的簇:Cλj=Cλj{xj}C_{\lambda_{j}}=C_{\lambda_{j}}\cup \left \{ x_{j} \right \};
    8: end for

    9: for i=1,2,…,k do
    10: 计算新均值向量:μi=1CixCix\mu_{i}^{'}=\frac{1}{\left | C_{i} \right |}\sum _{x\in C_{i}}x;
    11: if μiμi\mu_{i}^{'}\neq \mu_{i} then
    12: 将当前均值向量 μi\mu_{i}更新为μi\mu_{i}^{'}
    13: else
    14: 保持当前均值不变
    15: end if

    16: end for
    17:until 当前均值向量均未更新
    输出:簇划分C={C1,C2,...,Ck}C=\left \{ C_{1} ,C_{2},...,C_{k} \right \}

    以上算法流程引自周志华《机器学习》,从流程来看K-means算法计算步骤基本上可以概括为两个部分:(1)计算每一个对象到类簇中心的距离;(2)根据类簇内的对象计算新的簇类中心。


    3. 编程实现

    为了方便应用我们将其编写为一个M函数KMeans(),首先需要确定函数的输入输出。这里输入参数为:data,K,iniCentriods,iterations(其中data为输入的不带标号的数据集数据矩阵,大小为numOfDatanumOfAttributes,K为数据分的类簇数目,iniCentriods为自行指定的初始聚类中心矩阵,大小为KnumOfAttributes,iterations为算法迭代次数。)
    输出参数为:Idx,centroids,DistanceIdx为返回的分类标号, centroids为每一类的中心,Distance为类内总距离)

    根据前面2.2节中的算法流程编写Kmeans算法的MATLAB程序如下

    %% Kmeans算法
    % 输入:
    % data 输入的不带分类标号的数据
    % K 数据一共分多少类
    % iniCentriods 自行指定初始聚类中心
    % iterations 迭代次数
    
    % 输出:
    % Idx 返回的分类标号
    % centroids 每一类的中心
    % Distance 类内总距离
    
     
    function [Idx,centroids,Distance]=KMeans(data,K,iniCentriods,iterations)
    [numOfData,numOfAttr]=size(data); % numOfData是数据个数,numOfAttr是数据维数
    centroids=iniCentriods;
    %% 迭代
    for iter=1:iterations
        pre_centroids=centroids;% 上一次求得的中心位置
        
        tags=zeros(numOfData,K);
        %% 寻找最近中心,更新中心
        for i=1:numOfData
            D=zeros(1,K);% 每个数据点与每个聚类中心的标准差
            Dist=D;
            
            % 计算每个点到每个中心点的标准差
            for j=1:K
                Dist(j)=norm(data(i,:)-centroids(j,:),2);
            end
            
            [minDistance,index]=min(Dist);% 寻找距离最小的类别索引
            tags(i,index)=1;% 标记最小距离所处的位置(类别)
        end
        
        
        %% 取均值更新聚类中心点
        for i=1:K
            if sum(tags(:,i))~=0
                % 未出现空类,计算均值作为下一聚类中心
                for j=1:numOfAttr
                    centroids(i,j)=sum(tags(:,i).*data(:,j))/sum(tags(:,i));
                end
            else % 如果出现空类,从数据集中随机选中一个点作为中心
                randidx = randperm(size(data, 1));
                centroids(i,:) = data(randidx(1),:);
                tags(randidx,:)=0;
                tags(randidx,i)=1;
            end
        end
        
       
        if sum(norm(pre_centroids-centroids,2))<0.001  % 不断迭代直到位置不再变化
            break;
        end
        
        
    end
    
    %% 计算输出结果
    Distance=zeros(numOfData,1);
    Idx=zeros(numOfData,1);
    for i=1:numOfData
        D=zeros(1,K);% 每个数据点与每个聚类中心的标准差
        Dist=D;
        % 计算每个点到每个中心点的标准差
        for j=1:K
            Dist(j)=norm(data(i,:)-centroids(j,:),2);
        end
        
        [distance,idx]=min(Dist);% 寻找距离最小的类别索引
        distance=Dist(idx);
        
        Distance(i)=distance;
        Idx(i)=idx;
    end
    Distance=sum(Distance,1);% 计算类内总距离
    end
    

    在以上代码中其最主要部分在于第18至58行,进行寻找最近中心和求取均值更新聚类中心点。值得注意的是,在聚类过程中可能会出现空类即代码第44行那样,为保证算法的继续运行,从数据集中随机选取一个点作为中心。

    4. 聚类结果评价

    为了验证编写的Kmeans函数的性能,这里对想用的UCI数据集Iris数据集进行聚类并计算聚类的准确率,Iris数据集可以在http://archive.ics.uci.edu/ml/index.php上下载得到。首先读取Iris数据集,自行指定初始聚类中心调用前面编写的KMeans函数进行聚类,然后计算聚类的准确率,其代码如下

    clear 
    data=load('Iris.txt');
    data=data(:,2:end);
    
    matrix=[5.9016,2.7484,4.3935,1.4339;6.8500,3.0737,5.7421,2.0711;5.0060,3.4280,1.4620,0.2460];
    [Idx,C,distance]=KMeans(data,3,matrix,500);
    Distance=sum(distance)
    
    c1=Idx(1:50,1);c2=Idx(51:100,1);c3=Idx(101:150,1);
    accuracy=(sum(c1==mode(Idx(1:50,1)))+sum(c2==mode(Idx(51:100,1)))+sum(c3==mode(Idx(101:150,1))))/150
    

    为方便使用Iris数据集经过了一些整理,这里将最后一列的带字符串的标签Iris-setosa,Iris-versicolor,Iris-virginica分别用数字1,2,3代替并移到了第一列,所以第三行选取的是从第二列至最后一列的数据。第5行中的matrix是查阅论文得到的一个初始聚类中心,正好用来比对聚类结果。第6行则调用KMeans()函数进行聚类,得到聚类标号和类内距离。对每类的类内距离求和即得到总的距离Distance,如第7行。准确率的计算有点麻烦,因为不能直接用KMeans计算后得到的标号跟原数据集中的标号对比计算准确率,KMeans只需要也只能将那些“相似”的数据点聚集到一类中,而给这一类数据的标号却是可能跟原数据集不同的。

    这里采用一个简单的方法,从原数据集的标签可以看出第1-50个数据点为一类(Iris-setosa),第51-100为一类(Iris-versicolor),第101-150为一类(Iris-virginica),因此只需确定每50个数据点中的聚类标号是不是一致。取它们之中数目最多的标号作为正确的个数,最终比上数据集的总数即为准确率。以上代码运行结果如下所示。

    5. 类簇中心点的选取

    KMeans算法本身思想比较简单,但是合理的确定K值和K个初始类簇中心点对于聚类效果的好坏有很大的影响。最简单的确定初始类簇中心点的方法是随机产生数据大小范围内的K个点作为初始的簇类中心点。随机产生初始点并进行测试的程序代码如下

    clear
    data=load('Iris.txt');
    data=data(:,2:end);
    K=3;
    
    
    %% 产生随机初始点
    [numOfData,numOfAttr]=size(data);   % numOfData是数据个数,numOfAttr是数据维数
    
    centroids=zeros(K,numOfAttr);       % 随机初始化,最终迭代到每一类的中心位置
    maxAttr=zeros(numOfAttr);        % 每一维最大的数
    minAttr=zeros(numOfAttr);        % 每一维最小的数
    for i=1:numOfAttr
        maxAttr(i)=max(data(:,i));    % 每一维最大的数
        minAttr(i)=min(data(:,i));    % 每一维最小的数
        for j=1:K
            centroids(j,i)=maxAttr(i)+(minAttr(i)-maxAttr(i))*rand();  % 随机初始化,选取每一维[min max]中初始化
        end
    end
    
    [Idx,C,distance]=KMeans(data,K,centroids,500);% 调用KMeans
    Distance=sum(distance)% 计算类内距离之和
    
    %% 计算准确率
    c1=Idx(1:50,1);c2=Idx(51:100,1);c3=Idx(101:150,1);
    Accuracy=(sum(c1==mode(Idx(1:50,1)))+sum(c2==mode(Idx(51:100,1)))+sum(c3==mode(Idx(101:150,1))))/numOfData
    

    可以多运行几次以上代码,可以看出由于初始点事随机选取的每次运行得到的结果有所差异。这也是基本Kmeans算法的一个缺点,随着众多改进算法的提出Kmeans算法的这一问题也得到改善,深入了解的朋友可以查阅相关论文。

    6. 结束语

    本博文的完整MATLAB程序文件与整理好的数据集文件已经上传,下载即可运行。下载地址如下

    点击下载:本文Kmeans算法M函数及测试完整文件

    公众号获取
        本人微信公众号已创建,扫描以下二维码并关注公众号“AI技术研究与分享”,后台回复“KM20180516”即可获取全部资源文件信息。

    由于编者能力有限,代码即使经过了多次校对,也难免会有疏漏之处。希望您能热心指出其中的错误,以便下次修改时能以一个更完美更严谨的样子,呈现在大家面前。同时如果有更好的实现方法也请您不吝赐教。

    展开全文
  • 本节内容:本节内容是根据上学期所上的模式识别课程的作业整理而来,第一道题目是Kmeans聚类算法数据集是Iris(鸢尾花的数据集),分类数k是3,数据维数是4。关于聚类聚类算法是这样的一种算法:给定样本数据Sample...

    本节内容:本节内容是根据上学期所上的模式识别课程的作业整理而来,第一道题目是Kmeans聚类算法,数据集是Iris(鸢尾花的数据集),分类数k是3,数据维数是4。

    关于聚类

    聚类算法是这样的一种算法:给定样本数据Sample,要求将样本Sample中相似的数据聚到一类。有了这个认识之后,就应该了解了聚类算法要干什么了吧。说白了,就是归类。

    首先,我们需要考虑的是,如何衡量数据之间的相似程度?比如说,有一群说不同语言的人,我们一般是根据他们的方言来聚类的(当然,你也可以指定以身高来聚类)。这里,语言的相似性(或者身高)就成了我们衡量相似的量度了。在考虑存在海量数据,如微博上各种用户的关系网,如何根据用户的关注和被关注来聚类,给用户推荐他们感兴趣的用户?这就是聚类算法研究的内容之一了。

    Kmeans就是这样的聚类算法中比较简单的算法,给定数据样本集Sample和应该划分的类数K,对样本数据Sample进行聚类,最终形成K个cluster,其相似的度量是某条数据i与中心点的”距离”(这里所说的距离,不止于二维)。

    基本思想

    KMeans算法的基本思想是初始随机给定K个簇中心,按照最邻近原则把待分类样本点分到各个簇。然后按平均法重新计算各个簇的质心,从而确定新的簇心。一直迭代,直到簇心的移动距离小于某个给定的值。

    基本步骤

    K-Means聚类算法主要分为三个步骤:

    1,初始化k个聚类中心。

    2,计算出每个对象跟这k个中心的距离(相似度计算,这个下面会提到),假如x这个对象跟y这个中心的距离最小(相似度最大),那么x属于y这个中心。这一步就可以得到初步的k个聚类 。

    3,在第二步得到的每个聚类分别计算出新的聚类中心,和旧的中心比对,假如不相同,则继续第2步,直到新旧两个中心相同,说明聚类不可变,已经成功 。

    复杂度分析

    时间复杂度:O(tKmn),其中,t为迭代次数,K为簇的数目,m为记录数,n为维数

    空间复杂度:O((m+K)n),其中,K为簇的数目,m为记录数,n为维数

    初始质心的选择

    选择适当的初始质心是基本kmeans算法的关键步骤。常见的方法是随机的选取初始质心,但是这样簇的质量常常很差。处理选取初始质心问题的一种常用技术是:多次运行,每次使用一组不同的随机初始质心,然后选取具有最小SSE(误差的平方和)的簇集。这种策略简单,但是效果可能不好,这取决于数据集和寻找的簇的个数。

    第二种有效的方法是,取一个样本,并使用层次聚类技术对它聚类。从层次聚类中提取K个簇,并用这些簇的质心作为初始质心。该方法通常很有效,但仅对下列情况有效:

    (1)样本相对较小,例如数百到数千(层次聚类开销较大);

    (2)K相对于样本大小较小

    第三种选择初始质心的方法,随机地选择第一个点,或取所有点的质心作为第一个点。然后,对于每个后继初始质心,选择离已经选取过的初始质心最远的点。使用这种方法,确保了选择的初始质心不仅是随机的,而且是散开的。但是,这种方法可能选中离群点。此外,求离当前初始质心集最远的点开销也非常大。为了克服这个问题,通常该方法用于点样本。由于离群点很少(多了就不是离群点了),它们多半不会在随机样本中出现。计算量也大幅减少。

    第四种方法是使用canopy算法进行初始划分。基于Canopy Method的聚类算法将聚类过程分为两个阶段:

    Stage1:聚类最耗费计算的地方是计算对象相似性的时候,Canopy Method在第一阶段选择简单、计算代价较低的方法计算对象相似性,将相似的对象放在一个子集中,这个子集被叫做Canopy ,通过一系列计算得到若干Canopy,Canopy之间可以是重叠的,但不会存在某个对象不属于任何Canopy的情况,可以把这一阶段看做数据预处理。

    Stage2:在各个Canopy 内使用传统的聚类方法(如K-means),不属于同一Canopy 的对象之间不进行相似性计算。从这个方法起码可以看出两点好处:首先,Canopy 不要太大且Canopy 之间重叠的不要太多的话会大大减少后续需要计算相似性的对象的个数;其次,类似于K-means这样的聚类方法是需要人为指出K的值的,通过Stage1得到的Canopy 个数完全可以作为这个K值,一定程度上减少了选择K的盲目性。

    算法实验

    任务

    在给定的Iris.txt样本文件中,用K-means聚类算法将150个4维样本数据分成3类

    数据集(Iris.txt)

    5.1 3.5 1.4 0.2

    4.9 3.0 1.4 0.2

    4.7 3.2 1.3 0.2

    4.6 3.1 1.5 0.2

    5.0 3.6 1.4 0.2

    5.4 3.9 1.7 0.4

    4.6 3.4 1.4 0.3

    5.0 3.4 1.5 0.2

    4.4 2.9 1.4 0.2

    4.9 3.1 1.5 0.1

    5.4 3.7 1.5 0.2

    4.8 3.4 1.6 0.2

    4.8 3.0 1.4 0.1

    4.3 3.0 1.1 0.1

    5.8 4.0 1.2 0.2

    5.7 4.4 1.5 0.4

    5.4 3.9 1.3 0.4

    5.1 3.5 1.4 0.3

    5.7 3.8 1.7 0.3

    5.1 3.8 1.5 0.3

    5.4 3.4 1.7 0.2

    5.1 3.7 1.5 0.4

    4.6 3.6 1.0 0.2

    5.1 3.3 1.7 0.5

    4.8 3.4 1.9 0.2

    5.0 3.0 1.6 0.2

    5.0 3.4 1.6 0.4

    5.2 3.5 1.5 0.2

    5.2 3.4 1.4 0.2

    4.7 3.2 1.6 0.2

    4.8 3.1 1.6 0.2

    5.4 3.4 1.5 0.4

    5.2 4.1 1.5 0.1

    5.5 4.2 1.4 0.2

    4.9 3.1 1.5 0.2

    5.0 3.2 1.2 0.2

    5.5 3.5 1.3 0.2

    4.9 3.6 1.4 0.1

    4.4 3.0 1.3 0.2

    5.1 3.4 1.5 0.2

    5.0 3.5 1.3 0.3

    4.5 2.3 1.3 0.3

    4.4 3.2 1.3 0.2

    5.0 3.5 1.6 0.6

    5.1 3.8 1.9 0.4

    4.8 3.0 1.4 0.3

    5.1 3.8 1.6 0.2

    4.6 3.2 1.4 0.2

    5.3 3.7 1.5 0.2

    5.0 3.3 1.4 0.2

    7.0 3.2 4.7 1.4

    6.4 3.2 4.5 1.5

    6.9 3.1 4.9 1.5

    5.5 2.3 4.0 1.3

    6.5 2.8 4.6 1.5

    5.7 2.8 4.5 1.3

    6.3 3.3 4.7 1.6

    4.9 2.4 3.3 1.0

    6.6 2.9 4.6 1.3

    5.2 2.7 3.9 1.4

    5.0 2.0 3.5 1.0

    5.9 3.0 4.2 1.5

    6.0 2.2 4.0 1.0

    6.1 2.9 4.7 1.4

    5.6 2.9 3.9 1.3

    6.7 3.1 4.4 1.4

    5.6 3.0 4.5 1.5

    5.8 2.7 4.1 1.0

    6.2 2.2 4.5 1.5

    5.6 2.5 3.9 1.1

    5.9 3.2 4.8 1.8

    6.1 2.8 4.0 1.3

    6.3 2.5 4.9 1.5

    6.1 2.8 4.7 1.2

    6.4 2.9 4.3 1.3

    6.6 3.0 4.4 1.4

    6.8 2.8 4.8 1.4

    6.7 3.0 5.0 1.7

    6.0 2.9 4.5 1.5

    5.7 2.6 3.5 1.0

    5.5 2.4 3.8 1.1

    5.5 2.4 3.7 1.0

    5.8 2.7 3.9 1.2

    6.0 2.7 5.1 1.6

    5.4 3.0 4.5 1.5

    6.0 3.4 4.5 1.6

    6.7 3.1 4.7 1.5

    6.3 2.3 4.4 1.3

    5.6 3.0 4.1 1.3

    5.5 2.5 5.0 1.3

    5.5 2.6 4.4 1.2

    6.1 3.0 4.6 1.4

    5.8 2.6 4.0 1.2

    5.0 2.3 3.3 1.0

    5.6 2.7 4.2 1.3

    5.7 3.0 4.2 1.2

    5.7 2.9 4.2 1.3

    6.2 2.9 4.3 1.3

    5.1 2.5 3.0 1.1

    5.7 2.8 4.1 1.3

    6.3 3.3 6.0 2.5

    5.8 2.7 5.1 1.9

    7.1 3.0 5.9 2.1

    6.3 2.9 5.6 1.8

    6.5 3.0 5.8 2.2

    7.6 3.0 6.6 2.1

    4.9 2.5 4.5 1.7

    7.3 2.9 6.3 1.8

    6.7 2.5 5.8 1.8

    7.2 3.6 6.1 2.5

    6.5 3.2 5.1 2.0

    6.4 2.7 5.3 1.9

    6.8 3.0 5.5 2.1

    5.7 2.5 5.0 2.0

    5.8 2.8 5.1 2.4

    6.4 3.2 5.3 2.3

    6.5 3.0 5.5 1.8

    7.7 3.8 6.7 2.2

    7.7 2.6 6.9 2.3

    6.0 2.2 5.0 1.5

    6.9 3.2 5.7 2.3

    5.6 2.8 4.9 2.0

    7.7 2.8 6.7 2.0

    6.3 2.7 4.9 1.8

    6.7 3.3 5.7 2.1

    7.2 3.2 6.0 1.8

    6.2 2.8 4.8 1.8

    6.1 3.0 4.9 1.8

    6.4 2.8 5.6 2.1

    7.2 3.0 5.8 1.6

    7.4 2.8 6.1 1.9

    7.9 3.8 6.4 2.0

    6.4 2.8 5.6 2.2

    6.3 2.8 5.1 1.5

    6.1 2.6 5.6 1.4

    7.7 3.0 6.1 2.3

    6.3 3.4 5.6 2.4

    6.4 3.1 5.5 1.8

    6.0 3.0 4.8 1.8

    6.9 3.1 5.4 2.1

    6.7 3.1 5.6 2.4

    6.9 3.1 5.1 2.3

    5.8 2.7 5.1 1.9

    6.8 3.2 5.9 2.3

    6.7 3.3 5.7 2.5

    6.7 3.0 5.2 2.3

    6.3 2.5 5.0 1.9

    6.5 3.0 5.2 2.0

    6.2 3.4 5.4 2.3

    5.9 3.0 5.1 1.8

    Python实现

    算法流程

    第一步,将文件中的数据读入到dataset列表中,通过len(dataset[0])来获取数据维数,在测试样例中是四维

    第二步,产生聚类的初始位置。首先扫描数据,获取每一维数据分量中的最大值和最小值,然后在这个区间上随机产生一个值,循环k次(k为所分的类别),这样就产生了聚类初始中心(k个)

    第三步,按照最短距离(欧式距离)原则将所有样本分配到k个聚类中心中的某一个,这步操作的结果是产生列表assigments,可以通过Python中的zip函数整合成字典。注意到原始聚类中心可能不在样本中,因此可能出现分配的结果出现某一个聚类中心点集合为空,此时需要结束,提示“随机数产生错误,需要重新运行”,以产生合适的初始中心。

    第四步,计算各个聚类中心的新向量,更新距离,即每一类中每一维均值向量。然后再进行分配,比较前后两个聚类中心向量是否相等,若不相等则进行循环,否则终止循环,进入下一步。

    最后,将结果输出到文件和屏幕中

    代码如下

    # coding=gbk

    #python edition: Python3.4.1,2014,9,24

    from collections import defaultdict

    from random import uniform

    from math import sqrt

    def read_points():

    dataset=[]

    with open('Iris.txt','r') as file:

    for line in file:

    if line =='\n':

    continue

    dataset.append(list(map(float,line.split(' '))))

    file.close()

    return dataset

    def write_results(listResult,dataset,k):

    with open('result.txt','a') as file:

    for kind in range(k):

    file.write( "CLASSINFO:%d\n"%(kind+1) )

    for j in listResult[kind]:

    file.write('%d\n'%j)

    file.write('\n')

    file.write('\n\n')

    file.close()

    def point_avg(points):

    dimensions=len(points[0])

    new_center=[]

    for dimension in range(dimensions):

    sum=0

    for p in points:

    sum+=p[dimension]

    new_center.append(float("%.8f"%(sum/float(len(points)))))

    return new_center

    def update_centers(data_set ,assignments,k):

    new_means = defaultdict(list)

    centers = []

    for assignment ,point in zip(assignments , data_set):

    new_means[assignment].append(point)

    for i in range(k):

    points=new_means[i]

    centers.append(point_avg(points))

    return centers

    def assign_points(data_points,centers):

    assignments=[]

    for point in data_points:

    shortest=float('inf')

    shortest_index = 0

    for i in range(len(centers)):

    value=distance(point,centers[i])

    if value

    shortest=value

    shortest_index=i

    assignments.append(shortest_index)

    if len(set(assignments))

    print("\n--!!!产生随机数错误,请重新运行程序!!!!--\n")

    exit()

    return assignments

    def distance(a,b):

    dimention=len(a)

    sum=0

    for i in range(dimention):

    sq=(a[i]-b[i])**2

    sum+=sq

    return sqrt(sum)

    def generate_k(data_set,k):

    centers=[]

    dimentions=len(data_set[0])

    min_max=defaultdict(int)

    for point in data_set:

    for i in range(dimentions):

    value=point[i]

    min_key='min_%d'%i

    max_key='max_%d'%i

    if min_key not in min_max or value

    min_max[min_key]=value

    if max_key not in min_max or value>min_max[max_key]:

    min_max[max_key]=value

    for j in range(k):

    rand_point=[]

    for i in range(dimentions):

    min_val=min_max['min_%d'%i]

    max_val=min_max['max_%d'%i]

    tmp=float("%.8f"%(uniform(min_val,max_val)))

    rand_point.append(tmp)

    centers.append(rand_point)

    return centers

    def k_means(dataset,k):

    k_points=generate_k(dataset,k)

    assignments=assign_points(dataset,k_points)

    old_assignments=None

    while assignments !=old_assignments:

    new_centers=update_centers(dataset,assignments,k)

    old_assignments=assignments

    assignments=assign_points(dataset,new_centers)

    result=list(zip(assignments,dataset))

    print('\n\n---------------------------------分类结果---------------------------------------\n\n')

    for out in result :

    print(out,end='\n')

    print('\n\n---------------------------------标号简记---------------------------------------\n\n')

    listResult=[[] for i in range(k)]

    count=0

    for i in assignments:

    listResult[i].append(count)

    count=count+1

    write_results(listResult,dataset,k)

    for kind in range(k):

    print("第%d类数据有:"%(kind+1))

    count=0

    for j in listResult[kind]:

    print(j,end=' ')

    count=count+1

    if count%25==0:

    print('\n')

    print('\n')

    print('\n\n--------------------------------------------------------------------------------\n\n')

    def main():

    dataset=read_points()

    k_means(dataset,3)

    if __name__ == "__main__":

    main()

    分类结果

    a. 通过多次运行程序发现,所得结果与初始值的选定有着密切的关系,并且由于在我的程序中采用随机数的方式产生初值,因此经过观察发现有多种结果。

    b. 其中两种常见的结果之一如下:

    第1类数据有:(50)

    0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

    第2类数据有:(38)

    52 77 100 102 103 104 105 107 108 109 110 111 112 115 116 117 118 120 122 124 125 128 129 130 131 132 134 135 136 137 139 140 141 143 144 145 147 148

    第3类数据有:(62)

    50 51 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

    76 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 101 106

    113 114 119 121 123 126 127 133 138 142 146 149

    c. 结果之二:

    第1类数据有:(50)

    0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

    25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

    第2类数据有:(61)

    51 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

    78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 101 106 113

    114 119 121 123 126 127 133 138 142 146 149

    第3类数据有:(39)

    50 52 77 100 102 103 104 105 107 108 109 110 111 112 115 116 117 118 120 122 124 125 128 129 130 131 132 134 135 136 137 139 140 141 143 144 145 147 148

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    展开全文
  • 值感兴趣的小伙 们可以参考一下 本本节内内容容 本节内容是根据上学期所上的模式识别课程的作业整理而来第一道题目是Kmeans聚类算法数据集是Ir is(鸢尾花的数据集)分类数k是3数据维数是4 关关于于聚聚类 聚类算法是...
  • 上课,老师让做作业,kmeans分类,将iris进行聚类分类,于是就做了这个作业。很简单,我就将其设置为分三类,重点是我在选择初始center的时候,尝试了使用随机选取和使用大招选取两种方式,随机选择初始点的效果不如...

    上课,老师让做作业,kmeans分类,将iris进行聚类分类,于是就做了这个作业。很简单,我就将其设置为分三类,重点是我在选择初始center的时候,尝试了使用随机选取和使用大招选取两种方式,随机选择初始点的效果不如放大招。这个大招是这样的:先随机选取一个作为center1,再选取一个距离这个center1最远的点作为center2,再选择一个距离center1和center2最远的点作为center3。

    在训练过程中更新质心的时候,我不是选择online模式,来一个点更新一次质心,而是选择了mini_batch的模式,先送进来mini_batch个样本,分别将其划归到对应的中心处,然后再进行更新。说这么多屁话,不如把代码放上来,代码如下:

    import numpy as np
    import csv
    import random
    
    features = np.loadtxt('iris.csv',delimiter=',',usecols=(1,2,3,4))  #read features
    z_min, z_max = features.min(axis=0), features.max(axis=0)          #features normalized
    features = (features - z_min)/(z_max - z_min)
    
    csv_file = open('iris.csv')   #transform string to num label
    csv_reader_lines = csv.reader(csv_file)
    classes_list = []
    for i in csv_reader_lines:
        classes_list.append(i[-1])
    labels = []
    for i in classes_list:
        if i=='setosa':
            labels.append(0)
        elif i=='versicolor':
            labels.append(1)
        else:
            labels.append(2)
    
    labels = np.array(labels)
    labels = labels.reshape((150,1))   # transformm list to numpy type
    
    data_index = np.arange(features.shape[0])
    np.random.shuffle(data_index)
    
    train_input = features[ data_index[0:120] ]
    train_label = labels[ data_index[0:120] ]
    
    test_input = features[ data_index[120:150] ]
    test_label = labels[ data_index[120:150] ]
    
    train_length = 120
    K = 3
    center_1_pos = random.randint(0,train_length)
    center1 = train_input[ center_1_pos ]
    # center1 = train_input[0]
    # center2 = train_input[1]
    # center3 = train_input[2]
    # print(center1)
    # print(center2)
    # print(center3)
    
    biggest_distance = 0.0
    center_2_pos = 0
    
    for i in range(train_length):#选择center2
        dist = np.sum(pow( (center1 - train_input[i]),2 ))
        if dist > biggest_distance:
            biggest_distance = dist
            center_2_pos = i
    
    center2 = train_input[center_2_pos]
    
    
    biggest_distance = 0.0
    center_3_pos = 0
    
    for i in range(train_length):#选择center3
        dist = np.sum(pow( (center1 - train_input[i]), 2 )) + np.sum(pow( (center2 - train_input[i]) , 2))
        if dist > biggest_distance:
            biggest_distance = dist
            center_3_pos = i
    
    center3 = train_input[center_3_pos]
    mini_batch = 20
    
    for epoch in range(10):#在整个数据集上训练10次
        for i in range(6):
            belong1 = []
            belong2 = []
            belong3 = []
            for j in range(mini_batch):#mini_batch
                temp_index = mini_batch * i + j
                belong = 1
                dist_1 = np.sum(pow( ( center1 - train_input[mini_batch*i+j] ),2 ))
                temp_dist = dist_1
    
                dist_2 = np.sum(pow((center2 - train_input[mini_batch * i + j]), 2))
                dist_3 = np.sum(pow((center3 - train_input[mini_batch * i + j]), 2))
    
                if(dist_2 < temp_dist):
                    temp_dist = dist_2
                    belong = 2
                if(dist_3 < temp_dist):
                    belong = 3
    
                if belong==1:
                    belong1.append( temp_index )
                elif belong == 2:
                    belong2.append(temp_index)
                else:
                    belong3.append(temp_index)
    
    
            for k in belong1:
                center1 = center1 + train_input[k]
            center1 = center1 / (1 + len(belong1))
    
            for k in belong2:
                center2 = center2 + train_input[k]
            center2 = center2 / (1 + len(belong2))
    
            for k in belong3:
                center3 = center3 + train_input[k]
            center3 = center3 / (1 + len(belong3))
    
        b_1=[]
        b_2=[]
        b_3=[]
        for l in range(test_input.shape[0]):#在测试机上进行测试
            belong = 1
            dist_1 = np.sum(pow((center1 - test_input[l]), 2))
            temp_dist = dist_1
    
            dist_2 = np.sum(pow((center2 - test_input[ l ]), 2))
            dist_3 = np.sum(pow((center3 - test_input[ l ]), 2))
    
            if (dist_2 < temp_dist):
                temp_dist = dist_2
                belong = 2
            if (dist_3 < temp_dist):
                belong = 3
    
    
    
            if belong == 1:
                b_1.append(test_label[l][0])
            elif belong == 2:
                b_2.append(test_label[l][0])
            else:
                b_3.append(test_label[l][0])
        print()
        print('epoch : {} / 10' .format(epoch+1))
        print('center1: ',b_1)
        print('center2',b_2)
        print('center3: ',b_3)

    下面是我运行程序的结果:

    epoch : 1 / 10
    center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
    center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    center3:  [2, 2, 2, 2, 2]
    
    epoch : 2 / 10
    center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
    center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    center3:  [2, 2, 2, 2, 2]
    
    epoch : 3 / 10
    center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
    center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    center3:  [2, 2, 2, 2, 2]
    
    epoch : 4 / 10
    center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
    center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    center3:  [2, 2, 2, 2, 2]
    
    epoch : 5 / 10
    center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
    center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    center3:  [2, 2, 2, 2, 2]
    
    epoch : 6 / 10
    center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
    center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    center3:  [2, 2, 2, 2, 2]
    
    epoch : 7 / 10
    center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
    center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    center3:  [2, 2, 2, 2, 2]
    

         小数据集上结果还是挺好的。

    iris数据集的一个下载链接如下:链接: https://pan.baidu.com/s/1PpIwncqbtQbEuGKSxKyBMg  密码: 7ins

    注意:我在读取iris的数据时候,将第一行的属性名称删除了,要不然处理起来麻烦。

    哎,做这个小作业也挺有意思的,学习了Nummpy数据的归一化还,csv文件的numpy读取,以及如何将csv文件中的字符类型转化为数字标签。

    展开全文
  • 本节内容:本节内容是根据上学期所上的模式识别课程的作业整理而来,第一道题目是Kmeans聚类算法数据集是Iris(鸢尾花的数据集),分类数k是3,数据维数是4。 关于聚类  聚类算法是这样的一种算法:给定样本数据...
  • kmeans聚类算法

    2019-11-28 14:47:27
    kmeans聚类算法的思想有如下几步 第一步 首先在数据集随机挑选k个点,分别作为这k个簇的质心 第二步 其余的点根据欧式距离公式,找到离其自身最近的质心 并合并为一类 第三步 现在我们已经初步的到聚类过的...

    前言

    kmeans是一种聚类算法

    其简单,易用

    在机器学习,数据挖掘领域常常应用

    原理

    众所周知聚类就是要对一堆杂乱无章的数据进行分类合并

    假设我们有数据集dataset,并且将其聚类为k个簇
    kmeans聚类算法的思想有如下几步

    第一步

    首先在数据集随机挑选k个点,分别作为这k个簇的质心

    第二步

    其余的点根据欧式距离公式,找到离其自身最近的质心
    并合并为一类

    第三步

    现在我们已经初步的到聚类过的样本集合

    然后我们取每个样本集合的均值点作为新的质心
    重新进行聚类

    第四步

    各样本点根据新的质心再进行回归

    直到样本点分类不再发生改变

    算法实现

    网上也有很多算法实现
    这里我找到一篇比较有效率的代码
    下面是该博客地址
    https://blog.csdn.net/xufive/article/details/101448969
    我在其源代码上增加了一些注释
    话不多说直接上代码

    import numpy as np
    import time
    import matplotlib.pyplot as plt
    
    
    def kmeans(ds, k):
        """
        kmeans聚类算法
        :param ds: 数据集,形式为ndarray(m, n) 即m个样本,每个样本有 n 个属性值
        :param k: 指定分簇数量
        :return:
        """
        m, n = ds.shape
        result = np.empty(m, dtype=np.int) # 产生一个有随机元素的指定大小的矩阵
        cores = ds[np.random.choice(np.arange(m), k ,replace=False)] # 从m个样本随机挑选k个作为core
    
        while True:
            d = np.square(np.repeat(ds, k, axis=0).reshape(m, k, n) - cores)
            """
            np.repeat是将一个矩阵展开成行向量
            第二个参数指定要复制多少
            这里就是展开数据集
            因为有k个质心
            然后分别计算对应的距离差值
            """
            distance = np.sqrt(np.sum(d, axis=2)) # 在第二维度累加,即形状由(m, k, n)变为(m, k)
            index_min = np.argmin(distance, axis=1) # 找距离最小值
    
            if (index_min == result).all():
                # 这个条件就是样本聚类没有发生改变
                return result, cores # 返回聚类结果,以及质心
    
            result[:] = index_min
    
            for i in range(k):
                # 取质心集合的平均值做为新的质心
                items = ds[result==i] # 找出当前质心对应的数据集
                cores[i] = np.mean(items, axis=0) # 取质心平均值作为新的质心进行迭代
    
    
    def create_data_set(*cores):
        """生成k-means聚类测试用数据集"""
    
        ds = list()
        for x0, y0, z0 in cores:
            x = np.random.normal(x0, 0.1 + np.random.random() / 3, z0)
            y = np.random.normal(y0, 0.1 + np.random.random() / 3, z0)
            ds.append(np.stack((x, y), axis=1))
    
        return np.vstack(ds)
    
    
    k = 4
    ds = create_data_set((0,0,2500), (0,2,2500), (2,0,2500), (2,2,2500))
    
    t0 = time.time()
    result, cores = kmeans(ds, k)
    t = time.time() - t0
    
    plt.scatter(ds[:,0], ds[:,1], s=1, c=result.astype(np.int))
    plt.scatter(cores[:,0], cores[:,1], marker='x', c=np.arange(k))
    plt.show()
    
    print(u'使用kmeans算法,1万个样本点,耗时%f0.3秒'%t)
    
    
    

    在这里插入图片描述

    展开全文
  • Kmeans聚类算法

    万次阅读 2017-06-18 23:23:48
    Kmeans聚类算法 动态聚类算法  任务:是将数据集划分成一定数量的子集,例如将一个数据集划分成3、4个子集等。因此要划分成多少个子集往往要预先确定,或大致确定,当然这个子集数目在理想情况能体现数据集比较...
  • Kmeans聚类算法及其Python实现

    万次阅读 2015-04-12 12:51:03
    Python实现 本节内容:本节内容是根据上学期所上的模式识别课程的作业整理而来,第一道题目是Kmeans聚类算法数据集是Iris(鸢尾花的数据集),分类数k是3,数据维数是4。 关于聚类 聚类算法是这样的一种算法:给定...
  • Kmeans 聚类算法,数据集是 Iris(鸢尾花的数据集),分类数 k 是 3...# @Desc:Kmeans聚类算法数据集是Iris(鸢尾花的数据集),分类数k是3,数据维数是4。 __author__ = '未昔/AngelFate' __date__ = '2019/8/17 14:00'
  • kmeans聚类算法改进

    千次阅读 2018-03-05 20:14:10
    由于kmeans聚类算法对离群点或者噪音很敏感,而且适合凸规模的数据集,而且可能陷入局部最优等等问题,前辈们又提出了很多改进的算法!(总参考:机器学习(25)之K-Means聚类算法详解) 二分kmeans(bisecting K-...
  • Kmeans聚类算法源码

    2010-06-24 10:54:17
    Kmeans聚类算法的C#实现,包括数据集的特殊表示,数据集在该程序中存储为dateset类,其内容从*.dmds文件读入,每个列都是double型数据。该算法实现了快速有效地数据聚类,可作为数据挖掘初学者的入门参考
  • Kmeans 聚类算法

    2021-02-20 12:36:24
    KMeans算法属于无监督学习,解决聚类的问题 对于数据集D, 不需提供数据标记,大大减少工作量 数据集D必须是凸集,非凸数据集难以收敛 必须先指定聚类簇数k k-means优点 原理简单,实现容易,可解释性较强 聚类...
  • 1、kmeanskmeans, k-均值聚类算法,能够实现发现数据集的 k 个簇的算法,每个簇通过其质心来描述。kmeans步骤: (1)随机找 k 个点作为质心(种子); (2)计算其他点到这 k 个种子的距离,选择最近的那个作为该点...
  • Kmeans聚类算法原理与实现

    千次阅读 2016-07-11 15:07:52
    Kmeans聚类算法 1 Kmeans聚类算法的基本原理 K-means算法是最为经典的基于划分的聚类方法,是十大经典数据挖掘算法之一。K-means算法的基本思想是:以空间中k个点为中心进行聚类,对最靠近他们的对象归类。通过...
  • [问题背景] 关于KMeans聚类原理的动画...在[Python数据挖掘] sklearn-KMeans聚类一文中,我们调用sklearn库的KMeans聚类方法,成功对以下ANSI编码的grade.txt文本文档数据集进行了聚类: YZN,133,108,76 ZHY,96,...
  • k-means 算法是一种基于划分的聚类算法,它以 k 为参数,把 n 个数据对象分成 k 个簇,使簇内具有较高的相似度,而簇间的相似度较低。1. 基本思想k-means 算法是根据给定的 n 个数据对象的数据集,构建 k 个划分聚类...
  • importjava.util.ArrayList;importjava.util.Random;/*** K均值聚类算法*/public classKmeans {private int numOfCluster;//分成多少簇private int timeOfIteration;...//数据集元素个数,即数据集的长度private ...
  • 导读K-Means聚类算法也称k均值聚类算法,是简单和经典于一身的基于距离的聚类算法。它采用距离作为相似性的评价指标,即认为两个对象的距离越近,其相似度就越大。该算法认为类簇是由距离靠近的对象组成的,因此把...
  • 1、kmeanskmeans, k-均值聚类算法,能够实现发现数据集的 k 个簇的算法,每个簇通过其质心来描述。kmeans步骤:(1)随机找 k 个点作为质心(种子);(2)计算其他点到这 k 个种子的距离,选择最近的那个作为该点的类别;...
  • k-means算法是一种聚类算法,所谓聚类,即根据相似性原则,将具有较高相似度的数据对象划分至同一类簇,将具有较高相异度的数据对象划分至不同类簇。聚类与分类最大的区别在于,聚类过程为无监督过程,即待处理数据...
  • 1. Kmeans聚类算法原理 1.1 概述 K-means算法是简单和经典于一身的基于距离的聚类算法 采用距离作为相似性的评价指标,即认为两个对象的距离越近,其相似度就越大。 该算法认为类簇是由距离靠近的对象组成的,...
  • 包含数据集 0 1 22 9 181 5450 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 8 8 0.00 0.00 0.00 0.00 1.00 0.00 0.00 9 9 1.00 0.00 0.11 0.00 0.00 0.00 0.00 0.00 0 1 22 9 239 486 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 8 8 ...
  • 在进去聚类情况分析前,我们需要为我们的IDLE安装sklearn库,scikit-learn是Python的一个开源机器学习模块,它建立在NumPy,SciPy和matplotlib模块之上能够为用户提供各种机器学习算法接口,可以让用户简单、高效地...
  • kmeans聚类算法(使用西瓜数据集4.0)

    千次阅读 2018-04-26 17:40:00
    计算每个样本的聚类中心并预测聚类索引。 a1= xigua.values print (a1[:,1:3 ]) res = estimator.fit_predict(a1[:,1:3 ]) # 每个点的标签 lable_pred = estimator.labels_ # 每个点的聚类中心 centroids = ...
  • 所谓聚类分析,就是给定一个元素集合D,其中每个元素具有n个观测属性,对这些属性使用某种算法将D划分成K个子,要求每个子集内部的元素之间相似度尽可能高...聚类算法有很多种,如K-means(K均值聚类)、K中心聚类、...
  • 获得数据集anchor box的大小

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 463
精华内容 185
关键字:

kmeans聚类算法数据集