遗传算法案例分析及源代码
python遗传算法代码

python遗传算法代码遗传算法是一种基于生物进化原理的优化算法,适用于解决复杂问题。
在Python中,可以使用遗传算法库DEAP (Distributed Evolutionary Algorithms in Python)来实现遗传算法。
DEAP是一个灵活且易于使用的遗传算法框架,提供了用于定义和执行遗传算法的工具。
下面介绍如何使用DEAP库来实现一个简单的遗传算法。
首先,需要安装DEAP库。
可以使用以下命令来安装:```pip install deap```接下来,我们开始编写遗传算法的代码示例。
下面是一个寻找函数f(x)的最小值的例子:```pythonimport randomfrom deap import base, creator, tools# 定义目标函数def f(x):return x**2 + 4*x + 4# 创建遗传算法的环境creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) creator.create("Individual", list, fitness=creator.FitnessMin)# 初始化遗传算法的参数toolbox = base.Toolbox()toolbox.register("attr_float", random.uniform, -10, 10) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_float, n=1)toolbox.register("population", tools.initRepeat, list,toolbox.individual)# 定义评估函数def evaluate(individual):x = individual[0]return f(x),# 定义遗传算法的操作toolbox.register("evaluate", evaluate)toolbox.register("select", tools.selTournament, tournsize=3) toolbox.register("mate", tools.cxTwoPoint)toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.1)# 设置遗传算法的参数population_size = 100n_generations = 100cxpb = 0.5mutpb = 0.2# 创建初始种群population = toolbox.population(n=population_size)# 进化for generation in range(n_generations):offspring = toolbox.select(population, len(population))offspring = [toolbox.clone(ind) for ind in offspring]for child1, child2 in zip(offspring[::2], offspring[1::2]):if random.random() < cxpb:toolbox.mate(child1, child2)del child1.fitness.valuesdel child2.fitness.valuesfor mutant in offspring:if random.random() < mutpb:toolbox.mutate(mutant)del mutant.fitness.valuesinvalid_ind = [ind for ind in offspring if not ind.fitness.valid] fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)for ind, fit in zip(invalid_ind, fitnesses):ind.fitness.values = fitpopulation[:] = offspring# 输出最优解best_individual = tools.selBest(population, k=1)[0]best_fitness = evaluate(best_individual)[0]print("Best individual:", best_individual)print("Best fitness:", best_fitness)```在上面的代码中,首先定义了目标函数f(x),然后创建了遗传算法的环境,包括创建适应度函数和个体类,以及注册遗传算法的操作。
遗传算法代码python

遗传算法代码python一、简介遗传算法是一种通过模拟自然选择和遗传学原理来寻找最优解的优化算法。
它广泛应用于各种领域,包括优化问题、搜索和机器学习等。
二、代码概述以下是一个简单的遗传算法的Python代码示例,用于解决简单的优化问题。
该算法使用一个简单的二进制编码方式,并使用适应度函数来评估每个个体的适应度。
三、代码实现```pythonimportnumpyasnp#遗传算法参数POPULATION_SIZE=100#种群规模CROSSOVER_RATE=0.8#交叉概率MUTATION_RATE=0.1#变异概率MAX_GENERATIONS=100#最大迭代次数#适应度函数deffitness(individual):#在这里定义适应度函数,评估每个个体的适应度#这里简单地返回个体值的平方,可以根据实际问题进行调整returnnp.sum(individual**2)#初始种群生成pop=np.random.randint(2,size=(POPULATION_SIZE,))#迭代过程forgenerationinrange(MAX_GENERATIONS):#评估种群中每个个体的适应度fitness_values=np.apply_along_axis(fitness,1,pop)#选择种群selected_idx=np.random.choice(np.arange(POPULATION_SIZE), size=POPULATION_SIZE,replace=True,p=fitness_values/fitness_va lues.sum())selected_pop=pop[selected_idx]#交叉操作ifCROSSOVER_RATE>np.random.rand():cross_points=np.random.rand(POPULATION_SIZE,2)<0.5#随机选择交叉点cross_pop=np.array([np.hstack((individual[cross_points[i, 0]:cross_points[i,1]]+individual[cross_points[i,1]:],other))f ori,otherinenumerate(selected_pop)]).T#合并个体并随机交叉得到新的个体cross_pop=cross_pop[cross_points]#将交叉后的个体重新排列成原始种群大小selected_pop=np.vstack((selected_pop,cross_pop))#将新个体加入种群中#变异操作ifMUTATION_RATE>np.random.rand():mutated_pop=selected_pop+np.random.randn(POPULATION_SIZE, 1)*np.sqrt(np.log(POPULATION_SIZE))*(selected_pop!=pop).astyp e(np.float)#根据变异概率对个体进行变异操作,得到新的个体种群mutated_pop=mutated_pop[mutated_pop!=0]#将二进制种群中值为0的个体去掉,因为这些个体是随机的二进制串,不是解的一部分,不应该参与变异操作selected_pop=mutated_pop[:POPULATION_SIZE]#将新种群中除最后一个以外的部分加入原始种群中(即新的种群被排除了适应度最差的个体)#选择当前最好的个体(用于更新最优解)best_idx=np.argmax(fitness_values)best_solution=selected_pop[best_idx]print(f"Generation{generation}:Bestsolution:{best_solutio n}")```四、使用示例假设要解决一个简单的优化问题:求一个一维函数的最小值。
(完整版)遗传算法c语言代码

遗传算法代码# iiiclude<stdio.h>#mclude<stnng.h> #mclude<stdlib.h> #mclude<math.h> #mclude<tmie.h>^define cities 10 〃城市的个数 ^define MAXX ]00//迭代次数 #define pc 0.8 〃交配概率 #define pm 0.05 〃变异概率 ^define num 10〃种群的人小 int bestsolution;//最优染色体int distance[cities] [cities];// 城市之间的距离stmct group //染色体的结构{int city [cities];// 城市的顺序int adapt;// 适应度 double p 〃在种群中的幸存概率} group [num] ,grouptemp [num];〃随机产生10个城市之间的相互距离 voidinit(){intij ;meniset(distance.0.sizeof(distance)); srand((uiisigned)tuue(NULL)); fbr(i=O ;i<cities;i++){fbr(j=i+l ;j<cities J++){distance [i] [j]=rand()% 100; distance[j][i]=distance[i]Ij];} }fbr(i=O;i<cities;i++)printf( ”************ 城市的距离矩阵如下************\ii n );pruitf(M%4d H,distance[i][j]);}}〃随机产生初试群void groupproduceQ{mt i j 丄k,flag;fbi(i=O ;i<num; i++) //初始化for(j=OJ<citiesj++) group[i].city[j]=-l;srand((uiisigned)tuue(NULL));fbi(i=O ;i<num: i++)血(J=Oj<citi 亡s;){ t=rand()%cities;flag=l;for(k=0;k<j;k++){if(group[i] .city[k]=t){flag=O;break:}} if(flag){group[i].city|j]=t; J++;}}}pnntfC************ 初始种群如下^***************^);fbi(i=0;i<num: i++)血(J=0 J <citi 亡s;j++) pimtf(M%4d,\gioup[i].city[j]);〃评价函数,找岀最优染色体void pmgjiaQint ij;iiit nl,ii2;mt sumdistance5biggestsum=O; double biggestp=O;fdr(i=O;i<num; i++){sumdistance=O;{nl=group[i].city|j-l];n2=group[i].city[j]; sumdistance4-=distance[nl][n2];}group [1] .adapt=sumd istaiice; 〃每条染色体的路径总和biggestsum+=sumdistance; 〃种群的总路径}fbi(i=O ;i<num: i++){group [i].p= 1 -(double)gioup(i] .adapt/(double)biggestsum;biggestp+=group[i].p;}fbi(i=O ;i<num: i++)gioup[i] .p=gioup[i] .p./biggestp;〃求最佳路劲bestsolution=0;fbi(i=O ;i<num: i++) if(gioup[i].p>gioup[bestsolution].p) bestsolution=i; }〃选择void xuanzeQ{mt ij^temp;double gradient[num]^/梯度概率double xuaiize[num];//选择染色体的随机概率mt xuaii[num];//选择了的染色体〃初始化梯度概率fbi(i=O ;i<num: i++)gradient[i]=O.O; xuaiize[i]=O.O;}gradient[0]=gioup[0].p;fbr(i= 1 ;i<num:i++)gradient[i]=gradient[i-1 ]+group[i] .p; srand((uiisigned)tune(NULL));〃随机产生染色体的存活概率fdr(i=O;i<num: i++){xuanze[i]=(rand()% 100); xuaiize[i]/=100;}〃选择能生存的染色体fdr(i=0;i<num: i++){{if(xu aiize [i] <gradient [j ]){xuan[i]=j; //第i个位置存放第j个染色体break;}}}〃拷贝种群fdr(i=0;i<num: i++){grouptenip [i]. adapt=gioup [i].adapt;giouptemp[i] .p=group[i] .p;fbi(j=0 j <cities;j ++)grouptenip [i].citv|j]=group [i]. c ity[j ];}〃数据更新fdr(i=0;i<num: i++){temp=xuan[i];groupfi] .adapt=giouptemp[temp] .adapt;group [1] .p=giouptemp [temp] .p;fbi(j=0 j <cities;j ++)group[i].city[j]=grouptemp[tenip].city[j];〃变异void bianyiQ{intij;mt t;mt temp 1 ,temp2.point;double buinyip[num]; 〃染色体的变异概率mtbianyiflag[num];//染色体的变异情况fbi(i=O ;i<num: i++)〃初始化bianyiflag[i]=O;〃随机产生变异概率srand((uiisigned)tune(NULL));fbi(i=O ;i<num: i++){bianyip[i]=(rand()% 100); bianyip[i]/=100;}〃确定可以变异的染色体t=0;for(i=0 ;i<num; i++){if(biaiivip[i]<pm){ biaiiviflag[i]=l; t++;}}〃变异操作,即交换染色体的两个节点srand((iuisigned)tiine(NULL));for(i=0 ;i<num; i++){if(biaiiviflag[i]== 1){templ=rand()%10;temp2=rand()% 10;pomt=group[i]・ city[temp 1 ]; group [i]. city [temp1 ]=gioup [1]. city [temp2 ]; group[i] .city[temp2]=pomt;o e :a【n d(XXVINV£3n¥fo C T bB U T doQonpo】ddno・bb O -S Hg o q o ・Teqo「(£2】o o y )U S S A S()UTCU 二UTo lunp 」f (A R §o q o )2wl^20q o ^.・o %w uc o sXUTPsqsns^******** ***************^f l 】0 A)近士定—障尉QTry f ******************5-:************* **********⑧ 琛c>^建翠 唳********************=)七.s】d宀(dcl.mdno乩z'uxpt%-®^^・・)七宀「(曰目。
遗传算法代码

遗传算法代码遗传算法是一种基于自然选择和遗传学原理的优化算法,用于解决许多复杂的优化问题,如机器学习、图像处理、组合优化等。
以下是一个简单的遗传算法代码示例:1. 初始化种群首先,我们需要创建一组初始个体,称为种群。
每个个体都是由一组基因表示的,这些基因可能是一些数字、布尔值或其他类型的值。
我们可以使用随机数生成器生成这些基因,并将它们组合成一个个体。
2. 适应度函数为了衡量每个个体的表现,我们需要编写一个适应度函数。
该函数将计算每个个体的适应度得分,该得分反映了该个体在解决优化问题方面的能力。
适应度函数将对每个个体进行评分,并将其分配到一个适应度等级。
3. 选择操作选择操作是基于每个个体的适应度得分来选择哪些个体将被选择并用于生成下一代种群。
较高适应度的个体将有更高的概率被选择,而较低适应度的个体将有更低的概率被选择。
这通常是通过轮盘赌选择方法实现的。
4. 交叉操作交叉操作是将两个个体的基因组合并以生成新的个体。
我们可以将两个随机个体中的某些基因进行交换,从而创建新的个体。
这样的交叉操作将增加种群的多样性,使其更有可能找到最优解。
5. 变异操作变异操作是用于引入种群中的随机性的操作。
在变异操作中,我们将随机选择一个个体,并随机更改其中的一个或多个基因。
这将引入新的、未经探索的基因组合,从而增加种群的多样性。
6. 迭代随着种群不断进化,每个个体的适应度得分也将不断提高。
我们将重复执行选择、交叉和变异操作,以生成新的个体,并淘汰旧的个体。
这个不断迭代的过程将继续,直到达到预设的迭代次数或找到最优解为止。
这是一个简单的遗传算法代码示例,它演示了如何使用遗传算法来解决优化问题。
在实际应用中,我们可以进一步对算法进行优化,以获得更好的结果。
人工智能导论实验(遗传算法)-参考模板

环境配置1.安装anaconda,并配置环境变量2.Win+R运行cmd打开命令行窗口,在命令行中创建并激活所需的Python环境,也可直接使用默认的base环境a)创建:conda create -n [新环境的名字] python=[Python版本号]比如:conda create -n myEnv python=3.7b)激活环境:conda activate [环境名]。
激活成功后命令行前面会有个括号显示当前使用的环境名:3.检查当前环境下是否已有需要用到的库,若没有,则需要安装a)查询命令:conda listb)安装新的库:conda install [库名]也可指定库的版本号:conda install [库名]=[版本号]4.执行指定的python文件:python [.py文件名]如果.py文件不在当前路径下,需要指定文件的完整路径完成下列实验1,2以及3、4、5任选其二。
实验1:产生式系统1.基本要求1.1掌握产生式系统的基本原理1.2运行产生式系统的示例代码1.3尝试向示例代码中添加新数据,并完成相应的推理2.实验报告2.1总结产生式系统的基本原理2.2产生式系统的源代码分析与实验记录2.3尝试向示例代码中添加新数据,并完成相应的推理3.作业无实验2:AStar求解八数码问题1.基本要求1.1掌握AStar算法的基本原理1.2编写并运行AStar算法求解八数码问题的示例代码。
给定矩阵初始状态,允许将0与相邻的4个数字之一交换,直到矩阵转变为目标状态。
输出每一步交换后的矩阵例12.实验报告2.1 总结AStar算法的基本原理2.2 如何描述八数码问题中两个状态间的距离?2.2 如何根据状态距离将八数码问题转换为AStar寻路问题?3.作业提交编写的AStar求解八数码问题代码实验3:AStar求解迷宫寻路问题1.基本要求1.1掌握AStar算法的基本原理1.2编写并运行AStar算法求解迷宫寻路问题的示例代码。
python遗传算法代码

python遗传算法代码遗传算法是一种模拟生物进化过程的优化算法,常用于解决复杂的优化问题。
Python是一种简单易用且功能强大的编程语言,非常适合实现遗传算法。
下面是一个简单的Python遗传算法代码示例,用于求解一个二进制字符串中最长连续1的长度。
```pythonimport random# 设置遗传算法的参数POPULATION_SIZE = 100 # 种群大小GENERATION_COUNT = 50 # 迭代次数MUTATION_RATE = 0.01 # 变异率# 初始化种群def initialize_population():population = []for i in range(POPULATION_SIZE):individual = []for j in range(10): # 假设二进制字符串长度为10gene = random.randint(0, 1)individual.append(gene)population.append(individual)return population# 计算适应度def calculate_fitness(individual):fitness = 0current_streak = 0for gene in individual:if gene == 1:current_streak += 1fitness = max(fitness, current_streak)else:current_streak = 0return fitness# 选择操作:轮盘赌选择def selection(population):total_fitness = sum([calculate_fitness(individual) for individual in population])probabilities = [calculate_fitness(individual) /total_fitness for individual in population]selected_population = []for _ in range(POPULATION_SIZE):selected_individual = random.choices(population, weights=probabilities)[0]selected_population.append(selected_individual)return selected_population# 交叉操作:单点交叉def crossover(parent1, parent2):point = random.randint(1, len(parent1) - 1)child1 = parent1[:point] + parent2[point:]child2 = parent2[:point] + parent1[point:]return child1, child2# 变异操作def mutation(individual):for i in range(len(individual)):if random.random() < MUTATION_RATE:individual[i] = 1 - individual[i] # 变异位点翻转return individual# 主函数def genetic_algorithm():population = initialize_population()for _ in range(GENERATION_COUNT):population = selection(population)# 交叉操作new_population = []for i in range(0, POPULATION_SIZE, 2):parent1 = population[i]parent2 = population[i + 1]child1, child2 = crossover(parent1, parent2)new_population.append(child1)new_population.append(child2)# 变异操作population = [mutation(individual) for individual in new_population]best_individual = max(population, key=calculate_fitness) return best_individual# 运行遗传算法best_individual = genetic_algorithm()best_fitness = calculate_fitness(best_individual)print('Best individual:', best_individual)print('Best fitness:', best_fitness)```该代码首先初始化一个种群,然后通过选择、交叉和变异操作迭代地更新种群,并最终返回适应度最高的个体。
遗传算法matlab程序代码

遗传算法matlab程序代码
遗传算法(GA)是一种用于求解优化问题的算法,其主要思想是模拟
生物进化过程中的“选择、交叉、变异”操作,通过模拟这些操作,来寻
找最优解。
Matlab自带了GA算法工具箱,可以直接调用来实现遗传算法。
以下是遗传算法Matlab程序代码示例:
1.初始化
首先定义GA需要优化的目标函数f,以及GA算法的相关参数,如种
群大小、迭代次数、交叉概率、变异概率等,如下所示:
options = gaoptimset('PopulationSize',10,...
'Generations',50,...
2.运行遗传算法
运行GA算法时,需要调用MATLAB自带的ga函数,将目标函数、问
题的维度、上下界、约束条件和算法相关参数作为输入参数。
其中,上下
界和约束条件用于限制空间,防止到无效解。
代码如下:
[某,fval,reason,output,population] = ga(f,2,[],[],[],[],[-10,-10],[10,10],[],options);
3.结果分析
最后,将结果可视化并输出,可以使用Matlab的plot函数绘制出目
标函数的值随迭代次数的变化,如下所示:
plot(output.generations,output.bestf)
某label('Generation')
ylabel('Best function value')
总之,Matlab提供了方便易用的GA算法工具箱,开发者只需要根据具体问题定义好目标函数和相关参数,就能够在短时间内快速实现遗传算法。
遗传算法的经典案例

题目:通信网络链路容量和流量优化遗传算法MATLAB源码function [Zp,Xp,Yp,LC1,LC2]=GACFA(M,N,Pm)%--------------------------------------------------------------------------% GACFA.m% Genetic Algorithm for Capacity and Flow Assignment% 链路容量和流量优化分配的遗传算法% GreenSim团队原创作品,转载请注明% 更多原创代码,请访问GreenSim团队主页:/greensim% 算法设计、代写程序,欢迎访问GreenSim——算法仿真团队→/greensim%--------------------------------------------------------------------------% 函数功能% 使用遗传算法求解通信网链路容量和流量联合优化分配问题%--------------------------------------------------------------------------% 参考文献% 叶大振,吴新余.基于遗传算法的计算机通信网优化设计[J].% 南京邮电学院学报.1996,16(2):9-15%--------------------------------------------------------------------------% 输入参数列表% M 遗传进化迭代次数% N 种群规模(取偶数)% Pm 变异概率%--------------------------------------------------------------------------% 输出参数列表% Zp 目标函数最优值% Xp 路由选择决策变量最优值% Yp 线路型号决策变量最优值% LC1 收敛曲线1,各代最优个体适应值的记录% LC2 收敛曲线2,各代群体平均适应值的记录%--------------------------------------------------------------------------%第一步:载入数据和输出变量初始化load DATA_CFA;Xp=zeros(14,1);Yp=zeros(8,3);LC1=zeros(1,M);LC2=LC1;%第二步:随机产生初始种群farm_X=zeros(14,N);farm_Y=zeros(8,3*N);for i=1:Nfor j=1:2:13RAND=rand;if RAND>0.5farm_X(j,i)=1;elsefarm_X(j+1,i)=1;endendendfor i=1:Nfor j=1:8RAND=rand;if RAND<1/3farm_Y(j,3*i-2)=1;elseif RAND>2/3farm_Y(j,3*i)=1;elsefarm_Y(j,3*i-1)=1;endendendcounter=0;%设置迭代计数器while counter<M%停止条件为达到最大迭代次数%第三步:交叉newfarm_X=zeros(14,N);newfarm_Y=zeros(8,3*N);Ser=randperm(N);%对X做交叉for i=1:2:(N-1)A_X=farm_X(:,Ser(i));B_X=farm_X(:,Ser(i+1));cp=2*unidrnd(6);a_X=[A_X(1:cp);B_X((cp+1):end)];b_X=[B_X(1:cp);A_X((cp+1):end)];newfarm_X(:,i)=a_X;newfarm_X(:,i+1)=b_X;end%对Y做交叉for i=1:2:(N-1)A_Y=farm_Y(:,(3*Ser(i)-2):(3*Ser(i)));B_Y=farm_Y(:,(3*Ser(i+1)-2):(3*Ser(i+1))); cp=unidrnd(7);a_Y=[A_Y(1:cp,:);B_Y((cp+1):end,:)];b_Y=[B_Y(1:cp,:);A_Y((cp+1):end,:)];newfarm_Y(:,(3*i-2):(3*i))=a_Y;newfarm_Y(:,(3*i+1):(3*i+3))=b_Y;end%新旧种群合并FARM_X=[farm_X,newfarm_X];FARM_Y=[farm_Y,newfarm_Y];%第四步:选择复制Ser=randperm(2*N);FITNESS=zeros(1,2*N);fitness=zeros(1,N);for i=1:(2*N)X=FARM_X(:,i);Y=FARM_Y(:,(3*i-2):(3*i));FITNESS(i)=COST(X,Y,x1_x14,F_x1_x14,A,Q,C,S,b);endfor i=1:Nf1=FITNESS(Ser(2*i-1));f2=FITNESS(Ser(2*i));if f1<f2farm_X(:,i)=FARM_X(:,Ser(2*i-1));farm_Y(:,(3*i-2):(3*i))=FARM_Y(:,(3*Ser(2*i-1)-2):(3*Ser(2*i-1))); fitness(i)=f1;elsefarm_X(:,i)=FARM_X(:,Ser(2*i));farm_Y(:,(3*i-2):(3*i))=FARM_Y(:,(3*Ser(2*i)-2):(3*Ser(2*i)));fitness(i)=f2;endend%记录最佳个体和收敛曲线minfitness=min(fitness);meanfitness=mean(fitness);LC1(counter+1)=minfitness;LC2(counter+1)=meanfitness;pos=find(fitness==minfitness);Xp=farm_X(:,pos(1));Yp=farm_Y(:,(3*pos(1)-2):(3*pos(1)));Zp=minfitness;%第五步:变异for i=1:Nif Pm>randGT_X=farm_X(:,i);GT_Y=farm_Y(:,(3*i-2):(3*i));pos1=2*unidrnd(7);if GT_X(pos1)==1GT_X(pos1-1)=1;GT_X(pos1)=0;farm_X(:,i)=GT_X;elseif GT_X(pos1)==0GT_X(pos1-1)=0;GT_X(pos1)=1;farm_X(:,i)=GT_X;elseendpos2=unidrnd(8);GT_Y(pos2,:)=zeros(1,3);GT_Y(pos2,unidrnd(3))=1;endendcounter=counter+1endXp=Xp';Yp=Yp';%plot(LC1)%hold onplot(LC2)遗传算法程序:说明: fga.m 为遗传算法的主程序; 采用二进制Gray编码,采用基于轮盘赌法的非线性排名选择, 均匀交叉,变异操作,而且还引入了倒位操作!function[BestPop,Trace]=fga(FUN,LB,UB,eranum,popsize,pCross,pMutation,pInversion,options)% [BestPop,Trace]=fmaxga(FUN,LB,UB,eranum,popsize,pcross,pmutation)% Finds a maximum of a function of several variables.% fmaxga solves problems of the form:% max F(X) subject to: LB <= X <= UB% BestPop - 最优的群体即为最优的染色体群% Trace - 最佳染色体所对应的目标函数值% FUN - 目标函数% LB - 自变量下限% UB - 自变量上限% eranum - 种群的代数,取100--1000(默认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<3, error('FMAXGA requires at least three input arguments'); endif nargin==3,eranum=200;popsize=100;pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];endif nargin==4, popsize=100;pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];end if nargin==5, pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];endif nargin==6, pMutation=0.1;pInversion=0.15;options=[0 1e-4];endif nargin==7, pInversion=0.15;options=[0 1e-4];endif find((LB-UB)>0)error('数据输入错误,请重新输入(LB<UB):');ends=sprintf('程序运行需要约%.4f 秒钟时间,请稍等......',(eranum*popsize/1000));disp(s);global m n NewPop children1 children2 VarNumbounds=[LB;UB]';bits=[];VarNum=size(bounds,1);precision=options(2);%由求解精度确定二进制编码长度bits=ceil(log2((bounds(:,2)-bounds(:,1))' ./ precision));%由设定精度划分区间[Pop]=InitPopGray(popsize,bits);%初始化种群[m,n]=size(Pop);NewPop=zeros(m,n);children1=zeros(1,n);children2=zeros(1,n);pm0=pMutation;BestPop=zeros(eranum,n);%分配初始解空间BestPop,TraceTrace=zeros(eranum,length(bits)+1);i=1;while i<=eranumfor j=1:mvalue(j)=feval(FUN(1,:),(b2f(Pop(j,:),bounds,bits)));%计算适应度end[MaxValue,Index]=max(value);BestPop(i,:)=Pop(Index,:);Trace(i,1)=MaxValue;Trace(i,(2:length(bits)+1))=b2f(BestPop(i,:),bounds,bits);[selectpop]=NonlinearRankSelect(FUN,Pop,bounds,bits);%非线性排名选择[CrossOverPop]=CrossOver(selectpop,pCross,round(unidrnd(eranum-i)/eranum));%采用多点交叉和均匀交叉,且逐步增大均匀交叉的概率%round(unidrnd(eranum-i)/eranum)[MutationPop]=Mutation(CrossOverPop,pMutation,VarNum);%变异[InversionPop]=Inversion(MutationPop,pInversion);%倒位Pop=InversionPop;%更新pMutation=pm0+(i^4)*(pCross/3-pm0)/(eranum^4);%随着种群向前进化,逐步增大变异率至1/2交叉率p(i)=pMutation;i=i+1;endt=1:eranum;plot(t,Trace(:,1)');title('函数优化的遗传算法');xlabel('进化世代数(eranum)');ylabel('每一代最优适应度(maxfitness)');[MaxFval,I]=max(Trace(:,1));X=Trace(I,(2:length(bits)+1));hold on; plot(I,MaxFval,'*');text(I+5,MaxFval,['FMAX=' num2str(MaxFval)]);str1=sprintf('进化到 %d 代 ,自变量为 %s 时,得本次求解的最优值 %f\n对应染色体是:%s',I,num2str(X),MaxFval,num2str(BestPop(I,:)));disp(str1);%figure(2);plot(t,p);%绘制变异值增大过程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 %像这种程序当然不考虑运行上小时啦str2=sprintf('程序运行耗时 %d 小时 %d 分钟 %.4f 秒',elapsed_time(4),elapsed_time(5),elapsed_time(6));disp(str2);TSP问题遗传算法matlab源程序(注释详细,经反复实验收敛速度快)%TSP问题(又名:旅行商问题,货郎担问题)遗传算法通用matlab程序%D是距离矩阵,n为种群个数,建议取为城市个数的1~2倍,%C为停止代数,遗传到第 C代时程序停止,C的具体取值视问题的规模和耗费的时间而定%m为适应值归一化淘汰加速指数 ,最好取为1,2,3,4 ,不宜太大%alpha为淘汰保护指数,可取为0~1之间任意小数,取1时关闭保护功能,最好取为0.8~1.0%R为最短路径,Rlength为路径长度function [R,Rlength]=geneticTSP(D,n,C,m,alpha)[N,NN]=size(D);farm=zeros(n,N);%用于存储种群for i=1:nfarm(i,=randperm(N);%随机生成初始种群endR=farm(1,;%存储最优种群len=zeros(n,1);%存储路径长度fitness=zeros(n,1);%存储归一化适应值counter=0;while counter<Cfor i=1:nlen(i,1)=myLength(D,farm(i,);%计算路径长度endmaxlen=max(len);minlen=min(len);fitness=fit(len,m,maxlen,minlen);%计算归一化适应值 rr=find(len==minlen);R=farm(rr(1,1),;%更新最短路径FARM=farm;%优胜劣汰,nn记录了复制的个数nn=0;for i=1:nif fitness(i,1)>=alpha*randnn=nn+1;FARM(nn,=farm(i,;endendFARM=FARM(1:nn,;[aa,bb]=size(FARM);%交叉和变异while aa<nif nn<=2nnper=randperm(2);elsennper=randperm(nn);endA=FARM(nnper(1),;B=FARM(nnper(2),;[A,B]=intercross(A,B);FARM=[FARM;A;B];[aa,bb]=size(FARM);endif aa>nFARM=FARM(1:n,;%保持种群规模为nendfarm=FARM;clear FARMcounter=counter+1endRlength=myLength(D,R);function [a,b]=intercross(a,b)L=length(a);if L<=10%确定交叉宽度W=1;elseif ((L/10)-floor(L/10))>=rand&&L>10W=ceil(L/10);elseW=floor(L/10);endp=unidrnd(L-W+1);%随机选择交叉范围,从p到p+Wfor i=1:W%交叉x=find(a==b(1,p+i-1));y=find(b==a(1,p+i-1));[a(1,p+i-1),b(1,p+i-1)]=exchange(a(1,p+i-1),b(1,p+i-1));[a(1,x),b(1,y)]=exchange(a(1,x),b(1,y));endfunction [x,y]=exchange(x,y)temp=x;x=y;y=temp;% 计算路径的子程序function len=myLength(D,p)[N,NN]=size(D);len=D(p(1,N),p(1,1));for i=1N-1)len=len+D(p(1,i),p(1,i+1));end%计算归一化适应值子程序function fitness=fit(len,m,maxlen,minlen)fitness=len;for i=1:length(len)fitness(i,1)=(1-((len(i,1)-minlen)/(maxlen-minlen+0.000001))).^m; end%初始化种群%采用二进制Gray编码,其目的是为了克服二进制编码的Hamming悬崖缺点function [initpop]=InitPopGray(popsize,bits)len=sum(bits);initpop=zeros(popsize,len);%The whole zero encoding individualfor i=2:popsize-1pop=round(rand(1,len));pop=mod(([0 pop]+[pop 0]),2);%i=1时,b(1)=a(1);i>1时,b(i)=mod(a(i-1)+a(i),2)%其中原二进制串:a(1)a(2)...a(n),Gray串:b(1)b(2)...b(n)initpop(i,:)=pop(1:end-1);endinitpop(popsize,:)=ones(1,len);%The whole one encoding individual%解码function [fval] = b2f(bval,bounds,bits)% fval - 表征各变量的十进制数% bval - 表征各变量的二进制编码串% bounds - 各变量的取值范围% bits - 各变量的二进制编码长度scale=(bounds(:,2)-bounds(:,1))'./(2.^bits-1); %The range of the variablesnumV=size(bounds,1);cs=[0 cumsum(bits)];for i=1:numVa=bval((cs(i)+1):cs(i+1));fval(i)=sum(2.^(size(a,2)-1:-1:0).*a)*scale(i)+bounds(i,1);end%选择操作%采用基于轮盘赌法的非线性排名选择%各个体成员按适应值从大到小分配选择概率:%P(i)=(q/1-(1-q)^n)*(1-q)^i, 其中 P(0)>P(1)>...>P(n), sum(P(i))=1function [selectpop]=NonlinearRankSelect(FUN,pop,bounds,bits)global m nselectpop=zeros(m,n);fit=zeros(m,1);for i=1:mfit(i)=feval(FUN(1,:),(b2f(pop(i,:),bounds,bits)));%以函数值为适应值做排名依据endselectprob=fit/sum(fit);%计算各个体相对适应度(0,1)q=max(selectprob);%选择最优的概率x=zeros(m,2);x(:,1)=[m:-1:1]';[y x(:,2)]=sort(selectprob);r=q/(1-(1-q)^m);%标准分布基值newfit(x(:,2))=r*(1-q).^(x(:,1)-1);%生成选择概率newfit=cumsum(newfit);%计算各选择概率之和rNums=sort(rand(m,1));fitIn=1;newIn=1;while newIn<=mif rNums(newIn)<newfit(fitIn)selectpop(newIn,:)=pop(fitIn,:);newIn=newIn+1;elsefitIn=fitIn+1;endend%交叉操作function [NewPop]=CrossOver(OldPop,pCross,opts)%OldPop为父代种群,pcross为交叉概率global m n NewPopr=rand(1,m);y1=find(r<pCross);y2=find(r>=pCross);len=length(y1);if len>2&mod(len,2)==1%如果用来进行交叉的染色体的条数为奇数,将其调整为偶数y2(length(y2)+1)=y1(len);y1(len)=[];endif length(y1)>=2for i=0:2:length(y1)-2if opts==0[NewPop(y1(i+1),:),NewPop(y1(i+2),:)]=EqualCrossOver(OldPop(y1(i+1),:),OldPop(y1(i+2), :));else[NewPop(y1(i+1),:),NewPop(y1(i+2),:)]=MultiPointCross(OldPop(y1(i+1),:),OldPop(y1(i+2) ,:));endendendNewPop(y2,:)=OldPop(y2,:);%采用均匀交叉function [children1,children2]=EqualCrossOver(parent1,parent2)global n children1 children2hidecode=round(rand(1,n));%随机生成掩码crossposition=find(hidecode==1);holdposition=find(hidecode==0);children1(crossposition)=parent1(crossposition);%掩码为1,父1为子1提供基因children1(holdposition)=parent2(holdposition);%掩码为0,父2为子1提供基因children2(crossposition)=parent2(crossposition);%掩码为1,父2为子2提供基因children2(holdposition)=parent1(holdposition);%掩码为0,父1为子2提供基因%采用多点交叉,交叉点数由变量数决定function [Children1,Children2]=MultiPointCross(Parent1,Parent2)global n Children1 Children2 VarNumChildren1=Parent1;Children2=Parent2;Points=sort(unidrnd(n,1,2*VarNum));for i=1:VarNumChildren1(Points(2*i-1):Points(2*i))=Parent2(Points(2*i-1):Points(2*i));Children2(Points(2*i-1):Points(2*i))=Parent1(Points(2*i-1):Points(2*i));end%变异操作function [NewPop]=Mutation(OldPop,pMutation,VarNum)global m n NewPopr=rand(1,m);position=find(r<=pMutation);len=length(position);if len>=1for i=1:lenk=unidrnd(n,1,VarNum); %设置变异点数,一般设置1点for j=1:length(k)if OldPop(position(i),k(j))==1OldPop(position(i),k(j))=0;elseOldPop(position(i),k(j))=1;endendendendNewPop=OldPop;%倒位操作function [NewPop]=Inversion(OldPop,pInversion)global m n NewPopNewPop=OldPop;r=rand(1,m);PopIn=find(r<=pInversion);len=length(PopIn);if len>=1for i=1:lend=sort(unidrnd(n,1,2));if d(1)~=1&d(2)~=nNewPop(PopIn(i),1:d(1)-1)=OldPop(PopIn(i),1:d(1)-1);NewPop(PopIn(i),d(1):d(2))=OldPop(PopIn(i),d(2):-1:d(1)); NewPop(PopIn(i),d(2)+1:n)=OldPop(PopIn(i),d(2)+1:n);endendend。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一.问题描述:
在某一区域内有n 个客户,拟建一个物流中心,已知客户j 地址坐标为),(i i y x 。
确定物流中心的地址坐标),(y x ,使得该物流中心到几个客户之间的距离最短。
假设:简单的用两点之间的距离代替运输距离。
目标函数:
22)()(min i i y Y x X z -+-=
约束条件:
}
8,7,6,5,4,3,2,1,0{}8,7,6,5,4,3,2,1,0{X ∈∈Y 假设某一区域内有 5 个客户,其位置坐标如下表所示,
(1)变量:
C :是一个1*6数组,每个数组里面是一个6位二进制数,它是遗传算法中的染色体。
new_c:每一轮的新变量c 。
first_c:初始群体矩阵。
sur_value :个体适应值的概率值,为0-1之间的数,所有概率值和为1。
survived :经过选择运算后产生的个体基因型组合。
intersect_c :经过交叉运算后产生的个体基因型组合。
mutation_c :经过变异运算后产生的个体基因型组合。
f :最后计算得到的最大值
(2)程序里面的方程
function out = value_function( ci ):价值函数(自适应度函数)。
function [ sur_value ] = calc_value( c ):计算群体中每一个个体的适应度的值
function survived = surviver( sur_value ):利用概率选择函数
function [ intersect_c ] = intersect( new_c ):交叉运算
function [ mutation_c ,mutation_value] = mutation( intersect_c ):变异运算
(1)遗传算法主程序
%遗传算法的主程序
%初始群体的产生,本例中,群体规模大小取为6,即由6个个体组成,每个个体随机产生。
c = rand(6,6);%产生随机群体,c表示个体变量。
%第一个6表示个体个体,第二个6表示基因型由6位无符号二进制数组成
c(c>0.5) = 1;
c(c<0.5) = 0;
%显示初始群体
first_c = c;
points = [1,5;2,8;5,1;7,6;8,3];
%目的点
%一轮算法包括选择,交叉,变异,变异完成后产生新的个体,作为子代群体进行下一轮进化。
一共设置1000次进化
for n = 1:1000%设置循环次数
sur_value = calc_value(c,points);
survived = surviver(sur_value);
new_c = zeros(6,6);
for ii =1:6
new_c(ii,:) = c(survived(ii),:);
end
intersect_c = intersect(new_c);%交叉个体
mutation_c = mutation( intersect_c );%变异个体,作为子代群体
c = mutation_c;%子代群体作为新一轮的个体,继续选择,交叉,变异
end
f=0;
for jj=1:6
b = value_function(new_c(jj,:),points);
if b>f
f=b;
end
end
(2)适应度函数计算:适应度函数选择为目标函数的倒数
function distance = value_function( ci,points )
%遗传算法的价值函数,同时也可以将此目标函数值作为个体的适应度。
x = 4*ci(1)+2*ci(2)+1*ci(3)+1;
y = 4*ci(4)+2*ci(5)+1*ci(6)+1;
distance = 0;
for ii=1:length(points)
distance = distance +
((x-points(ii,1))^(2)+(y-points(ii,2))^(2))^(1/2);
end
end
function [ sur_value ] = calc_value( c,points )
%计算群体中每一个个体的适应度的值
value = zeros(1,6);
for ii = 1:6 %对于第1到第6个个体
value(ii) = 1 / value_function(c(ii,:),points);%计算每个个体的适应度值end
sur_value = value ./ sum(value);%将适应度值归一化,即每个个
%体被遗传到下一代群体中的概率
end
(3)选择计算
function survived = surviver( sur_value )
%选择个体,采用与适应度成正比的概率来确定各个个体复制到下一代群体中
survived = ones(1,6);
for ii = 1:6
random = rand(1)%随机产生一个0到1的数
%判断该随机数出现在哪一个概率区间内,以此来判断哪个个体被选中
sur_v_a=0;
%设置最后结果的输出
for jj = 1:6
sur_v_a=sur_v_a+sur_value(jj);
if random <sur_v_a
survived(ii) = jj;
break;
end
end
end
end
(4)交叉运算
随机设置交叉点
function [ r ] = random5( )
%随机设置交叉点位置,一共有5个交叉点位置。
6个个体共需3次交叉
r = rand(1)*5;
r = floor(r)+1;
end
function [ intersect_c ] = intersect( new_c )
%j进行交叉运算:以某一概率相互交换某两个个体之间的部分染色体
% 此处显示详细说明
intersect_c =zeros(6,6);
for ii = 1:3
r5 = random5();
intersect_c(ii*2-1,1:r5) = new_c(ii*2-1,1:r5);
intersect_c(ii*2-1,r5+1:6) = new_c(ii*2,r5+1:6);
intersect_c(ii*2,1:r5) =new_c(ii*2,1:r5);
intersect_c(ii*2,r5+1:6) = new_c(ii*2-1,r5+1:6);
end
end
(5)变异运算,变异概率为0.05
function [ mutation_c ,mutation_value] = mutation( intersect_c ) %变异运算:对个体的某一个或某一些基因座上的基因值按某一较小的概率进行改变
%
mutation_c = intersect_c;
mutation_value = zeros(2,36);
count=1;
for ii=1:6
for jj=1:6
r = rand(1);
if r<0.05
mutation_c(ii,jj)=1-mutation_c(ii,jj);
mutation_value(1,count)=ii;
mutation_value(2,count)=jj;
count=count+1;
end
end
end
end
经过1000次迭代后,产生的结果为:C的值。
对应的最优解为f的值。