精华内容
下载资源
问答
  • KMeans聚类算法聚类算法中最基础最常用、最重要的聚类算法。KMeans聚类算法首先需要确定N个初始中心点,初始中心点的选择对聚类结果影响很大,常用的初始中心点的选择有随机选择、自定义、采用Canopy聚类算法结果...
  • K-means聚类算法和模糊C-means聚类算法

    万次阅读 多人点赞 2018-02-05 21:16:47
    K-means聚类算法和模糊C-means聚类算法 1.K-means聚类算法 K-means算法是硬聚类算法,是典型的基于原型的目标函数聚类方法的代表,它是数据点到原型的某种距离作为优化的目标函数,利用函数求极值的方法得到迭代...

    K-means聚类算法和模糊C-means聚类算法

    1.K-means聚类算法

    K-means算法是硬聚类算法,是典型的基于原型的目标函数聚类方法的代表,它是数据点到原型的某种距离作为优化的目标函数,利用函数求极值的方法得到迭代运算的调整规则。K-means算法以欧式距离作为相似度测度,它是求对应某一初始聚类中心向量V最优分类,使得评价指标J最小。算法采用误差平方和准则函数作为聚类准则函数。

    K-Means聚类算法的优点主要集中在:

    1.算法快速、简单;

    2.对大数据集有较高的效率并且是可伸缩性的;

    3.时间复杂度近于线性,而且适合挖掘大规模数据集。K-Means聚类算法的时间复杂度是O(nkt) ,其中n代表数据集中对象的数量,t代表着算法迭代的次数,k代表着簇的数目。

    K-Means聚类算法的缺点:

    ① 在 K-means 算法中 K 是事先给定的,这个 K 值的选定是非常难以估计的。很多时候,事先并不知道给定的数据集应该分成多少个类别才最合适。这也是 K-means 算法的一个不足。有的算法是通过类的自动合并和分裂,得到较为合理的类型数目 K,例如 ISODATA 算法。关于 K-means 算法中聚类数目K 值的确定在文献中,是根据方差分析理论,应用混合 F统计量来确定最佳分类数,并应用了模糊划分熵来验证最佳分类数的正确性。在文献中,使用了一种结合全协方差矩阵的 RPCL 算法,并逐步删除那些只包含少量训练数据的类。而文献中使用的是一种称为次胜者受罚的竞争学习规则,来自动决定类的适当数目。它的思想是:对每个输入而言,不仅竞争获胜单元的权值被修正以适应输入值,而且对次胜单元采用惩罚的方法使之远离输入值。

     

    ② 在 K-means 算法中,首先需要根据初始聚类中心来确定一个初始划分,然后对初始划分进行优化。这个初始聚类中心的选择对聚类结果有较大的影响,一旦初始值选择的不好,可能无法得到有效的聚类结果,这也成为 K-means算法的一个主要问题。对于该问题的解决,许多算法采用遗传算法(GA),例如文献 中采用遗传算法(GA)进行初始化,以内部聚类准则作为评价指标。

    ③ 从 K-means 算法框架可以看出,该算法需要不断地进行样本分类调整,不断地计算调整后的新的聚类中心,因此当数据量非常大时,算法的时间开销是非常大的。所以需要对算法的时间复杂度进行分析、改进,提高算法应用范围。在文献中从该算法的时间复杂度进行分析考虑,通过一定的相似性准则来去掉聚类中心的侯选集。而在文献中,使用的 K-means 算法是对样本数据进行聚类,无论是初始点的选择还是一次迭代完成时对数据的调整,都是建立在随机选取的样本数据的基础之上,这样可以提高算法的收敛速度。

    下面给出例子,有34个地点的经纬度如下:

     

     

    13.5667000000000	9.63330000000000
    11.7833000000000	11.4833000000000
    14.0167000000000	10.1833000000000
    12.4000000000000	11.0500000000000
    11.1000000000000	10.7167000000000
    10.1167000000000	9.16670000000000
    8.81670000000000	7.73330000000000
    10.1333000000000	8.53330000000000
    9.46670000000000	8.53330000000000
    9.25000000000000	7.55000000000000
    9.88330000000000	10.6333000000000
    9.16670000000000	11.4167000000000
    10.5667000000000	8.26670000000000
    11.1833000000000	7.86670000000000
    10.8833000000000	8.75000000000000
    12.1500000000000	9.23330000000000
    12.9167000000000	9.11670000000000
    12.7833000000000	8.76670000000000
    11.7833000000000	8.73330000000000
    11.7333000000000	7.96670000000000
    12.5000000000000	7.51670000000000
    12.4167000000000	8.15000000000000
    11.6833000000000	7.35000000000000
    6.76830000000000	7.03210000000000
    13.2167000000000	8.46670000000000
    10.8167000000000	6.75000000000000
    9.66670000000000	6.91670000000000
    9.78330000000000	6.20000000000000
    11.0167000000000	7.10000000000000
    10.0667000000000	7.70000000000000
    10.2167000000000	6.50000000000000
    10.5667000000000	6.50000000000000
    8.76670000000000	6.81670000000000
    9.36670000000000	5.86670000000000

    matlab程序如下:

     

     

    % 簇心数目k
    K = 8;
    
    data=jw; % 直接存储到data变量中
    
    x = data(:,1);
    y = data(:,2);
    
    % 绘制数据,2维散点图
    % x,y: 要绘制的数据点  20:散点大小相同,均为20  'blue':散点颜色为蓝色
    s = scatter(x, y, 20, 'blue');
    title('原始数据:蓝圈;初始簇心:红点');
    
    % 初始化簇心
    sample_num = size(data, 1);       % 样本数量
    sample_dimension = size(data, 2); % 每个样本特征维度
    
    % 暂且手动指定簇心初始位置
    % clusters = zeros(K, sample_dimension);
    % clusters(1,:) = [-3,1];
    % clusters(2,:) = [2,4];
    % clusters(3,:) = [-1,-0.5];
    % clusters(4,:) = [2,-3];
    % 簇心赋初值:计算所有数据的均值,并将一些小随机向量加到均值上
    clusters = zeros(K, sample_dimension);
    minVal = min(data); % 各维度计算最小值
    maxVal = max(data); % 各维度计算最大值
    for i=1:K
        clusters(i, :) = minVal + (maxVal - minVal) * rand();
    end 
    
    
    hold on; % 在上次绘图(散点图)基础上,准备下次绘图
    % 绘制初始簇心
    scatter(clusters(:,1), clusters(:,2), 'red', 'filled'); % 实心圆点,表示簇心初始位置
    
    c = zeros(sample_num, 1); % 每个样本所属簇的编号
    
    PRECISION = 0.001;
    
    
    iter = 100; % 假定最多迭代100次
    % Stochastic Gradient Descendant 随机梯度下降(SGD)的K-means,也就是Competitive Learning版本
    basic_eta = 1;  % learning rate
    for i=1:iter
        pre_acc_err = 0;  % 上一次迭代中,累计误差
        acc_err = 0;  % 累计误差
        for j=1:sample_num
            x_j = data(j, :);     % 取得第j个样本数据,这里体现了stochastic性质
    
            % 所有簇心和x计算距离,找到最近的一个(比较簇心到x的模长)
            gg = repmat(x_j, K, 1);
            gg = gg - clusters;
            tt = arrayfun(@(n) norm(gg(n,:)), (1:K)');
            [minVal, minIdx] = min(tt);
    
            % 更新簇心:把最近的簇心(winner)向数据x拉动。 eta为学习率.
            eta = basic_eta/i;
            delta = eta*(x_j-clusters(minIdx,:));
            clusters(minIdx,:) = clusters(minIdx,:) + delta;
            acc_err = acc_err + norm(delta);
            c(j)=minIdx;
        end
        
        if(rem(i,10) ~= 0)
            continue
        end
        figure;
        f = scatter(x, y, 20, 'blue');
        hold on;
        scatter(clusters(:,1), clusters(:,2), 'filled'); % 实心圆点,表示簇心初始位置
        title(['第', num2str(i), '次迭代']);
        if (abs(acc_err-pre_acc_err) < PRECISION)
            disp(['收敛于第', num2str(i), '次迭代']);
            break;
        end
        
        disp(['累计误差:', num2str(abs(acc_err-pre_acc_err))]);
        pre_acc_err = acc_err;
    end
    
    
    disp('done');


    得到前90次迭代的结果如下:

     

    得到的第100次迭代结果为:

    用线条将聚类中心与成员连接起来

    1.模糊C-means聚类算法

    模糊c-均值聚类算法 fuzzy c-means algorithm (FCMA)或称( FCM)。在众多模糊聚类算法中,模糊C-均值( FCM) 算法应用最广泛且较成功,它通过优化目标函数得到每个样本点对所有类中心的隶属度,从而决定样本点的类属以达到自动对样本数据进行分类的目的。

    算法原理

    用法: 
    1. [center,U,obj_fcn] = FCM(Data,N_cluster,options); 
    2. [center,U,obj_fcn] = FCM(Data,N_cluster);

    输入变量 
    data ---- n*m矩阵,表示n个样本,每个样本具有m维特征值 
    cluster_n ---- 标量,表示聚合中心数目,即类别数 
    options ---- 4*1列向量,其中 
    options(1): 隶属度矩阵U的指数,>1(缺省值: 2.0) 
    options(2): 最大迭代次数(缺省值: 100) 
    options(3): 隶属度最小变化量,迭代终止条件(缺省值: 1e-5) 
    options(4): 每次迭代是否输出信息标志(缺省值: 0) 

    输出变量 
    center ---- 聚类中心 
    U ---- 隶属度矩阵 
    obj_fcn ---- 目标函数值 

    编写C-means函数为:

     

    function[center,U,obj_fun]=FCMCluster(data,n,options)
    %采用模糊C均值将数据集data分为n类
    %用法
    % 1 [center,U,obj_fcn]=FCMCluster(data,n,options);
    % 2 [center,U,obj_fcn]=FCMCluster(data,n);
    
    %输入 
    % data    n*m矩阵,n个样本数,每个样本的维度为m
    % n       类别数
    % options 4*1 矩阵
    %   options(1):隶属度矩阵U的加权指数
    %   options(2):最大迭代次数
    %   options(3):隶属度最小变化量,迭代终止条件
    %   options(4):每次迭代是否输出信息标志
    
    %输出
    % center    聚类中心
    % U         隶属度矩阵
    % obj_fun   目标函数值
    
    
    if nargin~=2 && nargin~=3
        error('Too many or too few input arguments');
    end 
    
    data_n=size(data,1);
    in_n=size(data,2);
    
    %默认参数
    default_options=[2;100;1e-5;1];
    
    %参数配置
      %如果只输入前两个参数,选用默认的参数;如果参数个数小于4,其他选用默认参数
      if nargin==2
          options=default_options;
      else
           if length(options)<4
               tmp=default_options;
               tmp(1:length(options))=options;
               options=tmp;
           end 
           nan_index=find(isnan(options)==1);
           options(nan_index)=default_options(nan_index);
    
           if options(1)<=1
               error('The exponent should be greater than 1!');
           end 
      end 
    
      %将options 中的分量分别赋值给四个变量
      expo=options(1);
      max_iter=options(2);
      min_impro=options(3);
      display=options(4);
    
      obj_fun=zeros(max_iter,1);
    
      %初始化模糊分配矩阵
      U=initfcm(n,data_n);
    
    
      %主程序
       for i=1:max_iter
           [U,center,obj_fun(i)]=stepfcm(data,U,n,expo);
           if display
               fprintf('FCM:Iteration count=%d,obj_fun=%f\n',i,obj_fun(i));
           end
           %终止条件判别
           if i>1
               if abs(obj_fun(i)-obj_fun(i-1))<min_impro
                   break;
               end 
           end 
       end
       iter_n=i;
       obj_fun(iter_n+1:max_iter)=[];
    %   
    
    end
    %%子函数 模糊矩阵初始化
        function U= initfcm(n,data_n)
            U=rand(n,data_n);
            col_sum=sum(U);
            U=U./col_sum(ones(n,1),:);
        end
    
    
    %%子函数 逐步聚类
            function [U_new,center,obj_fun]=stepfcm(data,U,n,expo)
                mf=U.^expo;
                center=mf*data./((ones(size(data,2),1)*sum(mf'))');
                dist=distfcm(center,data);
                obj_fun=sum(sum((dist.^2).*mf));
                tmp=dist.^(-2/(expo-1));
                U_new=tmp./(ones(n,1)*sum(tmp));
            end
    
    
    %%子函数 计算距离
                function out=distfcm(center,data)
                    out=zeros(size(center,1),size(data,1));
                    for k=1:size(center,1)
                        out(k,:)=sqrt(sum(((data-ones(size(data,1),1)*center(k,:)).^2)',1));
    
    
                    end 
                end

    脚本函数为:

     

     

    data=jw;
    options = [2;100;1e-5;1]; 
    [center,U,obj_fcn] = FCMCluster(data,8,options); 
    plot(data(:,1),data(:,2),'o'); 
    hold on; 
    index1=find(U(1,:)==max(U));%找出划分为第一类的数据索引 
    index2=find(U(2,:)==max(U));%找出划分为第二类的数据索引 
    index3=find(U(3,:)==max(U));%找出划分为第三类的数据索引 
    index4=find(U(4,:)==max(U));%找出划分为第四类的数据索引 
    index5=find(U(5,:)==max(U));%找出划分为第五类的数据索引 
    index6=find(U(6,:)==max(U));%找出划分为第六类的数据索引 
    index7=find(U(7,:)==max(U));%找出划分为第七类的数据索引 
    index8=find(U(8,:)==max(U));%找出划分为第八类的数据索引 
    plot(data(index1,1),data(index1,2),'g*'); 
    hold on; 
    plot(data(index2,1),data(index2,2),'r*'); 
    hold on; 
    plot(data(index3,1),data(index3,2),'b*'); 
    hold on;
    plot(data(index4,1),data(index4,2),'c*'); 
    hold on;
    plot(data(index5,1),data(index5,2),'m*'); 
    hold on;
    plot(data(index6,1),data(index6,2),'y*'); 
    hold on;
    plot(data(index7,1),data(index7,2),'k*'); 
    hold on;
    plot(data(index8,1),data(index8,2),'w*'); 
    hold on;
    plot([center([1:8],1)],[center([1:8],2)],'p','color','r');
    grid on

    得到的结果如下:

     


    通过结果来看,C-means聚类的结果要好些,最左边的地点并没有单独聚类一个类,在实际情况中运用更加广泛。

    展开全文
  • 是fcm聚类算法,文献,hd不要下载,可以看看,好好看看fcm聚类算法,fcm聚类算法,fcm聚类算法,fcm聚类算法,fcm聚类算法,fcm聚类算法
  • C++均值聚类算法C++均值聚类算法C++均值聚类算法
  • 聚类算法

    2019-12-14 21:14:15
    K-Means聚类算法原理 用scikit-learn学习K-Means聚类 BIRCH聚类算法原理 scikit-learn之BIRCH类 DBSCAN密度聚类算法 用scikit-learn学习DBSCAN聚类 谱聚类(spectral clustering)原理总结 用scikit-learn学习谱...

    kmeans算法过程
    kmeans++与kmeans不同之处在于初值的选择上。
    距离度量方式
    K-Means聚类算法原理
    用scikit-learn学习K-Means聚类
    BIRCH聚类算法原理
    scikit-learn之BIRCH类
    DBSCAN密度聚类算法
    用scikit-learn学习DBSCAN聚类
    谱聚类(spectral clustering)原理总结
    用scikit-learn学习谱聚类

    在这里插入图片描述

    各向异性,马氏距离

    在这里插入图片描述

    初始的簇心相距较远
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    将距离转成概率,以概率选择相应距离的点

    不平衡数据的分类问题:把少类看成噪声,去除噪声

    默认每个类别属于方差相同的高斯分布——>k-means minibatch方法

    在这里插入图片描述
    K值的选择
    在这里插入图片描述
    在这里插入图片描述

    轮廓系数
    在这里插入图片描述
    在这里插入图片描述

    **加粗样式**
    在这里插入图片描述

    层次聚类算法

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 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”即可获取全部资源文件信息。

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

    展开全文
  • 聚类算法 聚类算法

    2012-04-18 22:29:23
    基于同义词词林的聚类改进算法 基于同义词词林的聚类改进算法 k均值聚类算法
  • 图像聚类算法图像聚类算法图像聚类算法图像聚类算法图像聚类算法图像聚类算法
  • 文章目录聚类算法学习目标6.1 聚类算法简介1 认识聚类算法1.1 聚类算法在现实中的应用1.2 聚类算法的概念1.3 聚类算法与分类算法最大的区别 学习目标 掌握聚类算法实现过程 知道K-means算法原理 知道聚类算法中的...

    聚类算法

    学习目标

    • 掌握聚类算法实现过程
    • 知道K-means算法原理
    • 知道聚类算法中的评估模型
    • 说明K-means的优缺点
    • 了解聚类中的算法优化方式
    • 应用Kmeans实现聚类任务
      在这里插入图片描述

    6.1 聚类算法简介

    1 认识聚类算法

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pHCHjOCj-1583250908060)(../images/cluster1.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L5lD7AkJ-1583250908061)(../images/cluster2.png)]

    使用不同的聚类准则,产生的聚类结果不同

    1.1 聚类算法在现实中的应用

    • 用户画像,广告推荐,Data Segmentation,搜索引擎的流量推荐,恶意流量识别
    • 基于位置信息的商业推送,新闻聚类,筛选排序
    • 图像分割,降维,识别;离群点检测;信用卡异常消费;发掘相同功能的基因片段

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kaPEJEf2-1583250908062)(../images/cluster3.png)]

    1.2 聚类算法的概念

    聚类算法

    一种典型的无监督学习算法,主要用于将相似的样本自动归到一个类别中。

    在聚类算法中根据样本之间的相似性,将样本划分到不同的类别中,对于不同的相似度计算方法,会得到不同的聚类结果,常用的相似度计算方法有欧式距离法。

    1.3 聚类算法与分类算法最大的区别

    聚类算法是无监督的学习算法,而分类算法属于监督的学习算法。

    展开全文
  • 各种聚类算法(原理+代码+对比分析)最全总结

    万次阅读 多人点赞 2017-12-14 10:41:20
    二、聚类算法分类 1.基于划分 给定一个有N个元组或者纪录的数据集,分裂法将构造K个分组,每一个分组就代表一个聚类,K<N。 特点:计算量大。很适合发现中小规模的数据库中小规模的数据库中的球状簇。 算法:K-...
  • 5种流行的聚类算法以及它们的优缺点。 本文参考AiTechYun K-MEANS聚类算法 K-Means聚类算法可能是大家最熟悉的聚类算法。它出现在很多介绍性的数据科学和机器学习课程中。在代码中很容易理解和实现!请看下面的...
  • 目录:空间聚类算法及时空聚类算法

    千次阅读 多人点赞 2018-12-17 14:40:02
    1.在本实例中,如果想将代码直接运行需注意以下几点: Python版本3.X(本人使用的是Python 3.6) ...2.空间聚类算法及时空聚类算法目录 (1)Python之向量(Vector)距离矩阵计算 (2)聚类算法之K-means算法 (3...
  • 基于常用聚类算法及聚类融合算法进行了研究。首先阐述了数据挖掘领域的常用聚类算法及特点,接下来对近年来聚类融合的方法和研究现状进行了综述,并对如何产生高效的聚类成员和共识函数如何构建才能产生高效的聚类...
  • 均值漂移聚类算法 聚类算法-均值漂移算法 (Clustering Algorithms - Mean Shift Algorithm) Advertisements 广告 Previous Page 上一页 Next Page 下一页 均值漂移算法简介 (Introduction to Mean-...
  • 本算法是vc 6.0下实现的几种聚类算法,作为大家编程研究有一定帮助,其中isodata算法还有待改善,实现不是很完整
  • 常用的聚类算法类型有:划分方法(k-means),层次方法,基于密度的方法,基于网格的方法。聚类算法选取取决于数据的类型和聚类的目的。二、各类算法基本原理及优缺点(一)划分算法1.算法原理K-means聚类,原理是随...
  • 聚类算法——层次聚类算法

    千次阅读 2018-02-11 15:51:25
    每篇一句: You must strive to find your own voice. Because the longer you wait to begin, the less likely you are to find it at all. –你必须努力去寻找自己的声音,... 层次聚类算法 (Hierarchical Clu

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,230
精华内容 11,692
关键字:

聚类算法