zoukankan      html  css  js  c++  java
  • 数据挖掘之clara算法原理及实例(代码中有bug)

    继上两篇文章介绍聚类中基于划分思想的k-means算法和k-mediod算法

    本文将继续介绍第二种基于划分思想的k-mediod算法-----clara算法





    clara算法能够说是对k-mediod算法的一种改进,就如同k-mediod算法对

    k-means算法的改进一样.clara(clustering large application)算法是应用

    大规模数据的聚类.而其核心算法还是利用k-mediod算法.仅仅是这样的算法

    弥补了k-mediod算法仅仅能应用于小规模数据的缺陷.






    clara算法的核心是,先对大规模数据进行多次採样,每次採样样本进行med-diod

    聚类,然后将多次採样的样本聚类中心进行比較,选出最优的聚类中心.

    当然clara算法也有一定的缺陷,由于它依赖于抽样次数,每次样本数据

    是否均匀分布,以及抽样样本的大小.虽然这样,clara算法还是为我们

    提供了一种进行大规模数据聚类的方法.






    clara算法的详细描写叙述例如以下:

    1.对大规模数据进行多次採样得到採样样本


    2.对每次採样的样本进行k-mediod聚类,得到多组聚类中心


    3.求出每组聚类中心到其它全部点距离和.


    4.找出这几组距离和的最小值.距离和最小的那组就是最优的聚类中心.


    5.然后将大规模数据依照距离聚类到这组最优聚类中心



    matlab仿真代码例如以下:

    clc;
    clear;
    
    load Data3.mat;
    
    k=3; %给定的类别数目
    
    time=5;%time为抽样的次数
    number=30;%number为抽样本个数
    for T=1:time
        ClomStaticSample=zeros(1,number);
        ClomStaticSample=randsample(ClomStatic,number);   %ClomStaticSample就是样本数据
                                                          %接下来对样本数据使用kmediod算法进行聚类
                                                          
        %产生三个随机整数,随机聚类中心
        p=randperm(number);
        Temp=p(1:k);
        Center=zeros(1,k);
        for j=1:k
            Center(j)=ClomStaticSample(Temp(j));
        end
        [ClomStaticSample]=sort(ClomStaticSample);
        
        TempDistance=zeros(number,3);           %暂存差值
        
         while 1
            Circulm=1;                          %循环控制
    
            p1=1;
            p2=1;
            p3=1;
    
            if(Circulm~=1)
                clear Group1 Group2 Group3;   
            end
            for i=1:number
                for j=1:3
                    TempDistance(i,j)=abs(ClomStaticSample(i)-Center(j));
                end
                [RowMin RowIndex]=min(TempDistance(i,:));
                if(RowIndex(1)==1)
                    Group1(p1)=ClomStaticSample(i);
                    p1=p1+1;
                elseif(RowIndex(1)==2)
                    Group2(p2)=ClomStaticSample(i);
                    p2=p2+1;
                elseif(RowIndex(1)==3)
                    Group3(p3)=ClomStaticSample(i);
                    p3=p3+1;
                end
            end
    
                len1=length(Group1);
                len2=length(Group2);
                len3=length(Group3);
                
    
                      %分别计算每一个类中除开类中心的点到其它全部点的距离和E,E最小时为该类新的聚类中心.
                      E=zeros(1,len1-1);
                      q1=1;
                      for j=1:len1
                          for i=1:number
                            if(Group1(j)~=Center(1)&&i~=j)
                                E(q1)=floor(abs(Group1(j)-ClomStaticSample(i)));
                                q1=q1+1;
                            end
                          end
                      end
                      NewCenter(1)=min(E);
    
                     E=zeros(1,len2-1);
                      q2=1;
                      for j=1:len2
                          for i=1:number
                            if(Group2(j)~=Center(2)&&i~=j)
                                E(q2)=floor(abs(Group2(j)-ClomStaticSample(i)));
                                q2=q2+1;
                            end
                          end
                      end
                      NewCenter(2)=min(E);
    
                      E=zeros(1,len3-1);
                      q3=1;
                      for j=1:len3
                          for i=1:number
                            if(Group3(j)~=Center(3)&&i~=j)
                                E(q3)=floor(abs(Group3(j)-ClomStaticSample(i)));
                                q3=q3+1;
                            end
                          end
                      end
                      NewCenter(3)=min(E);
    
                %推断新的类和旧类的聚类中心是否不同,不同则继续聚类,否则聚类结束
                JudgeEqual=zeros(1,k);
                for i=1:k
                    JudgeEqual=(NewCenter==Center);
                end
    
                S=0;
                for i=1:k
                    if(JudgeEqual(i)==1)
                        S=S+1;
                    end
                end
    
                if(S==3)
                    break;
                end
    
                Circulm=Circulm+1;
         end
         CenterSum5=zeros(time,k);           %保存每次抽样后kmediod聚类中心的结果值.
         CenterSum5(i,1)=Center(1);
         CenterSum5(i,2)=Center(2);
         CenterSum5(i,3)=Center(3);
    end
    
    
    %计算每次聚类中心点到其它全部点的距离和的最小值即为最优聚类中心
    Sum=zeros(1,time);
    for i=1:time
        for j=1:k
            for r=1:number-1
                if( CenterSum5(i,j)~=ClomStaticSample(r))
                Sum(i)=Sum(i)+CenterSum5(i,j)-ClomStaticSample(r);
                end
            end
        end
    end
    
    [SumOrder CenterEnd]=sort(Sum);%最优聚类中心即为Center(CenterEnd);
    
    
    %对大数据进行终于的聚类(依照选择出来的最优聚类中心)
            q1=1;
            q2=1;
            q3=1;
            for i=1:length(ClomStatic)
                for j=1:3
                    EndTempDistance(i,j)=abs(ClomStatic(i)-CenterSum5(CenterEnd,j));
                end
                [RowMin RowIndex]=min(EndTempDistance(i,:));
                if(RowIndex(1)==1)
                    EndGroup1(q1)=ClomStatic(i);
                    q1=q1+1;
                elseif(RowIndex(1)==2)
                    EndGroup2(q2)=ClomStatic(i);
                    q2=q2+1;
                elseif(RowIndex(1)==3)
                    EndGroup3(q3)=ClomStatic(i);
                    q3=q3+1;
                end
            end




    转载请注明文章作者:小刘

  • 相关阅读:
    python 并发编程 多线程 event
    python 并发编程 多线程 定时器
    python 并发编程 多线程 信号量
    linux top 查看CPU命令
    python 并发编程 多线程 GIL与多线程
    python 并发编程 多线程 死锁现象与递归锁
    python 并发编程 多线程 GIL与Lock
    python GIL全局解释器锁与互斥锁 目录
    python 并发编程 多线程 GIL全局解释器锁基本概念
    执行python程序 出现三部曲
  • 原文地址:https://www.cnblogs.com/hrhguanli/p/4494917.html
Copyright © 2011-2022 走看看