main.m

本程序是基于matlab的时间序列预测模型GP源程序

clear all

x=[1:16];
w = [1 1 1 5 4 24 6 14 33 1 30 22 13 22 77 7];
y = cumsum(w);

% 定义函数、终止符集合
symbols{1} = {'sin','exp','cos','cot','tan','sqrt'};
symbols{2} = {'x'};

% 参数设定
popusize = 10;
maxtreedepth = 7;
opt = [0.8 0.9 0.05 2 1 0.2 30 0.05 0 1];

% 初始化种群
popu = initpop(popusize,maxtreedepth,symbols);

for i = 1:popusize,
  s{i} = tree_stringrc(popu.chrom{i}.tree,1,popu.symbols);  % s中保留初始化生成的种群个体
  obj(i) = objvalue(popu,s{i},x,y);
end

fitness = obj;
best(1) = fitness(1);
for j = 1:popusize,
    if (fitness(j) ~= 0) & (fitness(j)<best),
        best(1) = fitness(j);         % best(1) 得到的是第一代个体中误差平方和最小值，即最优个体
        best_solution{1} = s{j};      % best_solution{1} 第一代个体中最小误差值对应的个体
    end
end

% --------------------------- 第二代开始 -------------------------------------------
ggap = opt(1);
pc = opt(2);
pm = opt(3); 
tsels = opt(4);
rmode = opt(5);

% while best>=1000,  % 终止条件
for ii = 2:3,
    selm = selection(popu,fitness,ggap,pc,pm,tsels);      % 复制
    
    % New generation 新个体的产生
    newix = [];
    nn = 1;
    for i=1:size(selm,1),
        m = selm(i,3);
        %   交叉   *** Crossover ***
        if m==1,
            p1 = selm(i,1);
            p2 = selm(i,2);
            popu.chrom{nn} = popu.chrom{p1};
            popu.fitness(nn) = -1;
            if nn+1<popu.size, 
                popu.chrom{nn+1} = popu.chrom{p2};
                popu.fitness(nn+1) = -1;
            end
            
            % 重组二叉树
            tree1 = popu.chrom{p1}.tree;
            tree2 = popu.chrom{p2}.tree;
            [tree1,tree2] = crossover(tree1,tree2,rmode,popu.symbols); % 交叉运算
            popu2.chrom{nn}.tree = tree1;
            if nn+1<=popu.size,
                popu.chrom{nn+1}.tree = tree2;
            end

            % 存储新的个体
            newix = [newix nn];
            nn = nn+1;
            if nn<=popu.size,
                newix = [newix nn];
                nn = nn+1;
            end
            
        % *** Mutation 变异操作***
        elseif m==2,
            p1 = selm(i,1);
            popu.chrom{nn} = popu.chrom{p1};
            popu.fitness(nn) = -1;
            
            tree1 = popu.chrom{p1}.tree;
            tree1 = mutation(tree1,popu.symbols);
            popu.chrom{nn}.tree = tree1;
            
            % 记录新个体
            newix = [newix nn];
            nn = nn+1;
            % *** 如果不进行交叉和变异那么就直接存储保留 *** 
        else
            p1 = selm(i,1);
            if p1==0,
                popu.chrom{nn} = popu.chrom{1};
                return;
            else
                popu.chrom{nn} = popu.chrom{p1};
                nn = nn+1;
            end
        end
    end

    for l = 1:popusize,
        Z{l} = tree_stringrc(popu.chrom{l}.tree,1,popu.symbols);        %%  s 是输出的字符串型函数
        % 计算第 l 代个体的适应度大小
        obj_value(l) = objvalue(popu,Z{l},x,y);
    end
    
    f = obj_value;
    best(ii) = f(1); 
    for jj = 1:popusize,
        if (f(jj) ~= 0) & (f(jj)<best),
            best(ii) = f(jj);                % best(ii) 得到的是第 ii 代个体中误差平方和最小值，即最优个体
            best_solution{ii} = s{jj};       % best_solution{ii} 第 ii 代个体中最小误差值对应的个体
        end
    end
    % 适应值计算结束
    popu.generation = popu.generation+1;
end

% 计算得出最终的最优个体值
fit_result = best(1);
for n = 1:length(best),
    if (best(n)~= 0) & (best(n)<fit_result),
        fit_result = best(n);
        best_population = best_solution{n};
    end
end
return