isodata.asv

ISODATA算法

%******************************************************************
function Classes=ISODATA(Patterns,c,Nc,Selta_n,Selta_s,Selta_D,L,I)
%@project:ISODATA算法
%@author:fantasy
%@date:2006.5.4

%@parameter:
%    Patterns:输入模式集
%    c:预期类数
%    Nc:初始聚类中心个数
%    Selta_n:每类中允许的最少模式数目
%    Selta_s:类中各分量分布的标准差上限
%    Selta_D:两类中心间的最小距离下限
%    L:在每次迭代中可以合并的类的最多对数
%    I:允许的最多迭代次数

%@return:
%    Classes:输出类集

Dim=size(Patterns,1);%模式维数
N=size(Patterns,2);%总的模式数目

bPartition=0;%分裂条件
bCombine=0;%合并条件

Classes=[];
%初始化聚类
for iPattern=1:Nc
    p=Classf(Patterns(:,iPattern));
    Classes=[Classes,p];
end

iStep=0;%迭代步数
while iStep<I
    %**************************************************************
    %按最小距离原则分类
    for iPattern=1:N
        dMin=getDistance(Classes(1),Patterns(:,iPattern));%最小距离
        iClassMin=1;%最小距离对应之类别
        for iClass=2:length(Classes)
            d=getDistance(Classes(iClass),Patterns(:,iPattern));
            if dMin>d
                dMin=d;
                iClassMin=iClass;
            end
        end
        Classes(iClassMin)=addPattern(Classes(iClassMin),Patterns(:,iPattern));
    end
    %**************************************************************
    
    %**************************************************************
    %依Selta_n判断合并
    for iClass=1:length(Classes)
        if getSize(Classes(iClass))<Selta_n
            Classes(iClass)=[];
            bCombine=1;
            break;
        end
    end
    
    if bCombine==1
        Nc=Nc-1;
        break;
    end
    %**************************************************************

    %计算各类中模式到类心的平均距离
    d=[];
    d_mean=0.0;%总的平均距离
    
    for iClass=1:Nc
        d_mean=getMeanDistance(Classes(iClass));%d_mean当作临时变量
        d=[d,d_mean];
        d_mean=d_mean*getSize(Classes(iClass));
    end
    d_mean=d/N;
    %*************************************************************
    
    %*************************************************************
    if (iStep~=I)&&(Nc<=c/2||(Nc>c/2&&Nc<2*c&&(mod(iStep,2)==0)))
        %**********************************************************
        %分裂处理
        for iClass=1:Nc
            delta=getStdVector(Classes(iClass));
            [delta_max,index]=max(delta);
            if (delta_max>Selta_s)&&((d(iClass)>d_mean&&getSize(Classes(iClass))>2*(Selta_n+1))||Nc<=c/2)
                bPartition=1;
                break;
            end
        end
    end
    
    %分裂
    k=0.5;
    if 1==bPartition
        centerPattern=getCenter(Classes(iClass));
        Classes(iClass)=[];
        Nc=Nc+1;
        centerPatternPlus=centerPattern;
        centerPatternPlus(index)=centerPattern(index)+k*delta_max;
        centerPatternMinus=centerPattern;
        centerPatternMinus(index)=centerPattern(index)-k*delta_max;

        p=Classf(centerPatternPlus);
        Classes=[Classes,p];
        p=Classf(centerPatternMinus);
        Classes=[Classes,p];
        iStep=iStep+1;
        break;
    end
   
    %*************************************************************
    %合并处理
    if iStep==I
        Selta_D=0;
    end
    
    %计算各类对中心间的距离
    d=getDistance(Classes(1),getCenter(Classes(2)));
    i=1;
    j=2;
    for iClass=1:Nc-1
        for jClass=iClass+1:Nc
           d_ij=getDistance(Classes(iClass),getCenter(Classes(jClass)));
           if d>d_ij
              d=d_ij;
              i=iClass;
              j=jClass;
           end
               
        end
    end
    
    %合并
    if d_ij>Selta_D
        iStep=iStep+1;
    end
    
    iCenter=getCenter(Classes(i));
    jCenter=getCenter(Classes(j));
    
    Ni=getSize(Classes(i));
    Nj=getSize(Classes(j));
    
    newCenter=(iCenter*Ni+jCenter*Nj)/(Ni+Nj);
    Classes(i)=[];
    Classes(j)=[];
    p=Classf(newCenter);
    Classes=[Classes,p];
    Nc=Nc-1;
    iStep=iStep+1;       
    
end