自适应遗传算法代码

合集下载

基于遗传算法的BP神经网络MATLAB代码

基于遗传算法的BP神经网络MATLAB代码以下是基于遗传算法的BP神经网络的MATLAB代码，包括网络初始化、适应度计算、交叉运算、突变操作和迭代训练等。

1.网络初始化:```matlabfunction net = initialize_network(input_size, hidden_size, output_size)net.input_size = input_size;net.hidden_size = hidden_size;net.output_size = output_size;net.hidden_weights = rand(hidden_size, input_size);net.output_weights = rand(output_size, hidden_size);net.hidden_biases = rand(hidden_size, 1);net.output_biases = rand(output_size, 1);end```2.适应度计算:```matlabfunction fitness = calculate_fitness(net, data, labels)output = forward_propagation(net, data);fitness = sum(sum(abs(output - labels)));end```3.前向传播:```matlabfunction output = forward_propagation(net, data)hidden_input = net.hidden_weights * data + net.hidden_biases;hidden_output = sigmoid(hidden_input);output_input = net.output_weights * hidden_output +net.output_biases;output = sigmoid(output_input);endfunction result = sigmoid(x)result = 1 ./ (1 + exp(-x));end```4.交叉运算:```matlabfunction offspring = crossover(parent1, parent2)point = randi([1 numel(parent1)]);offspring = [parent1(1:point) parent2((point + 1):end)]; end```5.突变操作:```matlabfunction mutated = mutation(individual, mutation_rate) for i = 1:numel(individual)if rand < mutation_ratemutated(i) = rand;elsemutated(i) = individual(i);endendend```6.迭代训练:```matlabfunction [best_individual, best_fitness] =train_network(data, labels, population_size, generations, mutation_rate)input_size = size(data, 1);hidden_size = round((input_size + size(labels, 1)) / 2);output_size = size(labels, 1);population = cell(population_size, 1);for i = 1:population_sizepopulation{i} = initialize_network(input_size, hidden_size, output_size);endbest_individual = population{1};best_fitness = calculate_fitness(best_individual, data, labels);for i = 1:generationsfor j = 1:population_sizefitness = calculate_fitness(population{j}, data, labels);if fitness < best_fitnessbest_individual = population{j};best_fitness = fitness;endendselected = selection(population, data, labels);for j = 1:population_sizeparent1 = selected{randi([1 numel(selected)])};parent2 = selected{randi([1 numel(selected)])};offspring = crossover(parent1, parent2);mutated_offspring = mutation(offspring, mutation_rate);population{j} = mutated_offspring;endendendfunction selected = selection(population, data, labels) fitnesses = zeros(length(population), 1);for i = 1:length(population)fitnesses(i) = calculate_fitness(population{i}, data, labels);end[~, indices] = sort(fitnesses);selected = population(indices(1:floor(length(population) / 2)));end```这是一个基于遗传算法的简化版BP神经网络的MATLAB代码，使用该代码可以初始化神经网络并进行迭代训练，以获得最佳适应度的网络参数。

(完整版)遗传算法c语言代码

break;
}
}
}
//拷贝种群
for(i=0;i<num;i++)
{
grouptemp[i].adapt=group[i].adapt;
grouptemp[i].p=group[i].p;
for(j=0;j<cities;j++)
grouptemp[i].city[j]=group[i].city[j];
{
group[i].p=1-(double)group[i].adapt/(double)biggestsum;
biggestp+=group[i].p;
}
for(i=0;i<num;i++)
group[i].p=group[i].p/biggestp;
//求最佳路劲
bestsolution=0;
for(i=0;i<num;i++)
printf("\n******************是否想再一次计算(y or n)***********************\n");
fflush(stdin);
scanf("%c",&choice);
}while(choice=='y');
return 0;
}
遗传算法代码
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>
#define cities 10 //城市的个数

变异概率自适应调整的遗传算法GA程序

变异概率自适应调整的遗传算法算例一：优化函数：()()*sin 10*2,[1,2]f x x x x =+∈-+A.变异概率自适应调整公式：B.遗传算法参数（1）种群规模设为80，遗传算子分别为轮盘法选择，多点点交叉和多点自适应变异；（2）交叉概率0.7，变异概率0.01；（3）最大进化代数为100代，保优操作。

C.程序框图图 1 程序流程框图()()12max 1max 1,,m m m avg avg m m avg P P f f P f f f f P P f f --⎧-≥⎪-=⎨⎪<⎩ 开始确定实际问题参数对参数集进行编码初始化群体P(t) 群体P(t+1)（更新）位串解码得参数计算目标函数值函数值向适应值映射适应值调整选择、交叉、自适应变异群体评价遗传操作满足停止准则结束二：程序及运行结果（1）%变异概率自适应调整的GA程序%优化函数为f=x*sin(10*x)+2，其中，-1=<x<=2%编码长度为12位%种群规模设为80，遗传算子分别为轮盘法选择，多点点交叉和多点自适应变异。

%交叉概率0.7，变异概率0.01%最大进化代数为100代，保优操作。

%**********************%主函数*****************************************function main()global chrom lchrom oldpop newpop varible fitness popsize sumfitness %定义全局变量global pcross pmutation temp bestfit maxfit gen bestgenglobal maxgen po pp mp nplchrom=12; %染色体长度popsize=80; %种群大小pcross=0.7; %交叉概率pmutation=0.01; %变异概率maxgen=100; %最大代数po=0.1; %淘汰概率pp=0.1; %保护概率mp=floor(pp*popsize); %保护的个数np=floor(po*popsize); %淘汰的个数initpop; % 初始化种群for gen=1:maxgenobjfun; %计算适应度值pp_po; %执行保优操作select; %选择操作selfmutation; %自变异操作crossover; %交叉操作endbestbestfit % 最佳个体适应度值输出bestgen % 最佳个体所在代数输出figuregen=1:maxgen;plot(gen,maxfit(1,gen)); % 进化曲线hold on;plot(bestgen,bestfit);xlabel('Generation');ylabel('Fitness');%********************** 产生初始种群 ************************************ function initpop()global lchrom oldpop popsize chromfor i=1:popsizechrom=rand(1,lchrom); % lchrom=12 染色体长度for j=1:lchromif chrom(1,j)<0.5chrom(1,j)=0;elsechrom(1,j)=1;endendoldpop(i,1:lchrom)=chrom;end%************************%计算适应度值************************************ function objfun()global lchrom oldpop fitness popsize chrom maxfit gen varible avgfiness savgfitness % a=0;b=3;a=0;b=10;for i=1:popsizechrom=oldpop(i,:);c=decimal(chrom);varible(1,i)=a+c*(b-a)/(2.^lchrom-1); %对应变量值fitness(1,i)=varible(1,i)*sin(10*varible(1,i))+2;avgfitness=sum(fitness)/popsize;lsort; % 个体排序maxfit(1,gen)=max(fitness); %求本代中的最大适应度值maxfit%************************二进制转十进制********************************** function c=decimal(chrom)global lchrom popsizec=0;for j=1:lchromc=c+chrom(1,j)*2.^(lchrom-j);end%************************* 个体从小到大排序 ************************ function lsort()global popsize fitness oldpopfor i=1:popsizej=i+1;while j<=popsizeif fitness(1,i)>fitness(1,j)tf=fitness(1,i); % 适应度值tc=oldpop(i,:); % 基因代码fitness(1,i)=fitness(1,j); % 适应度值互换oldpop(i,:)=oldpop(j,:); % 基因代码互换fitnescs(1,j)=tf;oldpop(j,:)=tc;endj=j+1;endend%*************************保优操作*****************************function pp_po()global popsize oldpop npi=np+1; % np=floor(po*popsize); %淘汰的个数npwhile i<=popsize %将（np+1）～popsize的个体放在toldpop中，共（popsize-np）个 toldpop(j,:)=oldpop(i,:);j=j+1;i=i+1;endfor i=1:(popsize-np) %从小到大顺序排列，将前面np个淘汰oldpop(i,:)=toldpop(i,:); % 适应度是否也要互换？end%*************************转轮法选择操作********************************** function select()global fitness popsize sumfitness oldpop temp mp npsumfitness=0; %个体适应度之和for i=1:(popsize-np-mp) % 仅计算(popsize-np-mp)个个体的选择概率sumfitness=sumfitness+fitness(1,i);endfor i=1:(popsize-mp-np) % 仅计算(popsize-np-mp)个个体的选择概率p(1,i)=fitness(1,i)/sumfitness; % 个体染色体的选择概率endq=cumsum(p); % 个体染色体的累积概率（内部函数），共(popsize-np-mp)个b=sort(rand(1,(popsize-mp))); % 产生(popsize-mp)个随机数，并按升序排列。

遗传算法MATLAB完整代码（不用工具箱）

遗传算法MATLAB完整代码（不用工具箱）遗传算法解决简单问题%主程序：用遗传算法求解y=200*exp(-0.05*x).*sin(x)在区间[-2,2]上的最大值clc;clear all;close all;global BitLengthglobal boundsbeginglobal boundsendbounds=[-2,2];precision=0.0001;boundsbegin=bounds(:,1);boundsend=bounds(:,2);%计算如果满足求解精度至少需要多长的染色体BitLength=ceil(log2((boundsend-boundsbegin)'./precision));popsize=50; %初始种群大小Generationmax=12; %最大代数pcrossover=0.90; %交配概率pmutation=0.09; %变异概率%产生初始种群population=round(rand(popsize,BitLength));%计算适应度，返回适应度Fitvalue和累计概率cumsump[Fitvalue,cumsump]=fitnessfun(population);Generation=1;while Generation<generationmax+1< p="">for j=1:2:popsize%选择操作seln=selection(population,cumsump);%交叉操作scro=crossover(population,seln,pcrossover);scnew(j,:)=scro(1,:);scnew(j+1,:)=scro(2,:);%变异操作smnew(j,:)=mutation(scnew(j,:),pmutation);smnew(j+1,:)=mutation(scnew(j+1,:),pmutation);endpopulation=scnew; %产生了新的种群%计算新种群的适应度[Fitvalue,cumsump]=fitnessfun(population);%记录当前代最好的适应度和平均适应度[fmax,nmax]=max(Fitvalue);fmean=mean(Fitvalue);ymax(Generation)=fmax;ymean(Generation)=fmean;%记录当前代的最佳染色体个体x=transform2to10(population(nmax,:));%自变量取值范围是[-2,2],需要把经过遗传运算的最佳染色体整合到[-2,2]区间xx=boundsbegin+x*(boundsend-boundsbegin)/(power((boundsend),BitLength)-1);xmax(Generation)=xx;Generation=Generation+1;endGeneration=Generation-1;Bestpopulation=xx;Besttargetfunvalue=targetfun(xx);%绘制经过遗传运算后的适应度曲线。

遗传算法matlab程序代码

遗传算法matlab程序代码遗传算法是一种优化算法，用于在给定的搜索空间中寻找最优解。

在Matlab中，可以通过以下代码编写一个基本的遗传算法：% 初始种群大小Npop = 100;% 搜索空间维度ndim = 2;% 最大迭代次数imax = 100;% 初始化种群pop = rand(Npop, ndim);% 最小化目标函数fun = @(x) sum(x.^2);for i = 1:imax% 计算适应度函数fit = 1./fun(pop);% 选择操作[fitSort, fitIndex] = sort(fit, 'descend');pop = pop(fitIndex(1:Npop), :);% 染色体交叉操作popNew = zeros(Npop, ndim);for j = 1:Npopparent1Index = randi([1, Npop]);parent2Index = randi([1, Npop]);parent1 = pop(parent1Index, :);parent2 = pop(parent2Index, :);crossIndex = randi([1, ndim-1]);popNew(j,:) = [parent1(1:crossIndex),parent2(crossIndex+1:end)];end% 染色体突变操作for j = 1:NpopmutIndex = randi([1, ndim]);mutScale = randn();popNew(j, mutIndex) = popNew(j, mutIndex) + mutScale;end% 更新种群pop = [pop; popNew];end% 返回最优解[resultFit, resultIndex] = max(fit);result = pop(resultIndex, :);以上代码实现了一个简单的遗传算法，用于最小化目标函数x1^2 + x2^2。

基于实数编码的参数自适应遗传算法（matlab代码）

基于实数编码的参数⾃适应遗传算法（matlab代码）实数编码的遗传算法寻优：遗传算法的基本操作算⼦：（1）选择算⼦选择算⼦的作⽤主要是避免优良基因的丢失，使得性能⾼的个体能以更⼤的概率被选中，有机会作为⽗代繁殖下⼀代，从⽽提⾼遗传算法的全局收敛性及计算效率。

常见的选择算⼦包括轮盘赌选择法、随机遍历抽样法、局部选择法及锦标赛选择法等。

选择算⼦采⽤轮盘赌；（2）交叉算⼦在遗传算法中，交叉算⼦是区别于其它优化算法的本质特征，⽤于组合新的个体在解空间中快速有效地进⾏搜索，同时也降低了对有效模式的破坏程度，起到全局搜索寻优的效果。

交叉算⼦直接影响着遗传算法的最终搜索效果，⼀定程度上决定了其发展前景。

其中alpha为参数，0<alpha<1(3)变异算⼦群体基因的多样性是保证遗传算法寻找到全局最优解的前提条件，然⽽在进化过程中，遗传选择操作削弱了群体的多样性，上述交叉算⼦只有满⾜⼀定的条件才能保持群体的多样性，⽽变异操作则是保持群体多样性的有效算⼦，所以变异操作算⼦的选取也是必不可少的。

变异尺度⾃适应变化的变异算⼦在进化初期采⽤较⼤的变异尺度来保持群体的多样性，⽽在后期变异尺度将逐渐缩⼩以提⾼局部微调能⼒。

本⽂在此基础上做些改进，改进后的变异算⼦具有原有算⼦的优点，且操作上⽐原有算⼦简单⽅便，有效地加快遗传算法的收敛速度，具体如下：可以看出s(t) 决定了变异空间的⼤⼩，在迭代的初期，变异空间较⼤，在迭代的后期，变异空间缩⼩，算法的局部寻优能⼒变强。

变异算⼦参考⽂献: [1] 管⼩艳. 实数编码下遗传算法的改进及其应⽤[D].重庆⼤学,2012.参数⾃适应：交叉概率Pc和变异概率Pm是遗传算法的两个重要的参数，这两个参数决定了每个个体进⾏交叉或者变异操作的概率。

⾃适应算⼦参考⽂献：[2] M. Srinivas and L. M. Patnaik, "Adaptive probabilities of crossover and mutation in genetic algorithms," in IEEE Transactions on Systems, Man, and Cybernetics, vol. 24, no. 4, pp. 656-667, April 1994.doi: 10.1109/21.286385上述部分翻译⾃⽂献[2]按照论⽂描述，对算法的复现如下：% 测试函数图像% 测试函数图像% 改进的⾃适应遗传算法：% 参考⽂献：[7] M. Srinivas and L. M. Patnaik, "Adaptive probabilities of crossover and mutation in genetic algorithms,"% in IEEE Transactions on Systems, Man, and Cybernetics, vol. 24, no. 4, pp. 656-667, April 1994.% doi: 10.1109/21.286385clc;clear all;mode = 'Schaffer';% mode = 'self_define';if strcmp(mode, 'Schaffer')figure(1)x = -4:0.1:4;y = -4:0.1:4;[X,Y] = meshgrid(x,y);% Z = 3*cos(X.*Y)+X+Y.^2;Z = 0.5-((sin(sqrt(X.^2+Y.^2)).^2)-0.5)./(1+0.001.*(X.^2+Y.^2)).^2; surf(X,Y,Z);title('Schaffer Function');xlabel('X-轴');ylabel('Y-轴');zlabel('Z-轴');figure(2);contour(X, Y, Z, 8);title('Schaffer函数等⾼线');xlabel('X-轴');ylabel('Y-轴');endif strcmp(mode, 'self_define')figure(1);x = -4:0.1:4;y = -4:0.1:4;[X,Y] = meshgrid(x,y);% Z = 100.*(Y-X.^2).^2+(1-X).^2;Z = (cos(X.^2+Y.^2)-0.1)./(1+0.3*(X.^2+Y.^2).^2)+3;surf(X,Y,Z);%title('Rosen Brock valley Function');title('Self define Function');xlabel('X-轴');ylabel('Y-轴');zlabel('Z-轴');endclc;clearvars -except mode;r = 0.2;b = 3;NP=400;% Pc=0.65; % 将Pc,Pm参数改进为⾃适应参数% Pm=0.20;G=520; % 记得改D=2; % 变量个数k1 = 1;k3 = 1;k2 = 0.5;k4 = 0.5;X_min=-4;X_max=4;Y_min=-4;Y_max=4;% optimization_trace = []; % 三维数组, ⾏，列，叶for count_1=1:NP % 产⽣初始解temp1 = X_min+rand()*(X_max-X_min);temp2 = Y_min+rand()*(Y_max-Y_min);x(count_1,:) = [temp1,temp2];endsave_pic_cnt = 1;A = figure(3);for gen=1:G%pause(0.2);if rem(gen, 100)==1scatter(x(:,1), x(:, 2));axis([-4, 4, -4, 4]);title(['第', num2str(gen), '次迭代']);xlabel('变量X');ylabel('变量Y');base_path = 'C:\Users\18811\Desktop\graph\';cnt = num2str(save_pic_cnt);tail_path = '.jpg';frame = getframe(A);im=frame2im(frame);path_img = [base_path, cnt, tail_path];% imwrite(im, path_img);% save_x(:, :, save_pic_cnt) = x;save_pic_cnt = save_pic_cnt + 1;% scatter(0, 0, 'o', 'r');for count_2=1:NPfitness(count_2)=func(x(count_2,:), mode);end%[fitness_min,index0] = min(fitness);%fitness_max = max(fitness);[fitness_max,index0] = max(fitness);fitness_average = sum(fitness)/(length(fitness)); % 种群的平均值collect_fit_average(gen) = fitness_average; % 保存适应度的平均值collect_fitmax_subtract_fit_average(gen) = fitness_max - fitness_average; % 保存f_max-f_average ;fitness_min = min(fitness);best_indiv = x(index0,:); % 最优的个体% optimization_trace(gen,: , global_count) = best_indiv;% best_solution(gen) = fitness_min;best_solution(gen) = fitness_max;% 计算归⼀化的适应度值fitness = (fitness - fitness_min)/(fitness_max - fitness_min);fitness_sum = sum(fitness);fitness = fitness./fitness_sum;fitness = cumsum(fitness);% 选择算⼦：ms = sort(rand(NP,1));fiti = 1;newi = 1;while newi<=NPif ms(newi)<fitness(fiti)clone_x(newi,:) = x(newi,:);newi = newi + 1;elsefiti = fiti + 1;endendclone_x = clone_x(1:NP, :);% 进⾏交叉，变异操作% count=0;for count=1:2:NP% ⾃适应计算Pc.% 选区两个交叉的个体的较⼤的适应度值if fitness(count)>=fitness(count+1)fitness_selected = fitness(count);elsefitness_selected = fitness(count+1);end% 计算Pcif fitness_selected >= fitness_averagePc = k1*(fitness_max-fitness_selected)/(fitness_max-fitness_average);elsePc = k3;endcollect_Pc(gen, count) = Pc; % 保存Pc的值temp_cross = rand();if temp_cross < Pc% 交叉算⼦注：这种交叉算⼦效果更好temp_alpha = 0.6;cross_x(count,:) = temp_alpha*clone_x(count,:)+(1-temp_alpha)*clone_x(count+1,:);cross_x(count+1,:) = temp_alpha*clone_x(count+1,:)+(1-temp_alpha)*clone_x(count,:);% 改进的交叉算⼦参考⽂献：管⼩艳. 实数编码下遗传算法的改进及其应⽤[D].重庆⼤学,2012. 注：但这种交叉算⼦实际的效果不理想% temp_gama = rand();% temp_alpha = 0.98;% cross_x(count,:) = temp_alpha*clone_x(count,:)+(1-temp_alpha)*clone_x(count+1,:)+temp_gama*(clone_x(count,:)-clone_x(count+1,:)); % cross_x(count+1,:) = temp_alpha*clone_x(count+1,:)+(1-temp_alpha)*clone_x(count,:)+temp_gama*(clone_x(count,:)-clone_x(count+1,:)); elsecross_x(count,:)=clone_x(count,:);cross_x(count+1,:)=clone_x(count+1,:);end% 边界条件检查if cross_x(count,1)>X_max || cross_x(count,1)<X_min || cross_x(count,2)>Y_max || cross_x(count,2)<Y_mintemp1 = X_min+rand()*(X_max-X_min);temp2 = Y_min+rand()*(Y_max-Y_min);cross_x(count,:) = [temp1,temp2];endendcross_x = cross_x(1:NP,:);% cross_x为完成交叉的个体；% 变异操作for count=1:1:NP% 计算Pmif fitness(count)>=fitness_averagePm = k2*(fitness_max-fitness(count))/(fitness_max-fitness_average);elsePm = k4;collect_Pm(gen,count) = Pm; % 保存Pm的值temp_mutation=rand();if temp_mutation<Pm%mutation_x(count,:) = (1+0.01).*cross_x(count,:); %这种变异算⼦效果不理想% 变异算⼦参考⽂献：管⼩艳. 实数编码下遗传算法的改进及其应⽤[D].重庆⼤学,2012mutation_pos = randi(D);if mutation_pos==1low = X_min;high = X_max;elselow = Y_min;high = Y_max;ends_t(gen) = 1-r^((1-gen/G)^b);new_low = cross_x(count, mutation_pos)-s_t(gen)*(cross_x(count, mutation_pos)-low);new_high = cross_x(count, mutation_pos)+s_t(gen)*(high-cross_x(count, mutation_pos));mutation_x(count, :) = cross_x(count, :);mutation_x(count, mutation_pos) = new_low+rand()*(new_high-new_low);if mutation_x(count,1)>X_max || mutation_x(count,1)<X_min || mutation_x(count,2)>Y_max || mutation_x(count,2)<Y_min temp1 = X_min+rand()*(X_max-X_min);temp2 = Y_min+rand()*(Y_max-Y_min);mutation_x(count,:) = [temp1,temp2];endelsemutation_x(count,:) = cross_x(count,:);endend%边界条件处理x=mutation_x(1:NP, :);x(1,:)= best_indiv;end%% 作图figure(4)plot(best_solution);%hold on;xlabel('进化代数');ylabel('适应度值');title('适应度进化曲线');figure(5);plot(collect_fitmax_subtract_fit_average);title('f_{max}-f_{average}曲线');xlabel('进化代数');ylabel('f_{max}-f_{average}');% function f=func(buf)% f=0.5-((sin(sqrt(buf(1).^2+buf(2).^2)).^2)-0.5)./(1+0.001.*(buf(1).^2+buf(2).^2)).^2;% endfunction f=func(buf, md)if strcmp(md, 'Schaffer')f=0.5-((sin(sqrt(buf(1).^2+buf(2).^2)).^2)-0.5)./(1+0.001.*(buf(1).^2+buf(2).^2)).^2;endif strcmp(md,'self_define')% f = 100*(buf(2)-buf(1).^2).^2+(1-buf(1)).^2;f = (cos(buf(1).^2+buf(2).^2)-0.1)./(1+0.3*(buf(1).^2+buf(2).^2).^2)+3;endend测试函数：Schaffer函数：运⾏结果：种群的分布变化：-----------------------------------------------------分割线----------------------------------------------------2019/4/2 上⾯的代码有两个地⽅写错了，现在已经改正：1. ⽤于轮盘赌的fitness应该与⽤于计算⾃适应参数的fitness分开2.对轮盘赌选择算⼦进⾏修改修改后的代码:% 测试函数图像% 测试函数图像% 改进的⾃适应遗传算法：% 参考⽂献：[7] M. Srinivas and L. M. Patnaik, "Adaptive probabilities of crossover and mutation in genetic algorithms," % in IEEE Transactions on Systems, Man, and Cybernetics, vol. 24, no. 4, pp. 656-667, April 1994.% doi: 10.1109/21.286385clc;clear all;mode = 'Schaffer';% mode = 'self_define';if strcmp(mode, 'Schaffer')figure(1)x = -4:0.1:4;y = -4:0.1:4;[X,Y] = meshgrid(x,y);% Z = 3*cos(X.*Y)+X+Y.^2;Z = 0.5-((sin(sqrt(X.^2+Y.^2)).^2)-0.5)./(1+0.001.*(X.^2+Y.^2)).^2;surf(X,Y,Z);title('Schaffer Function');xlabel('X-轴');ylabel('Y-轴');zlabel('Z-轴');figure(2);contour(X, Y, Z, 8);title('Schaffer函数等⾼线');xlabel('X-轴');ylabel('Y-轴');endif strcmp(mode, 'self_define')figure(1);x = -4:0.1:4;y = -4:0.1:4;[X,Y] = meshgrid(x,y);% Z = 100.*(Y-X.^2).^2+(1-X).^2;Z = (cos(X.^2+Y.^2)-0.1)./(1+0.3*(X.^2+Y.^2).^2)+3;surf(X,Y,Z);%title('Rosen Brock valley Function');title('Self define Function');xlabel('X-轴');ylabel('Y-轴');zlabel('Z-轴');endclc;clearvars -except mode;r = 0.2;b = 3;NP=100;% Pc=0.65; % 将Pc,Pm参数改进为⾃适应参数% Pm=0.20;G=100; % 记得改D=2; % 变量个数k1 = 1;k3 = 1;k2 = 0.5;k4 = 0.5;X_min=-4;X_max=4;Y_min=-4;Y_max=4;% optimization_trace = []; % 三维数组, ⾏，列，叶for count_1=1:NP % 产⽣初始解temp1 = X_min+rand()*(X_max-X_min);temp2 = Y_min+rand()*(Y_max-Y_min);x(count_1,:) = [temp1,temp2];endsave_pic_cnt = 1;A = figure(3);for gen=1:Gpause(0.2);if rem(gen, 2)==1scatter(x(:,1), x(:, 2));axis([-4, 4, -4, 4]);title(['第', num2str(gen), '次迭代']);xlabel('变量X');ylabel('变量Y');base_path = 'C:\Users\18811\Desktop\graph\';cnt = num2str(save_pic_cnt);tail_path = '.jpg';frame = getframe(A);im=frame2im(frame);path_img = [base_path, cnt, tail_path];% imwrite(im, path_img);% save_x(:, :, save_pic_cnt) = x;save_pic_cnt = save_pic_cnt + 1;end% scatter(0, 0, 'o', 'r');for count_2=1:NPfitness(count_2)=func(x(count_2,:), mode);endfitness_ = fitness;%[fitness_min,index0] = min(fitness);%fitness_max = max(fitness);[fitness_max,index0] = max(fitness);fitness_average = sum(fitness)/(length(fitness)); % 种群的平均值collect_fit_average(gen) = fitness_average; % 保存适应度的平均值collect_fitmax_subtract_fit_average(gen) = fitness_max - fitness_average; % 保存f_max-f_average ; fitness_min = min(fitness);best_indiv = x(index0,:); % 最优的个体% optimization_trace(gen,: , global_count) = best_indiv;% best_solution(gen) = fitness_min;best_solution(gen) = fitness_max;% 计算归⼀化的适应度值fitness = (fitness - fitness_min)/(fitness_max - fitness_min);fitness_sum = sum(fitness);fitness = fitness./fitness_sum;fitness = cumsum(fitness);% 轮盘赌选择newi = 1;while newi<=NPrandom_num = rand(); % ⽣成随机数if random_num<fitness(1)clone_x(newi, :) = x(1, :);newi = newi+1;elsefor ct=1:NP-1if random_num>fitness(ct) && random_num<fitness(ct+1)clone_x(newi,:) = x(ct,:);newi = newi+1;break;endendendend% disp(clone_x - x);% 进⾏交叉，变异操作% count=0;for count=1:2:NP% ⾃适应计算Pc.% 选区两个交叉的个体的较⼤的适应度值if fitness_(count)>=fitness_(count+1)fitness_selected = fitness_(count);elsefitness_selected = fitness_(count+1);end% 计算Pcif fitness_selected >= fitness_averagePc = k1*(fitness_max-fitness_selected)/(fitness_max-fitness_average);elsePc = k3;endcollect_Pc(gen, count) = Pc; % 保存Pc的值temp_cross = rand();if temp_cross < Pc% 交叉算⼦注：这种交叉算⼦效果更好temp_alpha = 0.6;cross_x(count,:) = temp_alpha*clone_x(count,:)+(1-temp_alpha)*clone_x(count+1,:);cross_x(count+1,:) = temp_alpha*clone_x(count+1,:)+(1-temp_alpha)*clone_x(count,:);% 改进的交叉算⼦参考⽂献：管⼩艳. 实数编码下遗传算法的改进及其应⽤[D].重庆⼤学,2012. 注：但这种交叉算⼦实际的效果不理想% temp_gama = rand();% temp_alpha = 0.98;% cross_x(count,:) = temp_alpha*clone_x(count,:)+(1-temp_alpha)*clone_x(count+1,:)+temp_gama*(clone_x(count,:)-clone_x(count+1,:)); % cross_x(count+1,:) = temp_alpha*clone_x(count+1,:)+(1-temp_alpha)*clone_x(count,:)+temp_gama*(clone_x(count,:)-clone_x(count+1,:)); elsecross_x(count,:)=clone_x(count,:);cross_x(count+1,:)=clone_x(count+1,:);end% 边界条件检查if cross_x(count,1)>X_max || cross_x(count,1)<X_min || cross_x(count,2)>Y_max || cross_x(count,2)<Y_mintemp1 = X_min+rand()*(X_max-X_min);temp2 = Y_min+rand()*(Y_max-Y_min);cross_x(count,:) = [temp1,temp2];endendcross_x = cross_x(1:NP,:);% cross_x为完成交叉的个体；% 变异操作for count=1:1:NP% 计算Pmif fitness_(count)>=fitness_averagePm = k2*(fitness_max-fitness_(count))/(fitness_max-fitness_average);elsePm = k4;endcollect_Pm(gen,count) = Pm; % 保存Pm的值temp_mutation=rand();if temp_mutation<Pm%mutation_x(count,:) = (1+0.01).*cross_x(count,:); %这种变异算⼦效果不理想% 变异算⼦参考⽂献：管⼩艳. 实数编码下遗传算法的改进及其应⽤[D].重庆⼤学,2012mutation_pos = randi(D);if mutation_pos==1low = X_min;high = X_max;elselow = Y_min;high = Y_max;ends_t(gen) = 1-r^((1-gen/G)^b);new_low = cross_x(count, mutation_pos)-s_t(gen)*(cross_x(count, mutation_pos)-low);new_high = cross_x(count, mutation_pos)+s_t(gen)*(high-cross_x(count, mutation_pos));mutation_x(count, :) = cross_x(count, :);mutation_x(count, mutation_pos) = new_low+rand()*(new_high-new_low);if mutation_x(count,1)>X_max || mutation_x(count,1)<X_min || mutation_x(count,2)>Y_max || mutation_x(count,2)<Y_mintemp1 = X_min+rand()*(X_max-X_min);temp2 = Y_min+rand()*(Y_max-Y_min);mutation_x(count,:) = [temp1,temp2];endelsemutation_x(count,:) = cross_x(count,:);endend%边界条件处理x=mutation_x(1:NP, :);x(1,:)= best_indiv;end%% 作图figure(4)plot(best_solution);%hold on;xlabel('进化代数');ylabel('适应度值');title('适应度进化曲线');figure(5);plot(collect_fitmax_subtract_fit_average);title('f_{max}-f_{average}曲线');xlabel('进化代数');ylabel('f_{max}-f_{average}');% function f=func(buf)% f=0.5-((sin(sqrt(buf(1).^2+buf(2).^2)).^2)-0.5)./(1+0.001.*(buf(1).^2+buf(2).^2)).^2; % endfunction f=func(buf, md)if strcmp(md, 'Schaffer')f=0.5-((sin(sqrt(buf(1).^2+buf(2).^2)).^2)-0.5)./(1+0.001.*(buf(1).^2+buf(2).^2)).^2; endif strcmp(md,'self_define')% f = 100*(buf(2)-buf(1).^2).^2+(1-buf(1)).^2;f = (cos(buf(1).^2+buf(2).^2)-0.1)./(1+0.3*(buf(1).^2+buf(2).^2).^2)+3;endend修改后的算法寻优效果得到很⼤的提升，⾮常感谢指出代码中的错误：运⾏结果：。

遗传算法介绍并附上Matlab代码

1、遗传算法介绍遗传算法，模拟达尔文进化论的自然选择和遗产学机理的生物进化构成的计算模型，一种不断选择优良个体的算法。

谈到遗传，想想自然界动物遗传是怎么来的，自然主要过程包括染色体的选择，交叉，变异（不明白这个的可以去看看生物学），这些操作后，保证了以后的个基本上是最优的，那么以后再继续这样下去，就可以一直最优了。

2、解决的问题先说说自己要解决的问题吧，遗传算法很有名，自然能解决的问题很多了，在原理上不变的情况下，只要改变模型的应用环境和形式，基本上都可以。

但是遗传算法主要还是解决优化类问题，尤其是那种不能直接解出来的很复杂的问题，而实际情况通常也是这样的。

本部分主要为了了解遗传算法的应用，选择一个复杂的二维函数来进行遗传算法优化，函数显示为y=10*sin(5*x)+7*abs(x-5)+10,这个函数图像为：怎么样，还是有一点复杂的吧，当然你还可以任意假设和编写，只要符合就可以。

那么现在问你要你一下求出最大值你能求出来吗？这类问题如果用遗传算法或者其他优化方法就很简单了，为什么呢？说白了，其实就是计算机太笨了，同时计算速度又超快，举个例子吧，我把x等分成100万份，再一下子都带值进去算，求出对应的100万个y的值，再比较他们的大小，找到最大值不就可以了吗，很笨吧，人算是不可能的，但是计算机可以。

而遗传算法也是很笨的一个个搜索，只不过加了一点什么了，就是人为的给它算的方向和策略，让它有目的的算，这也就是算法了。

3、如何开始？我们知道一个种群中可能只有一个个体吗？不可能吧，肯定很多才对，这样相互结合的机会才多，产生的后代才会多种多样，才会有更好的优良基因，有利于种群的发展。

那么算法也是如此，当然个体多少是个问题，一般来说20-100之间我觉得差不多了。

那么个体究竟是什么呢？在我们这个问题中自然就是x值了。

其他情况下，个体就是所求问题的变量，这里我们假设个体数选100个，也就是开始选100个不同的x值，不明白的话就假设是100个猴子吧。

python 遗传算法适应度函数

python 遗传算法适应度函数Python遗传算法适应度函数遗传算法是一种模拟自然选择和遗传机制的优化算法，通过模拟物种的进化过程来寻找问题的最优解。

在遗传算法中，适应度函数被用来评估每个个体的适应度，以决定其在进化中的生存和繁殖机会。

所谓适应度函数，是指根据问题的特性、要求和目标，通过数学建模来定量地度量个体解（染色体）在问题解空间中的好坏程度的函数。

适应度函数可以是问题特定的、领域相关的，也可以是通用的、领域无关的。

在遗传算法中，适应度函数决定了个体优劣与繁殖机会的关系，从而影响整个算法的性能与最终结果。

在Python中，我们可以使用不同的方式来构建适应度函数。

下面将介绍一些常见的方法以及它们的实现。

1. 目标函数法目标函数法是适应度函数构建的最常见方法之一。

通过编写问题的目标函数，将个体的染色体作为输入，计算出该个体的适应度值。

例如，如果我们要求解一个最小化目标的问题，可以将目标函数设计为计算个体解的损失函数值，并将其反转作为适应度值。

例如，假设我们要解决一个最小化函数的问题，其中目标函数为f(x) = x^2。

我们可以使用Python代码来实现适应度函数：pythondef fitness_function(chromosome):x = decode(chromosome) # 解码染色体，得到个体参数值fitness_value = x2 # 计算适应度值return fitness_value在这个例子中，我们假设染色体表示一个实数变量x，通过解码染色体，我们可以得到x的数值，然后计算函数f(x)的值作为适应度值。

2. 约束函数法在某些问题中，除了优化目标外，还存在一些额外的约束条件。

适应度函数的计算需要考虑这些约束条件，以保证生成的个体解是可行解。

在这种情况下，我们可以编写约束函数来判断个体解是否满足约束条件，并根据满足程度来计算适应度值。

例如，假设我们要解决一个带约束条件的问题，其中目标函数为f(x) = x^2，约束条件为x >= 0。

遗传算法matlab代码

遗传算法matlab代码以下是一个简单的遗传算法的MATLAB 代码示例：matlab复制代码% 遗传算法参数设置pop_size = 50; % 种群大小num_vars = 10; % 变量数目num_generations = 100; % 进化的代数mutation_rate = 0.01; % 变异率crossover_rate = 0.8; % 交叉率% 初始化种群population = rand(pop_size, num_vars);% 开始进化for i = 1:num_generations% 计算适应度fitness = evaluate_fitness(population);% 选择操作selected_population = selection(population, fitness);% 交叉操作offspring_population = crossover(selected_population,crossover_rate);% 变异操作mutated_population = mutation(offspring_population,mutation_rate);% 生成新种群population = [selected_population; mutated_population];end% 选择最优解best_solution = population(find(fitness == max(fitness)), :);% 适应度函数function f = evaluate_fitness(population)f = zeros(size(population));for i = 1:size(population, 1)f(i) = sum(population(i, :));endend% 选择函数function selected_population = selection(population, fitness)% 轮盘赌选择total_fitness = sum(fitness);probabilities = fitness / total_fitness;selected_indices = zeros(pop_size, 1);for i = 1:pop_sizer = rand();cumulative_probabilities = cumsum(probabilities);for j = 1:pop_sizeif r <= cumulative_probabilities(j)selected_indices(i) = j;break;endendendselected_population = population(selected_indices, :);end% 交叉函数function offspring_population = crossover(parental_population, crossover_rate)offspring_population = zeros(size(parental_population));num_crossovers = ceil(size(parental_population, 1) *crossover_rate);crossover_indices = randperm(size(parental_population, 1),num_crossovers);以下是另一个一个简单的遗传算法的MATLAB 代码示例：matlab复制代码% 初始化种群population = rand(nPopulation, nGenes);% 进化迭代for iGeneration = 1:nGeneration% 计算适应度fitness = evaluateFitness(population);% 选择父代parentIdx = selection(fitness);parent = population(parentIdx, :);% 交叉产生子代child = crossover(parent);% 变异子代child = mutation(child);% 更新种群population = [parent; child];end% 评估最优解bestFitness = -Inf;for i = 1:nPopulationf = evaluateFitness(population(i, :));if f > bestFitnessbestFitness = f;bestIndividual = population(i, :);endend% 可视化结果plotFitness(fitness);其中，nPopulation和nGenes分别是种群大小和基因数；nGeneration是迭代次数；evaluateFitness函数用于计算个体的适应度；selection函数用于选择父代；crossover函数用于交叉产生子代；mutation函数用于变异子代。

人工智能遗传算法及python代码实现

人工智能遗传算法及python代码实现人工智能遗传算法是一种基于生物遗传进化理论的启发式算法，常用于求解复杂的优化问题。

它的基本思想是通过自然选择和基因交叉等机制，在种群中不断进化出适应性更强的个体，最终找到问题的最优解。

遗传算法通常由以下几个步骤组成：1. 初始化种群：从问题空间中随机生成一组解作为初始种群。

2. 评价适应度：利用一个适应度函数来评价每个解的适应性，通常是优化问题的目标函数，如最小化代价、最大化收益等。

3. 选择操作：从种群中选择一些具有较高适应度的个体用于产生新的种群。

选择操作通常采用轮盘赌选择方法或精英选择方法。

4. 交叉操作：将两个个体的染色体进行交叉、重组，生成新的子代个体。

5. 变异操作：对新产生的子代个体随机变异一些基因，以增加种群的多样性。

6. 生成新种群：用选择、交叉和变异操作产生新的种群，并进行适应度评价。

7. 终止条件：如果达到终止条件，算法停止，否则返回步骤3。

遗传算法的优点是可以适应各种优化问题，并且求解精度较高。

但由于其需要进行大量的随机操作，因此效率相对较低，也较容易陷入局部最优解。

在实际应用中，遗传算法常与其他算法结合使用，以求得更好的结果。

以下是使用Python实现基本遗传算法的示例代码：import randomimport math# 定义适应度函数，用于评价每个个体的适应程度def fitness_func(x):return math.cos(20 * x) + math.sin(3 * x)# 执行遗传算法def genetic_algorithm(pop_size, chrom_len, pcross, pmutate, generations):# 初始化种群population = [[random.randint(0, 1) for j in range(chrom_len)] for i in range(pop_size)]# 迭代指定代数for gen in range(generations):# 评价种群中每个个体的适应度fits = [fitness_func(sum(population[i]) / (chrom_len * 1.0)) for i in range(pop_size)]# 选择操作：轮盘赌选择roulette_wheel = []for i in range(pop_size):fitness = fits[i]roulette_wheel += [i] * int(fitness * 100)parents = []for i in range(pop_size):selected = random.choice(roulette_wheel)parents.append(population[selected])# 交叉操作：单点交叉for i in range(0, pop_size, 2):if random.uniform(0, 1) < pcross:pivot = random.randint(1, chrom_len - 1)parents[i][pivot:], parents[i+1][pivot:] = parents[i+1][pivot:], parents[i][pivot:]# 变异操作：随机翻转一个基因for i in range(pop_size):for j in range(chrom_len):if random.uniform(0, 1) < pmutate:parents[i][j] = 1 - parents[i][j]# 生成新种群population = parents# 返回种群中适应度最高的个体的解fits = [fitness_func(sum(population[i]) / (chrom_len * 1.0)) for i in range(pop_size)]best = fits.index(max(fits))return sum(population[best]) / (chrom_len * 1.0)# 测试遗传算法print("Result: ", genetic_algorithm(pop_size=100, chrom_len=10, pcross=0.9, pmutate=0.1, generations=100))上述代码实现了遗传算法，以优化余弦函数和正弦函数的和在某个区间内的最大值。

变异概率自适应调整的遗传算法GA程序资料

%交叉概率0.7，变异概率0.01%最大进化代数为100代，保优操作。

遗传算法python代码实现

遗传算法是一种模拟自然选择和遗传机制的优化方法，通过模拟自然界中的进化过程来寻找最优解。

在计算机科学和工程领域被广泛应用，特别是在优化问题、机器学习和模式识别中。

Python是一种流行的编程语言，具有简洁、易读的语法，非常适合实现遗传算法。

接下来我们将介绍如何使用Python来实现遗传算法。

1. 安装Python环境在实现遗传算法之前，首先需要安装Python环境。

在全球信息站（xxx）上下载最新版本的Python，并按照提示进行安装。

2. 安装遗传算法库Python中有许多开源的遗传算法库，例如DEAP、Pyevolve等。

选择其中一个库并按照文档进行安装。

3. 定义问题在实现遗传算法之前，需要明确问题的定义。

我们要解决一个优化问题，如最大化一个函数f(x)。

需要定义函数f(x)的计算方法和取值范围。

4. 初始化种裙接下来我们需要初始化一个种裙，种裙中的个体表示问题的一个可能解。

根据问题的定义，初始化一定数量的个体，并随机分布在取值范围内。

5. 评估个体针对种裙中的每个个体，计算其适应度，即函数f(x)的值。

根据适应度值来评估个体的优劣。

6. 选择操作选择操作是从种裙中选择个体用于繁殖下一代的过程。

常用的选择算法有轮盘赌选择、锦标赛选择等。

根据个体的适应度值来进行选择操作。

7. 交叉操作交叉操作是将两个个体进行基因交换，产生新的个体。

根据交叉概率和交叉方式来进行交叉操作。

8. 变异操作变异操作是随机改变个体的某些基因，以增加种裙的多样性。

根据变异概率和变异方式来进行变异操作。

9. 更新种裙经过选择、交叉和变异操作后，更新种裙并重新评估每个个体的适应度。

10. 终止条件设置终止条件，如达到最大迭代次数、适应度达到一定阈值等。

当满足终止条件时，算法停止并输出最优解。

通过以上步骤，我们可以使用Python实现遗传算法。

在实际应用中，还可以对算法进行优化和改进，以适应不同的问题和需求。

希望本文对正在学习或使用遗传算法的朋友们有所帮助。

自适应遗传算法代码

/* developed from the Pascal SGA code presented by David E.Goldberg */
/*华南理工大学电子与信息学院苏勇2004年4月*/
/**********************************************************************/
void freeall(),nomemory(char *),report();
void writepop(),writechrom(unsigned *);
void preselect();
void statistics(struct individual *);
void title(),repchar (FILE *,char *,int);
initpop();
statistics(oldpop);
initreport();
}
void initdata() /*遗传算法参数输入*/
{
char answer[2];
popsize=30;
if((popsize%2) != 0)
{
fprintf(outfp, "种群大小已设置为偶数\n");
int generation; /*最佳个体生成代*/
};
struct individual *oldpop; /*当前代种群*/
struct individual *newpop; /*新一代种群*/
struct bestever bestfit; /*最佳个体*/
double sumfitness; /*种群中个体适应度累计*/
nomemory("newpop chromosomes");

遗传算法挖掘因子 python代码

遗传算法是一种优化搜索技术，它是通过模拟自然选择和遗传过程来寻找最优解的。

以下是一个使用Python实现的简单遗传算法的例子，用于挖掘因子。

pythonimport numpy as np# 适应度函数def fitness_function(solution):# 此处是一个例子，具体的适应度函数应根据你的问题来定义return sum(solution)# 遗传算法def genetic_algorithm(population_size, gene_length, generations):# 初始化种群population = np.random.randint(2, size=(population_size, gene_length))for generation in range(generations):# 计算适应度值fitness = np.array([fitness_function(ind) for ind in population])# 选择操作parents = population[np.random.choice(population_size, population_size, replace=False)][:, np.random.choice(gene_length, gene_length, replace=False)] parents = parents[(fitness[np.arange(population_size)[:, None], parents] > fitness[parents, np.arange(gene_length)]).all()]# 交叉操作children = np.empty((0, gene_length), dtype=int)while len(children) < population_size:parent1 = parents[np.random.randint(0, len(parents))]parent2 = parents[np.random.randint(0, len(parents))]if parent1 != parent2:child = np.where(np.random.randint(2, size=(gene_length, 2)) > 0, parent1, parent2)children = np.append(children, child, axis=0)parents = np.delete(parents, np.where((parents == parent1).all() | (parents == parent2).all())[0])population = children# 变异操作for i in range(population_size):if np.random.rand() < 0.01: # 变异率可以根据实际情况调整for j in range(gene_length):if np.random.rand() < 0.5: # 变异点可以在这里调整population[i][j] = 1 if population[i][j] == 0 else 0 # 返回最优解return population[np.argmax(fitness)]# 运行遗传算法best_solution = genetic_algorithm(100, 10, 1000)print("Best solution:", best_solution)print("Best solution fitness:", fitness_function(best_solution))注意：这只是一个基础的遗传算法实现，实际应用中可能需要进行更复杂的操作，例如更复杂的编码方式、更复杂的交叉和变异操作、精英策略等。

基于实数编码（离散杂交+自适应变异），线性排名选择的遗传算法（附代码）

我们来看⼀个很简单的⼩问题f=x1+x2+x3+x4,x1、x2、x3、x4是⼤于等于10⼩于等于100的实数，求f的最⼤值。

这个⼩学⽣就能解决的问题我今天打算⽤遗传算法来解决，你可能说这不是智障吗？但是其实这只是⼀个⼩例⼦，因为⽤同样的⽅法，你可以解决f=x1^x2*x3^x4/x2^x1*x4^x3甚⾄是更复杂的问题，下⾯就来详细讲⼀讲。

基于对遗传算法的⼀般性了解，我就不再赘述详细过程（其实是因为上⼀篇写过了懒得再写⼀遍），只谈谈实数编码和线性排名选择策略。

实数编码顾名思义就是⽤实数进⾏编码，实数来做染⾊体的基因，实数构成染⾊体，他的本质其实是⽤问题的⼀个解空间来做⼀个染⾊体，⽐如{20.5658.15.2385，89.0000,56.4400}，就是上⾯⼩问题的⼀个解空间，就可以把它作为⼀个染⾊体⽤于进化，其中的每⼀个x1,x2都是⼀个基因，那些交叉，变异都是基于这样的设定的。

在这⾥插⼀句，实数编码和整数编码的思想是极为类似的，但是实数编码的解空间更⼤更复杂。

现在来讲讲实数编码的交叉和变异1、交叉实数编码的杂交⽅式有离散杂交，算数杂交等等，本例只讲解离散杂交。

离散杂交和⼆进制的杂交是⼗分类似的，（可以）选定⼀个基因位，然后将选定的两个染⾊体在这个位置之后的基因进⾏交换（注意基因的定义区间是不变的）。

注意，在实数编码中，交叉的作⽤不是很⼤。

2、变异实数编码的变异包括均匀性变异、正态性变异、⾮⼀致性变异、⾃适应变异、多级变异等，本例只讲解⾃适应变异和⾮⼀致性变异。

（1）⾮⼀致性变异在传统的遗传算法中，突变的情况是与代数⽆关的。

但是进化刚开始时，就是需要向各个⽅向⼤步发展进⾏尝试，进化到了后期，解已经相对较优了，进⾏局部搜索可能更有利于找到更好的解。

显然传统的⽅法是不⾏的，必须找到⼀种将变异幅度和代数相联系的策略。

自适应遗传算法matlab代码

gen=0;
v=bs2rv(Chrom,FieldD);
ObjV=v.*sin(10*pi*v)+2.0;
while gen<maxgen,
FitnV=ranking(-ObjV);
SelCh=select('sus',Chrom,FitnV,GGAP);
FitnVmax=max(FitnV);
FitnVave=sum(FitnV)/NIND;
v=bs2rv(SelCh,FieldD);
ObjVSel=v.*sin(10*pi*v)+2.0;
[Chrom ObjV]=reins(Chrom,SelCh,1,1,ObjV,ObjVSel);
gen=gen+1;
variable=bs2rv(Chrom, FieldD)
[Y,I]=max(ObjV),hold on;
plot(trace(1,:)','Pr');
hold on;
plot(trace(2,:)','-.');grid;
legend('解的变化','种群均值的变化')
</maxgen,
plot(I,Y,'bo');
trace(1,gen)=max(ObjV);
trace(2,gen)=sum(ObjV)/length(ObjV);
if (gen==20)
figure(2);
plot(ObjV);hold on;
plot(ObjV,'b*');grid;
end
%end
figure(3);
else

遗传算法解释及代码（一看就懂）

遗传算法解释及代码（一看就懂）遗传算法( GA , Genetic Algorithm ) ，也称进化算法。

遗传算法是受达尔文的进化论的启发，借鉴生物进化过程而提出的一种启发式搜索算法。

因此在介绍遗传算法前有必要简单的介绍生物进化知识。

一.进化论知识作为遗传算法生物背景的介绍，下面内容了解即可：种群(Population)：生物的进化以群体的形式进行，这样的一个群体称为种群。

个体：组成种群的单个生物。

基因 ( Gene ) ：一个遗传因子。

染色体 ( Chromosome )：包含一组的基因。

生存竞争，适者生存：对环境适应度高的、牛B的个体参与繁殖的机会比较多，后代就会越来越多。

适应度低的个体参与繁殖的机会比较少，后代就会越来越少。

遗传与变异：新个体会遗传父母双方各一部分的基因，同时有一定的概率发生基因变异。

简单说来就是：繁殖过程，会发生基因交叉( Crossover ) ，基因突变( Mutation ) ，适应度( Fitness )低的个体会被逐步淘汰，而适应度高的个体会越来越多。

那么经过N代的自然选择后，保存下来的个体都是适应度很高的，其中很可能包含史上产生的适应度最高的那个个体。

二.遗传算法思想借鉴生物进化论，遗传算法将要解决的问题模拟成一个生物进化的过程，通过复制、交叉、突变等操作产生下一代的解，并逐步淘汰掉适应度函数值低的解，增加适应度函数值高的解。

这样进化N代后就很有可能会进化出适应度函数值很高的个体。

举个例子，使用遗传算法解决“0-1背包问题”的思路：0-1背包的解可以编码为一串0-1字符串（0：不取，1：取）；首先，随机产生M个0-1字符串，然后评价这些0-1字符串作为0-1背包问题的解的优劣；然后，随机选择一些字符串通过交叉、突变等操作产生下一代的M个字符串，而且较优的解被选中的概率要比较高。

这样经过G代的进化后就可能会产生出0-1背包问题的一个“近似最优解”。

编码：需要将问题的解编码成字符串的形式才能使用遗传算法。

(完整版)遗传算法简介及代码详解

遗传算法简述及代码详解声明：本文内容整理自网络，认为原作者同意转载，如有冒犯请联系我。

遗传算法基本内容遗传算法为群体优化算法，也就是从多个初始解开始进行优化，每个解称为一个染色体，各染色体之间通过竞争、合作、单独变异，不断进化。

遗传学与遗传算法中的基础术语比较染色体：又可以叫做基因型个体(individuals)群体/种群(population)：一定数量的个体组成，及一定数量的染色体组成，群体中个体的数量叫做群体大小。

初始群体：若干染色体的集合，即解的规模，如30，50等，认为是随机选取的数据集合。

适应度(fitness)：各个个体对环境的适应程度优化时先要将实际问题转换到遗传空间，就是把实际问题的解用染色体表示，称为编码，反过程为解码/译码，因为优化后要进行评价（此时得到的解是否较之前解优越），所以要返回问题空间，故要进行解码。

SGA采用二进制编码，染色体就是二进制位串，每一位可称为一个基因；如果直接生成二进制初始种群，则不必有编码过程，但要求解码时将染色体解码到问题可行域内。

遗传算法的准备工作:1) 数据转换操作，包括表现型到基因型的转换和基因型到表现型的转换。

前者是把求解空间中的参数转化成遗传空间中的染色体或者个体(encoding)，后者是它的逆操作(decoding)2) 确定适应度计算函数，可以将个体值经过该函数转换为该个体的适应度，该适应度的高低要能充分反映该个体对于解得优秀程度。

非常重要的过程。

遗传算法基本过程为:1) 编码，创建初始群体2) 群体中个体适应度计算3) 评估适应度4) 根据适应度选择个体5) 被选择个体进行交叉繁殖6) 在繁殖的过程中引入变异机制7) 繁殖出新的群体，回到第二步实例一：（建议先看实例二）求 []30,0∈x 范围内的()210-=x y 的最小值1) 编码算法选择为"将x 转化为2进制的串"，串的长度为5位（串的长度根据解的精度设定，串长度越长解得精度越高）。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

void initialize() /* 遗传算法初始化 */ { /* 键盘输入遗传算法参数 */ initdata(); /* 确定染色体的字节长度 */ chromsize = (lchrom/(8*sizeof(unsigned))); if(lchrom%(8*sizeof(unsigned))) chromsize++; /*分配给全局数据结构空间 */ initmalloc();
/* 初始化随机数发生器 */ randomize(); /* 初始化全局计数变量和一些数值*/ nmutation = 0; ncross = 0; bestfit.fitness = 0.0; bestfit.generation = 0; /* 初始化种群，并统计计算结果 */ initpop(); statistics(oldpop); initreport(); } void initdata() /* 遗传算法参数输入 */ { char answer[2]; popsize=30; if((popsize%2) != 0) { fprintf(outfp, "种群大小已设置为偶数\n"); popsize++; }; lchrom=22; printstrings=1; maxgen=150; pcross=0.8; pc1=0.8; pc2=0.6; pmutation=0.05; pm1=0.05; pm2=0.005; } void initpop() /* 随机初始化种群 */ { int j, j1, k, stop; unsigned mask = 1; for(j = 0; j < popsize; j++) { for(k = 0; k < chromsize; k++) { oldpop[j].chrom[k] = 0; if(k == (chromsize-1)) stop = lchrom - (k*(8*sizeof(unsigned)));
/* 计算初始适应度*/

temp_mate2 = mate2; /* 交叉和变异 */ jcross = crossover(oldpop[mate1].chrom, oldpop[mate2].chrom, newpop[j].chrom, newpop[j+1].chrom); /* 自适应变异概率 */ if(gen!=0) { if(newpop[j].fitness>=avg) pmutation = pm1-(pm1-pm2)*(max-newpop[j].fitness)/(max-avg); else pmutation = pm1; } mutation(newpop[j].chrom); if(gen!=0) { if(newpop[j+1].fitness>=avg) pmutation = pm1-(pm1-pm2)*(max-newpop[j+1].fitness)/(max-avg); else pmutation = pm1; } mutation(newpop[j+1].chrom); /* 解码, 计算适应度 */ objfunc(&(newpop[j])); /*记录亲子关系和交叉位置 */ newpop[j].parent[0] = mate1+1; newpop[j].xsite = jcross; newpop[j].parent[1] = mate2+1; objfunc(&(newpop[j+1])); newpop[j+1].parent[0] = mate1+1; newpop[j+1].xsite = jcross; newpop[j+1].parent[1] = mate2+1; j = j + 2; } while(j < (popsize-1)); } void initmalloc() /*为全局数据变量分配空间 */ { unsigned nbytes; char *malloc(); int j; /* 分配给当前代和新一代种群内存空间 */ nbytes = popsize*sizeof(struct individual);
int ncross; /* 当前代交叉发生次数 */ float pc1; float pc2; float pm1; float pm2; int temp_mate1; int temp_mate2; /* 随机数发生器使用的静态变量 */ static double oldrand[55]; static int jrand; static double rndx2; static int rndcalcflag; /* 输出文件指针 */ FILE *outfp ; /* 函数定义 */ void advance_random(); int flip(float);rnd(int, int); void randomize(); double randomnormaldeviate(); float randomperc(),rndreal(float,float); void warmup_random(float); void initialize(),initdata(),initpop(); void initreport(),generation(),initmalloc(); void freeall(),nomemory(char *),report(); void writepop(),writechrom(unsigned *); void preselect(); void statistics(struct individual *); void title(),repchar (FILE *,char *,int); void skip(FILE *,int); int select(); void objfunc(struct individual *); int crossover (unsigned *, unsigned *, unsigned *, unsigned *); void mutation(unsigned *);
else stop =8*sizeof(unsigned); for(j1 = 1; j1 <= stop; j1++) { oldpop[j].chrom[k] = oldpop[j].chrom[k]<<1; if(flip(0.5)) oldpop[j].chrom[k] = oldpop[j].chrom[k]|mask; } } oldpop[j].parent[0] = 0; oldpop[j].parent[1] = 0; oldpop[j].xsite = 0; objfunc(&(oldpop[j])); } } void initreport() /* 初始参数输出 */ { void skip(); skip(outfp,1); fprintf(outfp," 基本遗传算法参数\n"); fprintf(outfp," -------------------------------------------------\n"); fprintf(outfp," 种群大小(popsize) = %d\n",popsize); fprintf(outfp," 染色体长度(lchrom) = %d\n",lchrom); fprintf(outfp," 最大进化代数(maxgen) = %d\n",maxgen); fprintf(outfp," 交叉概率(pcross) = %f\n",pcross); fprintf(outfp," 变异概率(pmutation) = %f\n",pmutation); fprintf(outfp," -------------------------------------------------\n"); skip(outfp,1); fflush(outfp); } void generation() { int mate1, mate2, jcross, j = 0; /* 每代运算前进行预选 */ preselect(); /* 选择, 交叉, 变异 */ do { /* 挑选交叉配对 */ mate1 = select(); temp_mate1 = mate1; mate2 = select(); /* 初始父个体信息 */
/**********************************************************************/ /* 基于基本遗传算法的自适应遗传优化算法函数最优化 SGA_AUTO.C */ /* A Function Optimizer using Simple Genetic Algorithm */ /* developed from the Pascal SGA code presented by David E.Goldberg */ /* 华南理工大学电子与信息学院苏勇 2004 年 4 月 */ /**********************************************************************/ #include <stdio.h> #include <math.h> /* 全局变量 */ struct individual /* 个体*/ { unsigned *chrom; /* 染色体 */ double fitness; /* 个体适应度*/ double varible; /* 个体对应的变量值*/ int xsite; /* 交叉位置 */ int parent[2]; /* 父个体 */ int *utility; /* 特定数据指针变量 */ }; struct bestever /* 最佳个体*/ { unsigned *chrom; /* 最佳个体染色体*/ double fitness; /* 最佳个体适应度 */ double varible; /* 最佳个体对应的变量值 */ int generation; /* 最佳个体生成代 */ }; struct individual *oldpop; /* 当前代种群 */ struct individual *newpop; /* 新一代种群 */ struct bestever bestfit; /* 最佳个体 */ double sumfitness; /* 种群中个体适应度累计 */ double max; /* 种群中个体最大适应度 */ double avg; /* 种群中个体平均适应度 */ double min; /* 种群中个体最小适应度 */ float pcross; /* 交叉概率 */ float pmutation; /* 变异概率 */ int popsize; /* 种群大小 */ int lchrom; /* 染色体长度*/ int chromsize; /* 存储一染色体所需字节数 */ int gen; /* 当前世代数 */ int maxgen; /* 最大世代数 */ int run; /* 当前运行次数 */ int maxruns; /* 总运行次数 */ int printstrings; /* 输出染色体编码的判断，0 -- 不输出, 1 -- 输出 */ int nmutation; /* 当前代变异发生次数 */