cga.m

遗传算法

%(1)初始化各个参数
function[m_pattern]=CGA(m_pattern,patternNum)
        popSize=200;%种群大小
        %初始化种群体结构
        for i=1:popSize
            m_pop(i).string=zeros(1,patternNum);%个体位串
            m_pop(i).index=-1;%素引
            m_pop(i).value=0;%评估值
            m_pop(i).fitness=0;%适应度
        end
        %初始化全局最优最差个体
        cBest=m_pop(1);%其中cBest的index属性记录最优个体出现在第几代中
        cWorst=m_pop(1);
        pc=0.6;%交叉概率
        pm=0.05;%变异概率
        disType=DisSelDlg();%获得距离计算类型
        [centerNum MaxGeneration]=InputClassDlg();%获得类中心数和最大迭代次数
        
 %(2)群体初始化
    function[m_pop]=GetIniPop(m_pop,popSize,patternNum,centerNum,m_pattern)
        for i=1:popSize
            m_pop(i).string=fix(rand(1,patternNum)*centerNum+ones(1,patternNum));
        end
        
        
 %(3)评价群体
     function [m_pop,cBest,cWorst]=EvaPop(m_pop,popSize,patternNum,centerNum,m_pattern,disType,cBest,cWorst,generation)%对当前群体评估
         m_pop=CalObjValue(m_pop,popSize,patternNum,centerNum,m_pattern,disType);%计算个体的评估值
         m_pop=CalFitnessValue(m_pop,popSize);%计算个体的适应度
         [cBest,cWorst]=FindBW(m_pop,popSize,cBest,cWorst,generation);%寻找最优个体，更新总的最优个体
         
     function [m_pop]=CalObjValue(m_pop,popSize,patternNum,centerNum,m_pattern,disType)
         global Nwidth;
         for i=1:popSize
             for j=1:centerNum%初始化聚类中心
                 m_center(j).index=i;
                 m_center(j).feature=zeros(Nwidth,Nwidth);
                 m_center(j).patternNum=0;
             end
             %计算聚类中心
             for j=1:patternNum
                 m_center(m_pop(i).string(1,j).feature=m_center(m_pop(i).string(1,j)).feature
                 +m_pattern(j).feature;
                 m_center(m_pop(i).string(1,j)).patternNum=m_center(m_pop(i).string(1,j)).patternNum+1;
             end
             d=0;
             for j=1:centerNum
                 if(m_center(j).patternNum~=0)
                     m_center(j).feature=m_center(j).feature/m_center(j).patternNum;
                 else
                     d=d+1;
                 end
             end
             m_pop(i).value=0;
             %计算个体评估值
             for j=1:patternNum
                 m_pop(i).value=m_pop(i).value+GetDistance(m_center(m_pop(i).string(1,j)),m_pattern(j),diType)^2;
             end
             m_pop(i).value=m_pop(i).value+d;
         end
         %计算个体的适应度
         function[m_pop]=CalFitnessValue(m_pop,popSize)
             for i=1:popSize
                 m_pop(i).index=-1;
             end
             %按照value大小排序
             for i=1:popSize
                 index=1;
                 for j=1:popSize
                     if(m_pop(j).value==m_pop(j).value&&m_pop(j).index~=-1&&i~=j)
                     index=index+1;
                     end
                 end
                 m_pop(i).index=index;
             end
             a=0.6;
             for i=1:popSize
                 m_pop(i).fitness=a*(1-a)^(m_pop(i).index-1);
             end
    %寻找最优个体，更新总的最优个体
             function[cBest,cWorst]=FinBW(m_pop,popSize,cBest,cWorst,generation)
                 %初始化局部最优个体
                 best=m_pop(1);
                 worst=m_pop(1);
                 for i=2:popSize
                     if(m_pop(i).value<best.value)
                         best=m_pop(i);
                     else if(m_pop(i).value>worst.value)
                             worst=m_pop(i);
                         end
                     end
                     if(generation==1)
                         cBest=best;
                         cBest.index=1;
                     else
                         if(best.value<cBest.value)
                             cBest=best;
                             cBest.index=generation;
                         end
                     end
%(4)生成下一代群体
         function [m_pop]=GenerateNextPop(m_pop,popSize,patternNum,centerNum,pc,pm)
                         %选择
                         [m_pop]=Selection(m_pop,popSize);
                         %交叉
                         [m_pop]=Crossover(m_pop,popSize,pc,patternNum);
                         %变异
                         [m_pop]=Mutation(m_pop,popSize,pm,patternNum,centerNum);
                         
                         
            %选择操作
           function [m_pop]=Selection(m_pop,popSize)
               cFitness=zeros(1,popSize);
               for i=1:popSize
                   if(i==1)
                       cFitness(i)=m_pop(i).fitness;
                   else
                       cFitness(i)=cFitness(i-1)+m_pop(i).fitness;
                   end
               end
               cFitness=cFitness/cFitness(popSize);
               for i=1:popSize
                   p=rand;
                   index=1;
                   while(cFitness(index)<p)
                     index=index+1;
                   end
                   newPop(i)=m_pop(index);
               end
               m_pop=newPop;
               
              %交叉操作
              function[m_pop]=Crossover(m_pop,popSize,pc,patternNum)
                  crossPop=zeros(1,popSize);
                  index=zeros(1,popSize);
                  for i=1:popSize
                      index(1,i)=i;
                  end
                  remainPop=popSize;
                  %随机选择两个个体
                  for i=1:popSize
                      p=fix(rand*remainPop+1);
                      crossPop(1,i)=index(1,p);
                      if(p~=remainPop)
                          index(1,p)=index(1,remainPop);
                      end
                      remainPop=remainPop-1;
                  end
                  %交叉操作
                  for i=1:popSize/2
                      p=rand;
                      if(p<pc)
                          point=fix(rand*patternNum);%生成随机位
                          for j=point+patternNum %交叉
                              temp=m_pop(2*i-1).string(1,j);
                              m_pop(2*i-1).string(1,j)=m_pop(2*i).string(1,j);
                              m_pop(2*i).string(1,j)=temp;
                          end
                      end
                  end
                  
                  
            %变异操作
                  function [m_pop]=Mutation(m_pop,popSize,pm,patternNum,centerNum)
                      for i=1:popSize
                          for j=1:patternNum
                              p=rand;
                              if(p<pm)
                                  m_pop(i).string(1,j)=fix(rand*centerNum+1);
                              end
                          end
                      end
                      
                      
           %(5)评估子代群体
           EvaPop();
           %(6)保留精英个体
           %(7)判断循环条件
           %(8)获得最优解
           for i=1:patternNum
               m_pattern(i).category=cBest.string(1,i);
           end