MATLAB课程遗传算法实验报告及源代码

合集下载

遗传算法详解（含MATLAB代码）

遗传算法详解（含MATLAB代码）Python遗传算法框架使用实例（一）使用Geatpy实现句子匹配在前面几篇文章中，我们已经介绍了高性能Python遗传和进化算法框架——Geatpy的使用。

本篇就一个案例进行展开讲述：pip install geatpy更新至Geatpy2的方法：pip install --upgrade --user geatpy查看版本号，在Python中执行：import geatpyprint(geatpy.__version__)我们都听过“无限猴子定理”，说的是有无限只猴子用无限的时间会产生特定的文章。

在无限猴子定理中，我们“假定”猴子们是没有像人类那样“智能”的，而且“假定”猴子不会自我学习。

因此，这些猴子需要“无限的时间"。

而在遗传算法中，由于采用的是启发式的进化搜索，因此不需要”无限的时间“就可以完成类似的工作。

当然，需要产生的文章篇幅越长，那么就需要越久的时间才能完成。

下面以产生"T om is a little boy, isn't he? Yes he is, he is a good and smart child and he is always ready to help others, all in all we all like him very much."的句子为例，讲述如何利用Geatpy实现句子的搜索。

之前的文章中我们已经讲述过如何使用Geatpy的进化算法框架实现遗传算法编程。

这里就直接用框架。

把自定义问题类和执行脚本编写在下面的"main.py”文件中：# -*- coding: utf-8 -*-import numpy as npimport geatpy as eaclass MyProblem(ea.Problem): # 继承Problem父类def __init__(self):name = 'MyProblem' # 初始化name（函数名称，可以随意设置） # 定义需要匹配的句子strs = 'Tom is a little boy, isn't he? Yes he is, he is a good and smart child and he is always ready to help others, all in all we all like him very much.'self.words = []for c in strs:self.words.append(ord(c)) # 把字符串转成ASCII码M = 1 # 初始化M（目标维数）maxormins = [1] # 初始化maxormins（目标最小最大化标记列表，1：最小化该目标；-1：最大化该目标）Dim = len(self.words) # 初始化Dim（决策变量维数）varTypes = [1] * Dim # 初始化varTypes（决策变量的类型，元素为0表示对应的变量是连续的；1表示是离散的）lb = [32] * Dim # 决策变量下界ub = [122] * Dim # 决策变量上界lbin = [1] * Dim # 决策变量下边界ubin = [1] * Dim # 决策变量上边界# 调用父类构造方法完成实例化ea.Problem.__init__(self, name, M, maxormins, Dim, varTypes, lb, ub, lbin, ubin)def aimFunc(self, pop): # 目标函数Vars = pop.Phen # 得到决策变量矩阵diff = np.sum((Vars - self.words)**2, 1)pop.ObjV = np.array([diff]).T # 把求得的目标函数值赋值给种群pop的ObjV执行脚本if __name__ == "__main__":"""================================实例化问题对象============================="""problem = MyProblem() # 生成问题对象"""==================================种群设置================================"""Encoding = 'RI' # 编码方式NIND = 50 # 种群规模Field = ea.crtfld(Encoding, problem.varTypes, problem.ranges,problem.borders) # 创建区域描述器population = ea.Population(Encoding, Field, NIND) # 实例化种群对象（此时种群还没被初始化，仅仅是完成种群对象的实例化）"""================================算法参数设置=============================="""myAlgorithm = ea.soea_DE_rand_1_L_templet(problem, population) # 实例化一个算法模板对象myAlgorithm.MAXGEN = 2000 # 最大进化代数"""===========================调用算法模板进行种群进化========================="""[population, obj_trace, var_trace] = myAlgorithm.run() # 执行算法模板population.save() # 把最后一代种群的信息保存到文件中# 输出结果best_gen = np.argmin(obj_trace[:, 1]) # 记录最优种群是在哪一代best_ObjV = obj_trace[best_gen, 1]print('最优的目标函数值为：%s'%(best_ObjV))print('有效进化代数：%s'%(obj_trace.shape[0]))print('最优的一代是第 %s 代'%(best_gen + 1))print('评价次数：%s'%(myAlgorithm.evalsNum))print('时间已过 %s 秒'%(myAlgorithm.passTime))for num in var_trace[best_gen, :]:print(chr(int(num)), end = '')上述代码中首先定义了一个问题类MyProblem，然后调用Geatpy内置的soea_DE_rand_1_L_templet算法模板，它实现的是差分进化算法DE-rand-1-L，详见源码：运行结果如下：种群信息导出完毕。

遗传算法Matlab源代码

function [X,MaxFval,BestPop,Trace]=fga(FUN,bounds,MaxEranum,PopSize,options,pCross,pMutation,pInversion)% [X,MaxFval,BestPop,Trace]=fga(FUN,bounds,MaxEranum,PopSize,options,pCross,pMutation,pInversion)% Finds a maximum of a function of several variables.% fga solves problems of the form:% max F(X) subject to: LB <= X <= UB (LB=bounds(:,1),UB=bounds(:,2))% X - 最优个体对应自变量值% MaxFval - 最优个体对应函数值% BestPop - 最优的群体即为最优的染色体群% Trace - 每代最佳个体所对应的目标函数值% FUN - 目标函数% bounds - 自变量范围% MaxEranum - 种群的代数,取50--500(默认200)% PopSize - 每一代种群的规模；此可取50--200(默认100)% pCross - 交叉概率,一般取0.5--0.85之间较好(默认0.8)% pMutation - 初始变异概率,一般取0.05-0.2之间较好(默认0.1)% pInversion - 倒位概率,一般取0.05－0.3之间较好(默认0.2)% options - 1*2矩阵,options(1)=0二进制编码(默认0),option(1)~=0十进制编码,option(2)设定求解精度(默认1e-4)T1=clock;%检验初始参数if nargin<2, error('FMAXGA requires at least three input arguments'); endif nargin==2, MaxEranum=150;PopSize=100;options=[1 1e-4];pCross=0.85;pMutation=0.1;pInversion=0.25;endif nargin==3, PopSize=100;options=[1 1e-4];pCross=0.85;pMutation=0.1;pInversion=0.25;endif nargin==4, options=[1 1e-4];pCross=0.85;pMutation=0.1;pInversion=0.25;endif nargin==5, pCross=0.85;pMutation=0.1;pInversion=0.25;endif nargin==6, pMutation=0.1;pInversion=0.25;endif nargin==7, pInversion=0.25;endif (options(1)==0|options(1)==1)&find((bounds(:,1)-bounds(:,2))>0)error('数据输入错误,请重新输入:');end% 定义全局变量global m n NewPop children1 children2 VarNum% 初始化种群和变量precision = options(2);bits = ceil(log2((bounds(:,2)-bounds(:,1))' ./ precision));%由设定精度划分区间VarNum = size(bounds,1);[Pop] = InitPop(PopSize,bounds,bits,options);%初始化种群[m,n] = size(Pop);fit = zeros(1,m);NewPop = zeros(m,n);children1 = zeros(1,n);children2 = zeros(1,n);pm0 = pMutation;BestPop = zeros(MaxEranum,n);%分配初始解空间BestPop,TraceTrace = zeros(1,MaxEranum);Lb = ones(PopSize,1)*bounds(:,1)';Ub = ones(PopSize,1)*bounds(:,2)';%二进制编码采用多点交叉和均匀交叉，并逐步增大均匀交叉概率%浮点编码采用离散交叉（前期）、算术交叉（中期）、AEA重组（后期）OptsCrossOver = [ones(1,MaxEranum)*options(1);...round(unidrnd(2*(MaxEranum-[1:MaxEranum]))/MaxEranum)]';%浮点编码时采用两种自适应变异和一种随机变异（自适应变异发生概率为随机变异发生的2倍）OptsMutation = [ones(1,MaxEranum)*options(1);unidrnd(5,1,MaxEranum)]';if options(1)==3D=zeros(n);CityPosition=bounds;D = sqrt((CityPosition(:, ones(1,n)) - CityPosition(:, ones(1,n))').^2 +...(CityPosition(:,2*ones(1,n)) - CityPosition(:,2*ones(1,n))').^2 );end%==========================================================================% 进化主程序%%==========================================================================eranum = 1;H=waitbar(0,'Please wait...');while(eranum<=MaxEranum)for j=1:mif options(1)==1%eval(['[fit(j)]=' FUN '(Pop(j,:));']);%但执行字符串速度比直接计算函数值慢fit(j)=feval(FUN,Pop(j,:));%计算适应度elseif options(1)==0%eval(['[fit(j)]=' FUN '(b2f(Pop(j,:),bounds,bits));']);fit(j)=feval(FUN,(b2f(Pop(j,:),bounds,bits)));elsefit(j)=-feval(FUN,Pop(j,:),D);endend[Maxfit,fitIn]=max(fit);%得到每一代最大适应值Meanfit(eranum)=mean(fit);BestPop(eranum,:)=Pop(fitIn,:);Trace(eranum)=Maxfit;if options(1)==1Pop=(Pop-Lb)./(Ub-Lb);%将定义域映射到[0,1]：[Lb,Ub]-->[0,1] ,Pop-->(Pop-Lb)./(Ub-Lb) endswitch round(unifrnd(0,eranum/MaxEranum))%进化前期尽量使用实行锦标赛选择，后期逐步增大非线性排名选择case {0}[selectpop]=TournamentSelect(Pop,fit,bits);%锦标赛选择case {1}[selectpop]=NonlinearRankSelect(Pop,fit,bits);%非线性排名选择end[CrossOverPop]=CrossOver(selectpop,pCross,OptsCrossOver(eranum,:));%交叉[MutationPop]=Mutation(CrossOverPop,fit,pMutation,VarNum,OptsMutation(eranum,:)); %变异[InversionPop]=Inversion(MutationPop,pInversion);%倒位%更新种群if options(1)==1Pop=Lb+InversionPop.*(Ub-Lb);%还原PopelsePop=InversionPop;endpMutation=pm0+(eranum^3)*(pCross/2-pm0)/(eranum^4); %逐步增大变异率至1/2交叉率percent=num2str(round(100*eranum/MaxEranum));waitbar(eranum/MaxEranum,H,['Evolution complete ',percent,'%']);eranum=eranum+1;endclose(H);% 格式化输出进化结果和解的变化情况t=1:MaxEranum;plot(t,Trace,t,Meanfit);legend('解的变化','种群的变化');title('函数优化的遗传算法');xlabel('进化世代数');ylabel('每一代最优适应度');[MaxFval,MaxFvalIn]=max(Trace);if options(1)==1|options(1)==3X=BestPop(MaxFvalIn,:);elseif options(1)==0X=b2f(BestPop(MaxFvalIn,:),bounds,bits);endhold on;plot(MaxFvalIn,MaxFval,'*');text(MaxFvalIn+5,MaxFval,['FMAX=' num2str(MaxFval)]);str1=sprintf(' Best generation:\n %d\n\n Best X:\n %s\n\n MaxFval\n %f\n',...MaxFvalIn,num2str(X),MaxFval);disp(str1);% -计时T2=clock;elapsed_time=T2-T1;if elapsed_time(6)<0elapsed_time(6)=elapsed_time(6)+60; elapsed_time(5)=elapsed_time(5)-1;endif elapsed_time(5)<0elapsed_time(5)=elapsed_time(5)+60;elapsed_time(4)=elapsed_time(4)-1;end。

遗传算法matlab代码

figure(1);%打开第一个窗口
fplot(f,[xmin,xmax]);%隐函数画图
grid on;hold on;
plot(x,fit,'k*');%作图,画初始种群的适应度图像
title('(a)染色体的初始位置');%标题
xlabel('x');ylabel('f(x)');%标记轴
close all;
clc;%清屏
tic;%计时器开始计时
n=20;ger=100;pc=0.65;pm=0.05;%初始化参数
%以上为经验值，可以更改。
% 生成初始种群
v=init_population(n,22); %得到初始种群，22串长，生成20*22的0-1矩阵
[N,L]=size(v); %得到初始规模行，列
v=fliplr(v); %实现左右翻转颠倒
[s,c]=size(v); %c代表串长。求行，列
aux=0:1:c-1; %21维向量
aux=ones(s,1)*aux;%权值向量矩阵
x1=sum((v.*2.^aux)');%权值 %注意转置 %sum是求列和
x=xymin+(xymax-xymin)*x1./(2^c-1); %最大值4194303;
disp(sprintf('Number of generations:%d',ger));
disp(sprintf('Population size:%d',N));
disp(sprintf('Crossover probability:%.3f',pc));

遗传算法多目标优化matlab源代码

遗传算法多目标优化matlab源代码遗传算法(Genetic Algorithm，GA)是一种基于自然选择和遗传学原理的优化算法。

它通过模拟生物进化过程，利用交叉、变异等操作来搜索问题的最优解。

在多目标优化问题中，GA也可以被应用。

本文将介绍如何使用Matlab实现遗传算法多目标优化，并提供源代码。

一、多目标优化1.1 多目标优化概述在实际问题中，往往存在多个冲突的目标函数需要同时优化。

这就是多目标优化(Multi-Objective Optimization, MOO)问题。

MOO不同于单一目标优化(Single Objective Optimization, SOO)，因为在MOO中不存在一个全局最优解，而是存在一系列的Pareto最优解。

Pareto最优解指的是，在不降低任何一个目标函数的情况下，无法找到更好的解决方案。

因此，在MOO中我们需要寻找Pareto前沿(Pareto Front)，即所有Pareto最优解组成的集合。

1.2 MOO方法常见的MOO方法有以下几种：（1）加权和法：将每个目标函数乘以一个权重系数，并将其加和作为综合评价指标。

（2）约束法：通过添加约束条件来限制可行域，并在可行域内寻找最优解。

（3）多目标遗传算法：通过模拟生物进化过程，利用交叉、变异等操作来搜索问题的最优解。

1.3 MOO评价指标在MOO中，我们需要使用一些指标来评价算法的性能。

以下是常见的MOO评价指标：（1）Pareto前沿覆盖率：Pareto前沿中被算法找到的解占总解数的比例。

（2）Pareto前沿距离：所有被算法找到的解与真实Pareto前沿之间的平均距离。

（3）收敛性：算法是否能够快速收敛到Pareto前沿。

二、遗传算法2.1 遗传算法概述遗传算法(Genetic Algorithm, GA)是一种基于自然选择和遗传学原理的优化算法。

它通过模拟生物进化过程，利用交叉、变异等操作来搜索问题的最优解。

遗传算法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源代码

方案一的程序编码函数主文件：function[Xp,LC1,LC2,LC3]=CLBGA8(M,Pm) %%%陈璐斌编程，解决VRP问题（带时间窗）%%输入参数%M遗传进化迭代次数%Pm变异概率%%输出参数%Xp最优个体%LC1目标收敛曲线%LC2平均适应度收敛曲线%LC3最优适应度收敛曲线%%%变量初始化Xp=zeros(1,5);LC1=zeros(1,M);LC2=zeros(1,M);LC3=zeros(1,M);Best=inf;%%编码方式-第一步：产生初始种群N=10;%N 种群规模farm=cell(1,N);%存储种群的细胞结构k=1;while (N-k>=0)G=randperm(5);%产生5个客户的全排列farm{k}=G;k=k+1;end%%%进化迭代计数器counter=1;while counter<=M%%第二步：交叉%交叉采用双亲双子单点交叉N=10;%种群规模newfarm=cell(1,2*N-4);%存储子代的细胞结构Ser=randperm(N);%两两随机配对表生成for i=1:(N-2)%避免交叉概率为1 A=farm{Ser(i)};B=farm{Ser(i+1)};%取出父代P0=unidrnd(5);%随机选择交叉点aa=zeros(1,5);bb=zeros(1,5);A_=A;B_=B;for ii=1:5-P0aa(ii)=B(P0+ii);endfor ii=1:5-P0for iiii=1:5if(B(P0+ii)==A_(iiii))A_(iiii)=0;endendendfor iii=6-P0:5for iiii=1:5if(A_(iiii)~=0)aa(iii)=A_(iiii);A_(iiii)=0;breakendendendfor ii=1:5-P0bb(ii)=A(P0+ii);endfor ii=1:5-P0for iiii=1:5if(A(P0+ii)==B_(iiii))B_(iiii)=0;endendendfor iii=6-P0:5for iiii=1:5if(B_(iiii)~=0)bb(iii)=B_(iiii);B_(iiii)=0;breakendendend%产生子代newfarm{2*i-1}=aa;newfarm{2*i}=bb;endFARM=[farm,newfarm];%新旧种群合并%%第三步：选择复制%%计算当前种群适应度并存储N=10;SYZ=zeros(1,3*N-4);syz=zeros(1,3*N-4);for i=1:(3*N-4)x=FARM{i};SYZ(i)=clb8(x);end%%选择复制，较优的N个个体复制到下一代k=1;while k<=(3*N-4)maxSYZ=max(SYZ);posSYZ=find(SYZ==maxSYZ);POS=posSYZ(1);k=k+1;farm{k}=FARM{POS};syz(k)=SYZ(POS);SYZ(POS)=0;end%记录和更新，更新最优个体，记录收敛曲线数据maxsyz=max(syz);meansyz=mean(syz);pos=find(syz==maxsyz);LC2(counter+1)=meansyz;if maxsyzBest=maxsyz;Xp=farm{pos(1)};endLC3(counter+1)=Best;d=[0,6.4,3.2,3.9,3.7,2;6.4,0,2.9,2.1,4.5,4.1;3.2,2.9,0,1.5,3.3,1.2;3.9,2.1,1.5,0,3.6,2.6;3.7,4.5,3.3,3.6 ,0,3.8;...2.0,4.1,1.2,2.6,3.8,0;];%距离矩阵t=[0,0.16,0.08,0.1,0.09,0.05;0.16,0,0.07,0.05,0.11,0.1;0.08,0.07,0,0.04,0.08,0.03;...0.1,0.05,0.04,0,0.09,0.07;0.09,0.11,0.08,0.09,0,0.10;0.05,0.1,0.03,0.07,0.1,0;];%行驶时间矩阵w=[0.15,0.2,0.18,0.25,0.22];%服务时间矩阵%%时间窗向量early=[0.15,0.3,0.7,0.4,0.7];xx=x;%取出染色体j=1;%分工点初始化%%取距离向量d1,d2d1=zeros(1,6);d1(1)=d(1,xx(1)+1);for i=1:4d1(i+1)=d(xx(i)+1,xx(i+1)+1);endd1(6)=d(xx(5)+1,1);%%时间窗计算T=t(1,xx(1)+1);pun1=0;if T<early(xx(1))pun1=early(xx(1))-T;T=early(xx(1));endT=T+w(xx(1));for i=2:5T=T+t(xx(i-1)+1,xx(i)+1);if T<early(xx(i))pun1=pun1+early(xx(i))-T;T=early(xx(i));endT=T+w(xx(5));endF=sum(10.*d1)+sum(10.*d2)+20*pun1; LC1(counter+1)=F;%%第四步：变异N=10;for i=1:Nif Pm>randAA=farm{i};POS1=unidrnd(5);POS2=unidrnd(5);temp=AA(POS1);AA(POS1)=AA(POS2);AA(POS2)=temp;farm{i}=AA;endendcounter=counter+1;end%%第五步：绘制收敛曲线图figure(2);plot(LC1);xlabel('迭代次数');ylabel('目标的值');title('目标的收敛曲线');figure(3);plot(LC2);xlabel('迭代次数');ylabel('适应度函数的平均值');title('平均适应度函数的收敛曲线');plot(LC3);xlabel('迭代次数');ylabel('适应度函数的最优值');title('最优适应度函数的收敛曲线');适应度文件：%%计算载重量和时间窗%%适应度函数计算function Fitness=clb8(x)d=[0,6.4,3.2,3.9,3.7,2;6.4,0,2.9,2.1,4.5,4.1;3.2,2.9,0,1.5,3.3,1.2;3.9,2.1,1.5,0,3.6,2.6;3.7,4.5,3.3,3.6 ,0,3.8;...2.0,4.1,1.2,2.6,3.8,0;];%距离矩阵t=[0,0.16,0.08,0.1,0.09,0.05;0.16,0,0.07,0.05,0.11,0.1;0.08,0.07,0,0.04,0.08,0.03;...0.1,0.05,0.04,0,0.09,0.07;0.09,0.11,0.08,0.09,0,0.10;0.05,0.1,0.03,0.07,0.1,0;];%行驶时间矩阵w=[0.15,0.2,0.18,0.25,0.22];%服务时间矩阵%%时间窗向量early=[0.15,0.3,0.7,0.4,0.7];xx=x;%取出染色体j=1;%分工点初始化%%取距离向量d1,d2d1=zeros(1,6);d1(1)=d(1,xx(1)+1);for i=1:4d1(i+1)=d(xx(i)+1,xx(i+1)+1);endd1(6)=d(xx(5)+1,1);%%时间窗计算T=t(1,xx(1)+1);pun1=0;if T<early(xx(1))pun1=early(xx(1))-T;T=early(xx(1));endT=T+w(xx(1));T=T+t(xx(i-1)+1,xx(i)+1);if T<early(xx(i))pun1=pun1+early(xx(i))-T;T=early(xx(i));endT=T+w(xx(5));endF=sum(10.*d1)+sum(10.*d2)+20*pun1;Fitness=1/F;计算时间文件：function[T]=TOTALT(Xp1)Xp=Xp1;t=[0,0.16,0.08,0.1,0.09,0.05;0.16,0,0.07,0.05,0.11,0.1;0.08,0.07,0,0.04,0.08,0.03;...0.1,0.05,0.04,0,0.09,0.07;0.09,0.11,0.08,0.09,0,0.10;0.05,0.1,0.03,0.07,0.1,0;];%行驶时间矩阵w=[0.15,0.2,0.18,0.25,0.22];%服务时间矩阵%%时间窗向量early=[0.15,0.3,0.7,0.4,0.7];T=t(1,Xp(1)+1);if T<early(Xp(1))T=early(Xp(1));endT=T+w(Xp(1));for i=2:5T=T+t(Xp(i-1)+1,Xp(i)+1);if T<early(Xp(i))T=early(Xp(1));endT=T+w(Xp(i));endT=T+t(1,Xp(5)+1);方案二的程序编码主函数文件：function[Xp,LC1,LC2,LC3]=CLBGA9(M,Pm)%%%陈璐斌编程，解决VRP问题（带时间窗）%%输入参数%M遗传进化迭代次数%Pm变异概率%%输出参数%Xp最优个体%LC1子目标2收敛曲线%LC2平均适应度收敛曲线%LC3最优适应度收敛曲线%%%变量初始化Xp=zeros(1,6);LC1=zeros(1,M);LC2=zeros(1,M);LC3=zeros(1,M);Best=inf;%%编码方式-第一步：产生初始种群N=10;%N 种群规模%Q=[2.4,3.3,2.1,2.7,2.3,1.6,2.0,1.2,3.6,1.9];%需求矩阵farm=cell(1,N);%存储种群的细胞结构k=1;while (N-k>=0)G=randperm(6);%产生6个客户的全排列farm{k}=G;k=k+1;end%%%进化迭代计数器counter=1;while counter<=M%%第二步：交叉%交叉采用双亲双子单点交叉N=10;%种群规模newfarm=cell(1,2*N-4);%存储子代的细胞结构Ser=randperm(N);%两两随机配对表生成for i=1:(N-2)%避免交叉概率为1A=farm{Ser(i)};B=farm{Ser(i+1)};%取出父代P0=unidrnd(6);%随机选择交叉点aa=zeros(1,6);bb=zeros(1,6);A_=A;B_=B;for ii=1:6-P0aa(ii)=B(P0+ii);endfor ii=1:6-P0for iiii=1:6if(B(P0+ii)==A_(iiii))A_(iiii)=0;endendendfor iii=7-P0:6for iiii=1:6if(A_(iiii)~=0)aa(iii)=A_(iiii);A_(iiii)=0;breakendendendfor ii=1:6-P0bb(ii)=A(P0+ii);endfor ii=1:6-P0for iiii=1:6if(A(P0+ii)==B_(iiii))B_(iiii)=0;endendendfor iii=7-P0:6for iiii=1:6if(B_(iiii)~=0)bb(iii)=B_(iiii);B_(iiii)=0;breakendendend%产生子代newfarm{2*i-1}=aa;newfarm{2*i}=bb;endFARM=[farm,newfarm];%新旧种群合并%%第三步：选择复制%%计算当前种群适应度并存储N=10;SYZ=zeros(1,3*N-4);syz=zeros(1,3*N-4);for i=1:(3*N-4)x=FARM{i};SYZ(i)=clb9(x);end%%选择复制，较优的N个个体复制到下一代k=1;while k<=(3*N-4)maxSYZ=max(SYZ);posSYZ=find(SYZ==maxSYZ);POS=posSYZ(1);k=k+1;farm{k}=FARM{POS};syz(k)=SYZ(POS);SYZ(POS)=0;end%记录和更新，更新最优个体，记录收敛曲线数据maxsyz=max(syz);meansyz=mean(syz);pos=find(syz==maxsyz);LC2(counter+1)=meansyz;if maxsyzBest=maxsyz;Xp=farm{pos(1)};endLC3(counter+1)=Best;d=[0,6.4,3.2,3.9,3.7,35,2;6.4,0,2.9,2.1,4.5,32.5,4.1;3.2,2.9,0,1.5,3.3,35.7,1.2;3.9,2.1,1.5,0,3.6,34.5,2.6;...3.7,4.5,3.3,3.6,0,37,3.8;35,32.5,35.7,34.5,37,0,38.5;2,4.1,1.2,2.6,3.8,38.5,0];%距离矩阵t=[0,0.16,0.08,0.1,0.1,0.88,0.05;0.16,0,0.07,0.05,0.11,0.81,0.1;0.08,0.07,0,0.04,0.08,0.9,0.03;...0.1,0.05,0.04,0,0.09,0.86,0.07;0.1,0.11,0.08,0.09,0,0.92,0.1;0.88,0.81,0.9,0.86,0.92,0,0.96;...0.05,0.1,0.03,0.07,0.1,0.96,0;];%行驶时间矩阵w=[0.15,0.2,0.18,0.25,0.2,0.22];%服务时间矩阵%%时间窗向量early=[0.15,0.3,0.7,0.4,0.7,0.6];xx=x;%取出染色体j=1;%分工点初始化%%取距离向量d1,d2d1=zeros(1,7);d1(1)=d(1,xx(1)+1);for i=1:5d1(i+1)=d(xx(i)+1,xx(i+1)+1);endd1(7)=d(xx(6)+1,1);%%时间窗计算T=t(1,xx(1)+1);pun1=0;if T<early(xx(1))pun1=early(xx(1))-T;T=early(xx(1));endT=T+w(xx(1));for i=2:6T=T+t(xx(i-1)+1,xx(i)+1);if T<early(xx(i))pun1=pun1+early(xx(i))-T;T=early(xx(i));endT=T+w(xx(6));endF=sum(10.*d1) +20*pun1;LC1(counter+1)=F;%%第四步：变异N=10;for i=1:Nif Pm>randAA=farm{i};POS1=unidrnd(6);POS2=unidrnd(6);temp=AA(POS1);AA(POS1)=AA(POS2);AA(POS2)=temp;farm{i}=AA;endendcounter=counter+1;end%%第五步：绘制收敛曲线图figure(2);plot(LC1);xlabel('迭代次数');ylabel('目标的值');title('目标的收敛曲线');figure(3);plot(LC2);xlabel('迭代次数');ylabel('适应度函数的平均值');title('平均适应度函数的收敛曲线');figure(4);plot(LC3);xlabel('迭代次数');ylabel('适应度函数的最优值');title('最优适应度函数的收敛曲线');适应度文件：%%计算载重量和时间窗%%适应度函数计算function Fitness=clb9(x)d=[0,6.4,3.2,3.9,3.7,35,2;6.4,0,2.9,2.1,4.5,32.5,4.1;3.2,2.9,0,1.5,3.3,35.7,1.2;3.9,2.1,1.5,0,3.6,34.5,2.6;...3.7,4.5,3.3,3.6,0,37,3.8;35,32.5,35.7,34.5,37,0,38.5;2,4.1,1.2,2.6,3.8,38.5,0];%距离矩阵t=[0,0.16,0.08,0.1,0.1,0.88,0.05;0.16,0,0.07,0.05,0.11,0.81,0.1;0.08,0.07,0,0.04,0.08,0.9,0.03;...0.1,0.05,0.04,0,0.09,0.86,0.07;0.1,0.11,0.08,0.09,0,0.92,0.1;0.88,0.81,0.9,0.86,0.92,0,0.96;...0.05,0.1,0.03,0.07,0.1,0.96,0;];%行驶时间矩阵w=[0.15,0.2,0.18,0.25,0.2,0.22];%服务时间矩阵%%时间窗向量early=[0.15,0.3,0.7,0.4,0.7,0.6];late=[2.5,3.4,3.3,2.7,2.5,4.5];xx=x;%取出染色体j=1;%分工点初始化%%取距离向量d1,d2d1=zeros(1,7);d1(1)=d(1,xx(1)+1);for i=1:5d1(i+1)=d(xx(i)+1,xx(i+1)+1);endd1(7)=d(xx(6)+1,1);%%时间窗计算T=t(1,xx(1)+1);pun1=0;if T<early(xx(1))pun1=early(xx(1))-T;T=early(xx(1));endT=T+w(xx(1));for i=2:6T=T+t(xx(i-1)+1,xx(i)+1);if T<early(xx(i))pun1=pun1+early(xx(i))-T;T=early(xx(i));endT=T+w(xx(6));endF=sum(10.*d1) +20*pun1;Fitness=1/F;计算时间文件：function[T]=TOTALT2(Xp1)Xp=Xp1;t=[0,0.16,0.08,0.1,0.1,0.88,0.05;0.16,0,0.07,0.05,0.11,0.81,0.1;0.08,0.07,0,0.04,0.08,0.9,0.03;...0.1,0.05,0.04,0,0.09,0.86,0.07;0.1,0.11,0.08,0.09,0,0.92,0.1;0.88,0.81,0.9,0.86,0.92,0,0.96;... 0.05,0.1,0.03,0.07,0.1,0.96,0;];%行驶时间矩阵w=[0.15,0.2,0.18,0.25,0.2,0.22];%服务时间矩阵%%时间窗向量early=[0.15,0.3,0.7,0.4,0.7,0.6];T=t(1,Xp(1)+1);if T<early(Xp(1))T=early(Xp(1));endT=T+w(Xp(1));for i=2:6T=T+t(Xp(i-1)+1,Xp(i)+1);if T<early(Xp(i))T=early(Xp(1));endT=T+w(Xp(i));endT=T+t(1,Xp(6)+1)。

遗传算法matlab函数的源程序

chi(j,i)=rand();
end
end
end
%确定下一代父代个体
%确定实际子代个体数值
chi_fact=zeros(x_num,chi_num*3);
for j=1:x_num
chi_fact(j,:)=x_range(j,1)+(x_range(j,2)-x_range(j,1))*chi(j,:);
par=chi(:,chi_ada_no(1:par_num));
end ');
par_fac_exc(:,1)=x_range(:,1)+(x_range(:,2)-x_range(:,1)).*par(:,1);%父代个体最优函数值
par_fun_exc=fun(par_fac_exc);
%输出父代样本实际值
par_fact=zeros(x_num,par_num);
for i=1:x_num
par_fact(i,:)=x_range(i,1)+(x_range(i,2)-x_range(i,1))*par(i,:);
if chi_ran(3)<0.5
chi(j,i)=chi_ran(1)*par(j,chi_sel1)+(1-chi_ran(1))*par(j,chi_sel2);
else
chi(j,i)=chi_ran(2)*par(j,chi_sel1)+(1-chi_ran(2))*par(j,chi_sel2);
%例子2：
%fun=@(x) sum(x.*x-cos(18*x))+5;
%x_range=[-1,1;-1,1;-1,1;-1,1;-1,1];

数学实验七：遗传算法实验报告

数学实验七：遗传算法实验报告实验七遗传算法1．⽤Matlab编制另⼀个主程序Genetic2.m，求例1的在第⼆种终⽌条件下的最优解．提⽰：⼀个可能的函数调⽤形式以及相应的结果为：[Count,Result,BestMember]=Genetic2(22,6,'-x*x+2*x+0.5',-1,2,-2,0.01,0.00001) % 附录1 Genetic2.mfunction[Count,Result,BestMember]=Genetic2(MumberLength,MemberNumber,FunctionFitness,MinX,MaxX,Fmin,MutationProbability,Precision)Population=PopulationInitialize(MumberLength,MemberNumber);Error=Precision+1;global Count;global CurrentBest;Count=1;PopulationCode=Population;PopulationFitness=Fitness(PopulationCode,FunctionFitness,MinX,MaxX,MumberLength); %⽤于计算群体中每⼀个染⾊体的⽬标函数值PopulationFitnessF=FitnessF(PopulationFitness,Fmin); %⽤于计算每个染⾊体的适应函数值PopulationProbability=Probability(PopulationFitnessF); %⽤于计算群体中每个染⾊体的⼊选概率[Population,CurrentBest,EachGenMaxFitness]=Elitist(PopulationCode,PopulationFitness ,MumberLength); %⽤到最佳个体保存⽅法（“优胜劣汰”思想）EachMaxFitness(Count)=EachGenMaxFitness;MaxFitness(Count)=CurrentBest(length(CurrentBest));while Error>PrecisionNewPopulation=Select(Population,PopulationProbability,MemberNumber);Population=NewPopulation;NewPopulation=Crossing(Population,FunctionFitness,MinX,MaxX,MumberLength);Population=NewPopulation;NewPopulation=Mutation(Population,MutationProbability);Population=NewPopulation;PopulationFitness=Fitness(Population,FunctionFitness,MinX,MaxX,MumberLength);PopulationFitnessF=FitnessF(PopulationFitness,Fmin);PopulationProbability=Probability(PopulationFitnessF);Count=Count+1;[NewPopulation,CurrentBest,EachGenMaxFitness]=Elitist(Population,PopulationFitness, MumberLength); EachMaxFitness(Count)=EachGenMaxFitness;MaxFitness(Count)=CurrentBest(length(CurrentBest));Error=sum(abs(PopulationProbability-mean(PopulationProbability)));实验七遗传算法Population=NewPopulation;endDim=size(Population);Result=ones(2,Dim(1));for i=1:Dim(1)Result(1,i)=Translate(Population(i,:),MinX,MaxX,MumberLength);endResult(2,:)=PopulationFitness;BestMember(1,1)=Translate(CurrentBest(1:MumberLength),MinX,MaxX,MumberLength); BestMember(2,1)=CurrentBest(MumberLength+1);close allsubplot(211)plot(EachMaxFitness)subplot(212)plot(MaxFitness)>> [Count,Result,BestMember]=Genetic2(22,6,'-x*x+2*x+0.5',-1,2,-2,0.01,0.00001) Count = 11Result =0.9748 0.9748 0.9748 0.9748 0.9748 0.97481.4994 1.4994 1.4994 1.4994 1.4994 1.4994BestMember =0.97481.4994123456789101112345678910112．按照例2的具体要求，⽤遗传算法求上述例2的最优解．>> [Count,Result,BestMember]=Genetic1(20,6,'-x*x+x+3',0,2,1,0.01,50)实验七遗传算法50Result =0.6880 0.6880 0.6880 0.6880 0.6880 0.68803.2146 3.2146 3.2146 3.2146 3.2146 3.2146 BestMember =0.68803.2146051015202530354045503．附录9⼦程序Crossing.m中的第8⾏⾄第13⾏的程序表明，当Dim(1)>=3时，将交换数组Population的最后两⾏，即交换最后⾯的两个个体．其⽬的是什么？4．设2f x x∈-，要设定求解精度到15位⼩数．=--+，求max(),[2,2]f x x x()41>> [Count,Result,BestMember]=Genetic2(22,6,'-x*x-4*x+1',-2,2,-12,0.01,1e-15)Count =15Result =-1.8728 -1.8728 -1.8728 -1.8728 -1.8728 -1.87284.9838 4.9838 4.9838 4.9838 4.9838 4.9838 BestMember =-1.87284.9838实验七遗传算法4.854.94.9555.050510154.98384.9838 4.98384.98384.98384.9838。

遗传算法介绍并附上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个猴子吧。

遗传算法matlab代码

function youhuafunD=code;N=50; % Tunablemaxgen=50; % Tunablecrossrate=0.5; %Tunablemuterate=0.08; %Tunablegeneration=1;num = length(D);fatherrand=randint(num,N,3);score = zeros(maxgen,N);while generation<=maxgenind=randperm(N-2)+2; % 随机配对交叉A=fatherrand(:,ind(1:(N-2)/2));B=fatherrand(:,ind((N-2)/2+1:end));% 多点交叉rnd=rand(num,(N-2)/2);ind=rnd tmp=A(ind);A(ind)=B(ind);B(ind)=tmp;% % 两点交叉% for kk=1:(N-2)/2% rndtmp=randint(1,1,num)+1;% tmp=A(1:rndtmp,kk);% A(1:rndtmp,kk)=B(1:rndtmp,kk);% B(1:rndtmp,kk)=tmp;% endfatherrand=[fatherrand(:,1:2),A,B];% 变异rnd=rand(num,N);ind=rnd [m,n]=size(ind);tmp=randint(m,n,2)+1;tmp(:,1:2)=0;fatherrand=tmp+fatherrand;fatherrand=mod(fatherrand,3);% fatherrand(ind)=tmp;%评价、选择scoreN=scorefun(fatherrand,D);% 求得N个个体的评价函数score(generation,:)=scoreN;[scoreSort,scoreind]=sort(scoreN);sumscore=cumsum(scoreSort);sumscore=sumscore./sumscore(end);childind(1:2)=scoreind(end-1:end);for k=3:Ntmprnd=rand;tmpind=tmprnd difind=[0,diff(tmpind)];if ~any(difind)difind(1)=1;endchildind(k)=scoreind(logical(difind));endfatherrand=fatherrand(:,childind);generation=generation+1;end% scoremaxV=max(score,[],2);minV=11*300-maxV;plot(minV,'*');title('各代的目标函数值');F4=D(:,4);FF4=F4-fatherrand(:,1);FF4=max(FF4,1);D(:,5)=FF4;save DData Dfunction D=codeload youhua.mat% properties F2 and F3F1=A(:,1);F2=A(:,2);F3=A(:,3);if (max(F2)>1450)||(min(F2)<=900)error('DATA property F2 exceed it''s range (900,1450]') end% get group property F1 of data, according to F2 value F4=zeros(size(F1));for ite=11:-1:1index=find(F2<=900+ite*50);F4(index)=ite;endD=[F1,F2,F3,F4];function ScoreN=scorefun(fatherrand,D)F3=D(:,3);F4=D(:,4);N=size(fatherrand,2);FF4=F4*ones(1,N);FF4rnd=FF4-fatherrand;FF4rnd=max(FF4rnd,1);ScoreN=ones(1,N)*300*11;% 这里有待优化for k=1:NFF4k=FF4rnd(:,k);for ite=1:11F0index=find(FF4k==ite);if ~isempty(F0index)tmpMat=F3(F0index);tmpSco=sum(tmpMat);ScoreBin(ite)=mod(tmpSco,300);endendScorek(k)=sum(ScoreBin);endScoreN=ScoreN-Scorek;遗传算法实例:% 下面举例说明遗传算法%% 求下列函数的最大值%% f(x)=10*sin(5x)+7*cos(4x) x∈[0,10] %% 将x 的值用一个10位的二值形式表示为二值问题，一个10位的二值数提供的分辨率是每为(10-0)/(2^10-1)≈0.01 。

遗传算法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函数用于变异子代。

遗传算法matlab实现源程序

附页：一．遗传算法源程序：clc;clear;population;%评价目标函数值for uim=1:popsizevector=population(uim,:);obj(uim)=hanshu(hromlength,vector,phen); end%obj%min(obj)clear uim;objmin=min(obj);for sequ=1:popsizeif obj(sequ)==objminopti=population(sequ,:);endendclear sequ;fmax=22000;%==for gen=1:maxgen%选择操作%将求最小值的函数转化为适应度函数for indivi=1:popsizeobj1(indivi)=1/obj(indivi);endclear indivi;%适应度函数累加总合total=0;for indivi=1:popsizetotal=total+obj1(indivi);endclear indivi;%每条染色体被选中的几率for indivi=1:popsizefitness1(indivi)=obj1(indivi)/total;endclear indivi;%各条染色体被选中的范围for indivi=1:popsizefitness(indivi)=0;for j=1:indivifitness(indivi)=fitness(indivi)+fitness1(j);endendclear j;fitness;%选择适应度高的个体for ranseti=1:popsizeran=rand;while (ran>1||ran<0)ran=rand;endran;if ran<=fitness(1)newpopulation(ranseti,:)=population(1,:);elsefor fet=2:popsizeif (ran>fitness(fet-1))&&(ran<=fitness(fet))newpopulation(ranseti,:)=population(fet,:);endendendendclear ran;newpopulation;%交叉for int=1:2:popsize-1popmoth=newpopulation(int,:);popfath=newpopulation(int+1,:);popcross(int,:)=popmoth;popcross(int+1,:)=popfath;randnum=rand;if(randnum< P>cpoint1=round(rand*hromlength);cpoint2=round(rand*hromlength);while (cpoint2==cpoint1)cpoint2=round(rand*hromlength);endif cpoint1>cpoint2tem=cpoint1;cpoint1=cpoint2;cpoint2=tem;endcpoint1;cpoint2;for term=cpoint1+1:cpoint2for ss=1:hromlengthif popcross(int,ss)==popfath(term)tem1=popcross(int,ss);popcross(int,ss)=popcross(int,term);popcross(int,term)=tem1;endendclear tem1;endfor term=cpoint1+1:cpoint2for ss=1:hromlengthif popcross(int+1,ss)==popmoth(term)tem1=popcross(int+1,ss);popcross(int+1,ss)=popcross(int+1,term);popcross(int+1,term)=tem1;endendclear tem1;endendclear term;endclear randnum;popcross;%变异操作newpop=popcross;for int=1:popsizerandnum=rand;if randnumcpoint12=round(rand*hromlength);cpoint22=round(rand*hromlength);if (cpoint12==0)cpoint12=1;endif (cpoint22==0)cpoint22=1;endwhile (cpoint22==cpoint12)cpoint22=round(rand*hromlength);if cpoint22==0;cpoint22=1;endendtemp=newpop(int,cpoint12);newpop(int,cpoint12)=newpop(int,cpoint22);newpop(int,cpoint22)=temp;endendnewpop;clear cpoint12;clear cpoint22;clear randnum;clear int;for ium=1:popsizevector1=newpop(ium,:);obj1(ium)=hanshu(hromlength,vector1,phen);endclear ium;obj1max=max(obj1);for ar=1:popsizeif obj1(ar)==obj1maxnewpop(ar,:)=opti;endend%遗传操作结束二．粒子群算法源程序：%------初始格式化-------------------------------------------------- clear all;clc;format long;%------给定初始化条件---------------------------------------------- c1=1.4962;%学习因子1c2=1.4962;%学习因子2w=0.7298;%惯性权重MaxDT=100;%最大迭代次数D=2;%搜索空间维数（未知数个数）N=40;%初始化群体个体数目eps=10^(-6);%设置精度(在已知最小值时候用)%------初始化种群的个体(可以在这里限定位置和速度的范围)------------ for i=1:Nfor j=1:Dx(i,j)=randn;%随机初始化位置v(i,j)=randn;%随机初始化速度endend%------先计算各个粒子的适应度，并初始化Pi和Pg---------------------- for i=1:Np(i)=fitness(x(i,:),D);y(i,:)=x(i,:);endpg=x(1,:);%Pg为全局最优for i=2:Nif fitness(x(i,:),D)<FITNESS(pg,D)pg=x(i,:);endend%------进入主要循环，按照公式依次迭代，直到满足精度要求------------ for t=1:MaxDTtfor i=1:Nv(i,:)=w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:)); x(i,:)=x(i,:)+v(i,:);if fitness(x(i,:),D)<p(i)p(i)=fitness(x(i,:),D);y(i,:)=x(i,:);endif p(i)<FITNESS(pg,D)pg=y(i,:);endendPbest(t)=fitness(pg,D);end%------进入主要循环，按照公式依次迭代，直到满足精度要求------------ for t=1:MaxDTfor i=1:Nv(i,:)=w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:));x(i,:)=x(i,:)+v(i,:);if fitness(x(i,:),D)<p(i)p(i)=fitness(x(i,:),D);y(i,:)=x(i,:);endif p(i)<FITNESS(pg,D)pg=y(i,:);endendPbest(t)=fitness(pg,D);end%------最后给出计算结果disp('*************************************************************') disp('函数的全局最优位置为：')Solution=pg'disp('最后得到的优化极值为：')Result=fitness(pg,D)disp('*************************************************************') [X,Y]=meshgrid(-500:2:500);Z=X.*sin(sqrt(X))+Y.*(sin(sqrt(Y)));hold oncontour(X,Y,Z)plot(x(:,1),x(:,2),'*');hold off。

遗传算法的实验报告

遗传算法的仿真一.实验目的1.了解遗传算法的原理2.学习Matlab遗传算法工具箱的使用3.使用Matlab进行遗传算法的仿真二.实验设备1.计算机2.Matlab软件三.实验内容和步骤要求：计算目标函数值函数：()()[]2,1x=xxfπ。

x+0.2∈*10sin-1.建立目标函数文件。

在Matlab命令窗口中，选择“file”→“new”→“M-file”，命名为ft.m，然后在新建的窗口中输入如下内容：%目标函数function y=ft(x)y=x.*sin(10*pi*x)+2;2.分别建立相应的子函数文件。

1)计算适应度和累计概率函数在Matlab命令窗口中，选择“file”→“new”→“M-file”，命名为objf.m，然后在新建的窗口中输入如下内容：function [f,p]=objf(s) %计算适应度函数r=size(s); %读取种群大小inn=r(1); %有inn个个体bn=r(2); %个体长度为bnfor i=1:innx=n2to10(s(i,:)); %将二进制转换为十进制xx=-1.0+x*3/(power(2,bn)-1); %转化为[-1,2]区间的实数f(i)=ft(xx); %计算函数值，即适应度endf=f';%计算选择概率fsum=0;for i=1:innfsum=fsum+f(i)*f(i);endfor i=1:innps(i)=f(i)*f(i)/fsum;%计算累积概率p(1)=ps(1);for i=2:innp(i)=p(i-1)+ps(i);endp=p';end2)选择操作函数在Matlab命令窗口中，选择“file”→“new”→“M-file”，命名为sel.m，然后在新建的窗口中输入如下内容：function seln=sel(s,p)%“选择”操作inn=size(p,1);for i=1:2 %从种群中选择两个个体r=rand;%产生一个随机数prand=p-r;j=1;while prand(j)<0j=j+1;endseln(i)=j; %选中个体的序号end3)交叉操作函数在Matlab命令窗口中，选择“file”→“new”→“M-file”，命名为cro.m，然后在新建的窗口中输入如下内容：function scro=cro(s,seln,pc) %“交叉”操作r=size(s);inn=r(1);bn=r(2);pcc=pro(pc); %根据交叉概率决定是否进行交叉操作，1则是，0则。

遗传算法Matlab代码

遗传算法优缺点遗传算法的优点：1. 与问题领域无关切快速随机的搜索能力。

2. 搜索从群体出发，具有潜在的并行性，可以进行多个个体的同时比较，robust.3. 搜索使用评价函数启发，过程简单4. 使用概率机制进行迭代，具有随机性。

5. 具有可扩展性，容易与其他算法结合。

缺点是：1。

没有能够及时利用网络的反馈信息,故算法的搜索速度比较慢，要得要较精确的解需要较多的训练时间。

2。

算法对初始种群的选择有一定的依赖性，能够结合一些启发算法进行改进。

3。

算法的并行机制的潜在能力没有得到充分的利用，这也是当前遗传算法的一个研究热点方向。

核心函数：(1)function [pop]=initializega(num,bounds,eevalFN,eevalOps,options)--初始种群的生成函数【输出参数】pop--生成的初始种群【输入参数】num--种群中的个体数目bounds--代表变量的上下界的矩阵eevalFN--适应度函数eevalOps--传递给适应度函数的参数options--选择编码形式(浮点编码或是二进制编码)[precision F_or_B],如precision--变量进行二进制编码时指定的精度F_or_B--为1时选择浮点编码，否则为二进制编码,由precision指定精度)(2)function [x,endPop,bPop,traceInfo] = ga(bounds,evalFN,evalOps,startPop,opts,...termFN,termOps,selectFN,selectOps,xOverFNs,xOverOps,mutFNs,mutOps)--遗传算法函数【输出参数】x--求得的最优解endPop--最终得到的种群bPop--最优种群的一个搜索轨迹【输入参数】bounds--代表变量上下界的矩阵evalFN--适应度函数evalOps--传递给适应度函数的参数startPop-初始种群opts[epsilon prob_ops display]--opts(1:2)等同于initializega的options参数，第三个参数控制是否输出，一般为0。

遗传算法经典MATLAB代码

遗传算法经典学习Matlab代码遗传算法实例:也是自己找来的，原代码有少许错误，本人都已更正了，调试运行都通过了的。

对于初学者，尤其是还没有编程经验的非常有用的一个文件遗传算法实例% 下面举例说明遗传算法%% 求下列函数的最大值%% f(x)=10*sin(5x)+7*cos(4x) x∈[0,10]%% 将x 的值用一个10位的二值形式表示为二值问题，一个10位的二值数提供的分辨率是每为(10-0)/(2^10-1)≈0.01。

%% 将变量域[0,10] 离散化为二值域[0,1023], x=0+10*b/1023, 其中 b 是[0,1023] 中的一个二值数。

%% %%--------------------------------------------------------------------------------------------------------------%%--------------------------------------------------------------------------------------------------------------%% 编程%-----------------------------------------------% 2.1初始化(编码)% initpop.m函数的功能是实现群体的初始化，popsize表示群体的大小，chromlength表示染色体的长度(二值数的长度)，% 长度大小取决于变量的二进制编码的长度(在本例中取10位)。

%遗传算法子程序%Name: initpop.m%初始化function pop=initpop(popsize,chromlength)pop=round(rand(popsize,chromlength)); % rand随机产生每个单元为{0,1} 行数为popsize，列数为chromlength的矩阵，% roud对矩阵的每个单元进行圆整。

matlab智能算法代码

matlab智能算法代码MATLAB是一种功能强大的数值计算和科学编程软件，它提供了许多智能算法的实现。

下面是一些常见的智能算法及其在MATLAB中的代码示例：1. 遗传算法（Genetic Algorithm）：MATLAB中有一个专门的工具箱，称为Global Optimization Toolbox，其中包含了遗传算法的实现。

以下是一个简单的遗传算法示例代码：matlab.% 定义目标函数。

fitness = @(x) x^2;% 设置遗传算法参数。

options = gaoptimset('Display', 'iter','PopulationSize', 50);% 运行遗传算法。

[x, fval] = ga(fitness, 1, options);2. 粒子群优化算法（Particle Swarm Optimization）：MATLAB中也有一个工具箱，称为Global Optimization Toolbox，其中包含了粒子群优化算法的实现。

以下是一个简单的粒子群优化算法示例代码：matlab.% 定义目标函数。

fitness = @(x) x^2;% 设置粒子群优化算法参数。

options = optimoptions('particleswarm', 'Display','iter', 'SwarmSize', 50);% 运行粒子群优化算法。

[x, fval] = particleswarm(fitness, 1, [], [], options);3. 支持向量机（Support Vector Machine）：MATLAB中有一个机器学习工具箱，称为Statistics and Machine Learning Toolbox，其中包含了支持向量机的实现。

遗传算法matlab程序代码

function [R,Rlength]= GA_TSP(xyCity,dCity,Population,nPopulation,pCrossover,percent,pMutation,generation,nR,rr,rang eCity,rR,moffspring,record,pi,Shock,maxShock)clear allA=load('d.txt');AxyCity=[A(1,:);A(2,:)]; %x,y为各地点坐标xyCityfigure(1)grid onhold onscatter(xyCity(1,:),xyCity(2,:),'b+')grid onnCity=50;nCityfor i=1:nCity %计算城市间距离for j=1:nCitydCity(i,j)=abs(xyCity(1,i)-xyCity(1,j))+abs(xyCity(2,i)-xyCity(2,j));endend %计算城市间距离xyCity; %显示城市坐标dCity %显示城市距离矩阵%初始种群k=input('取点操作结束'); %取点时对操作保护disp('-------------------')nPopulation=input('种群个体数量：'); %输入种群个体数量if size(nPopulation,1)==0nPopulation=50; %默认值endfor i=1:nPopulationPopulation(i,:)=randperm(nCity-1); %产生随机个体endPopulation %显示初始种群pCrossover=input('交叉概率：'); %输入交叉概率percent=input('交叉部分占整体的百分比：'); %输入交叉比率pMutation=input('突变概率：'); %输入突变概率nRemain=input('最优个体保留最大数量：');pi(1)=input('选择操作最优个体被保护概率：');%输入最优个体被保护概率pi(2)=input('交叉操作最优个体被保护概率：');pi(3)=input('突变操作最优个体被保护概率：');maxShock=input('最大突变概率：');if size(pCrossover,1)==0pCrossover=0.85;endif size(percent,1)==0percent=0.5;endif size(pMutation,1)==0pMutation=0.05;endShock=0;rr=0;Rlength=0;counter1=0;counter2=0;R=zeros(1,nCity-1);[newPopulation,R,Rlength,counter2,rr]=select(Population,nPopulation,nCity,dCity,Rlength,R,coun ter2,pi,nRemain);R0=R;record(1,:)=R;rR(1)=Rlength;Rlength0=Rlength;generation=input('算法终止条件A.最多迭代次数：');%输入算法终止条件if size(generation,1)==0generation=200;endnR=input('算法终止条件B.最短路径连续保持不变代数：');if size(nR,1)==0nR=10;endwhile counter1<generation&counter2<nRif counter2<nR*1/5Shock=0;elseif counter2<nR*2/5Shock=maxShock*1/4-pMutation;elseif counter2<nR*3/5Shock=maxShock*2/4-pMutation;elseif counter2<nR*4/5Shock=maxShock*3/4-pMutation;elseShock=maxShock-pMutation;endcounter1newPopulationoffspring=crossover(newPopulation,nCity,pCrossover,percent,nPopulation,rr,pi,nRemain);offspringmoffspring=Mutation(offspring,nCity,pMutation,nPopulation,rr,pi,nRemain,Shock);[newPopulation,R,Rlength,counter2,rr]=select(moffspring,nPopulation,nCity,dCity,Rlength,R,coun ter2,pi,nRemain);counter1=counter1+1;rR(counter1+1)=Rlength;record(counter1+1,:)=R;endR0;Rlength0;R;Rlength;minR=min(rR);disp('最短路经出现代数:')rr=find(rR==minR)disp('最短路经:')record(rr,:);mR=record(rr(1,1),:)disp('终止条件一:')counter1disp('终止条件二:')counter2disp('最短路经长度:')minRdisp('最初路经长度:')rR(1)figure(2)plotaiwa(xyCity,mR,nCity)figure(3)i=1:counter1+1;plot(i,rR(i))grid onfunction[newPopulation,R,Rlength,counter2,rr]=select(Population,nPopulation,nCity,dCity,Rlength,R,coun ter2,pi,nRemain)Distance=zeros(nPopulation,1); %零化路径长度Fitness=zeros(nPopulation,1); %零化适应概率Sum=0; %路径长度for i=1:nPopulation %计算个体路径长度for j=1:nCity-2Distance(i)=Distance(i)+dCity(Population(i,j),Population(i,j+1));end %对路径长度调整，增加起始点到路径首尾点的距离Distance(i)=Distance(i)+dCity(Population(i,1),nCity)+dCity(Population(i,nCity-1),nCity);Sum=Sum+Distance(i); %累计总路径长度end %计算个体路径长度if Rlength==min(Distance)counter2=counter2+1;elsecounter2=0;endRlength=min(Distance); %更新最短路径长度Rlength;rr=find(Distance==Rlength);R=Population(rr(1,1),:); %更新最短路径for i=1:nPopulationFitness(i)=(max(Distance)-Distance(i)+0.001)/(nPopulation*(max(Distance)+0.001)-Sum); %适应概率=个体/总和。

matlab遗传算法代码

matlab遗传算法代码
1 、算法概述
遗传算法（Genetic Algorithms，GA）是一种仿生学优化算法，它借用遗传学中物
竞天择的进化规则，模拟“自然选择”与“遗传进化”得出选择最优解的过程。

其基本原
理是对现有的种群中的各个个体，将其表示成某种形式的编码，然后根据自变量与约束条件，利用杂交、变异等操作，产生新一代解的种群，不断重复这一过程，最终求出收敛到
最优解的种群。

2、遗传算法的作用
遗传算法的主要作用在于优化多元函数，能够在大量的变量影响目标函数值的情况下
寻求最优解。

和其它现有的数值优化技术比较，如梯度下降法等，遗传算法更能适应“凸”和“非凸”都能解决，不受约束条件与搜索空间的影响较大，又叫做“智能搜索法”。

在
计算机视觉等计算机技术领域，经常用遗传算法来对一系列特征参数进行搜索和调节，成
功优化提高了系统的正确处理率。

3、matlab遗传算法的实现
Matlab的遗传算法应用是基于GA Toolbox工具箱，它提供了一个功能强大的、可扩
展的包装器，可用于构建遗传算法模型。

(1)编写最优化函数：
使用和设置最优化表达式或函数、变量；
(2)设置参数编码：
设置变量的编码，比如选择0-1二进制、0-10十进制；
(3)选择遗传算法的方法
选择遗传算法的方法，可以在多个选择中选择，比如变异、杂交等；
(4)设置运算参数：
设置每代的种群数、最大进化的世代数；
(5)运行遗传算法：
根据设定的参数运行遗传算法，算出收敛到最优解的种群；
(6)获得最优解：
获得收敛到最优解的条件下的最优解，得出最优解所在位置等参数，完成整个优化搜索。