• 利用遗传算法寻找函数f(x)=sin(10πx)/x x=[1,2] 解题思路 将自变量在给定范围进行编码，得到种群编码，按照所选择的适应度函数并通过遗传算法中的选择，交叉和变异对个体进行筛选和进化，使适应度值大的个体被...
利用遗传算法寻找函数f(x)=sin(10πx)/x    x=[1,2]
解题思路
将自变量在给定范围进行编码，得到种群编码，按照所选择的适应度函数并通过遗传算法中的选择，交叉和变异对个体进行筛选和进化，使适应度值大的个体被保留，小的个体被淘汰，新的种群继承上一代的信息，又优于下一代，这样反复循环，最后得出最终结果
注：程序参考<<MATLAB智能智能算法30个案例>>, 依照matlab程序，用python进行了重写
# -*- coding: utf-8 -*-
import matplotlib.pyplot as plt
import numpy as np
from pylab import *
import random
import math
mpl.rcParams['font.sans-serif'] = ['SimHei']
mpl.rcParams['axes.unicode_minus'] = False
#定义遗传算法参数
pop_size=40
generation=20
length=30
pc=0.65
pm=0.01
#编码
def genEncoding(pop_size,length):
pop=[[]]
for i in range(pop_size):
temp=[]
for j in range(length):
temp.append(random.randint(0,1))
pop.append(temp)
return pop[1:]
#解码
def genDecoding(pop,length):
temp=[]
for i in range(len(pop)):
t=0
for j in range(length):
t+=pop[i][j]*math.pow(2,j)
temp.append(t)
return temp
#计算目标值
def calobjValue(pop,length,lb,ub):
temp1=[]
obj_value=[]
x_value=[]
temp1=genDecoding(pop,length)
for i in range(len(temp1)):
x=lb+(ub-lb)*temp1[i]/((math.pow(2,length))-1)
x_value.append(x)
obj_value.append(np.sin(10*pi*x)/x)
return obj_value
#计算适应度
def fitness(pop,length,lb,ub):
obj_value=[]
fitness_value=[]
obj_value=calobjValue(pop,length,lb,ub)
for i in range(len(obj_value)):
fitness_value.append(obj_value[i]-1)
fitness_value=list(map(abs,fitness_value))
return fitness_value
#累积适应度
def cumsum(newfitness_value):
accumulation_value=[]
t=0
for i in range(len(newfitness_value)):
t+=newfitness_value[i]
accumulation_value.append(t)
return accumulation_value
#选择函数
def selection(pop,fitness_value):
newfitness_value=[]
accumulation_value=[]
total_fit=np.sum(fitness_value)
for i in range(len(fitness_value)):
newfitness_value.append(fitness_value[i]/total_fit)
accumulation_value=cumsum(newfitness_value)
ms=[]
for i in range(len(pop)):
ms.append(random.random())
newin=0
newpop=[]
for i in range(len(ms)):
j=0
for j in range(len(accumulation_value)):
if ms[i]<accumulation_value[j]:
t=pop[j]
newpop.append(t)
break
return newpop
#交叉函数
def crossover(pop,fitness_value,pc):
newpop=[]
newpop=selection(pop,fitness_value)
for i in range(len(newpop)-1):
if random.random()<pc:
temp1=[]
temp2=[]
temp1=newpop[i][3:15]
temp2=newpop[i+1][3:15]
newpop[i][3:15]=temp2
newpop[i+1][3:15]=temp1
return newpop
def mutation(pop,fitness_value,pc,pm,length):
newpop=[]
newpop=crossover(pop,fitness_value,pc)
for i in range(len(newpop)):
if random.random()<pm:
m1=random.randint(0,length-1)
m2=random.randint(0,length-1)
m3=random.randint(0,length-1)
if newpop[i][m1]==1:
newpop[i][m1]=0
else:
newpop[i][m1]=1
if newpop[i][m2]==1:
newpop[i][m2]=0
else:
newpop[i][m2]=1
if newpop[i][m3]==1:
newpop[i][m3]=0
else:
newpop[i][m3]=1
i=0
return newpop
if __name__ =='__main__':
#画出函数图
plt.figure(1)
lb=1
ub=2
x=np.arange(lb,ub,0.01)
y=sin(10*pi*x)/x
plt.plot(x,y)
plt.xlabel("自变量x")
plt.ylabel("自变量y")
plt.title('sin(10*pi*x)/x')
pop=genEncoding(pop_size,length)
obj_value=calobjValue(pop,length,lb,ub)
fitness_value=fitness(pop,length,lb,ub)
gen=0
x_value=[]
best_x=[]
best_individual=[]
Generation=[]
while gen<generation:
newpop=mutation(pop,fitness_value,pc,pm,length)
temp=genDecoding(newpop,length)
for i in range(len(temp)):
x=lb+(ub-lb)*temp[i]/((math.pow(2,length))-1)
x_value.append(x)
obj_value=calobjValue(newpop,length,lb,ub)
k=0
j=0
for i in range(len(obj_value)):
if k>obj_value[i]:
k=obj_value[i]
j=i
best_individual.append(k)
best_x.append(x_value[j])
fitness_value=fitness(newpop,length,lb,ub)
Generation.append(gen)
gen=gen+1
k=0
j=0
for i in range(len(best_individual)):
if k>best_individual[i]:
k=best_individual[i]
j=i
print(best_individual[j])
print(best_x[j])
best_individual.sort(reverse=True)
plt.figure(2)
plt.plot(Generation,best_individual)
plt.xlabel("遗传代数")
plt.ylabel("解的变化")
plt.title("进化过程")
plt.show()


展开全文
• 1、遗传算法概论  遗传算法（GA）可能是最早开发出来的模拟生物遗传系统的算法模型。它首先由Fraser提出，后来有Bremermann和Reed等人  再次提出。最后，Holland对遗传算法做了大量工作并使之推广，因此被认为是...
1、遗传算法概论
遗传算法（GA）可能是最早开发出来的模拟生物遗传系统的算法模型。它首先由Fraser提出，后来有Bremermann和Reed等人
再次提出。最后，Holland对遗传算法做了大量工作并使之推广，因此被认为是遗传算法的奠基人。遗传算法模拟了基因进化，在这
个模型中，个体的性状通过基因型表达。选择算子（模拟适者生存）与交叉算子（模拟繁殖），是遗传算法的主要驱动算法。
2、遗传算法的基本运算过程如下：

a)初始化：设置进化代数计数器t=0，设置最大进化代数T，随机生成M个个体作为初始群体P(0)。

b)个体评价：计算群体P(t)中各个个体的适应度。

c)选择运算：将选择算子作用于群体。选择的目的是把优化的个体直接遗传到下一代或通过配对交叉产生新的个体再遗传到下一代。选择操作是建立在群体中个体的适应度评估基础上的。

d)交叉运算：将交叉算子作用于群体。遗传算法中起核心作用的就是交叉算子。

e)变异运算：将变异算子作用于群体。即是对群体中的个体串的某些基因座上的基因值作变动。

群体P(t)经过选择、交叉、变异运算之后得到下一代群体P(t+1)。

f)终止条件判断：若t=T,则以进化过程中所得到的具有最大适应度个体作为最优解输出，终止计算。
3、应用遗传算法求解函数最小值

使用的函数为f(x)=7*sin(6*x)+6*cos(5*x),x∈[0,2*pi]
遗传算法的MATLAB实现如下：
L=16;  %编码长度，即用16位二进制表示
N=32;  %种群数目
M=48;  %M>=N，M个中间体，运用算子选择出M/2对母体，进行交叉；对M个中间体进行变异
T=100; %最大繁殖代数
Pc=0.8;  %交叉概率
Pm=0.03;  %变异概率

x1=zeros(1,N);
x2=zeros(1,N);
x4=zeros(1,N);
%grayCode=zeros(1,N)';
grayCode=cell(N,1);
grayCodeNew=cell(N,1);
for i=1:1:N %初始化种群N
x1(1,i)=rand()*2*pi;
x2(1,i)=uint16(x1(1,i)/(2*pi)*65535);
%grayCode(i,:)=num2gray(x2(1,i),L);
grayCode{i}=num2gray(x2(1,i),L);
end
%=========进化，开始进行遗传算子操作
for t=1:1:T
y1=7*sin(6*x1)+6*cos(5*x1);
for i=1:1:M/2
[~,b]=min(y1);
%grayCodeNew(i,:)=grayCode(b,:);
grayCodeNew{i}=grayCode{b};
%grayCodeNew(i+M/2,:)=grayCode(b,:);
grayCodeNew{i+M/2}=grayCode{b};
y1(1,b)=inf;
end
for i=1:1:M/2
p=unidrnd(L);
if rand()< Pc %rand()产生一个随机数
for j=p:1:L
temp=grayCodeNew{i}(j);
grayCodeNew{i}(j)=grayCodeNew{M-i+1}(j);
grayCodeNew{M-i+1}(j)=temp;
end
end
end
%将全部染色体按概率进行变异
for i=1:1:M
for j=1:1:L
if rand()< Pm
grayCodeNew{i}(j)=dec2bin(1-bin2dec(grayCodeNew{i}(j)));
end
end
end
for i=1:1:M
%x4(1,i)=gray2num(grayCodeNew(i,:));
x4(1,i)=gray2num(grayCodeNew{i});
end
x3=double(x4)*2*pi/65535;
y3=11*sin(6*x3)+7*cos(5*x3);
for i=1:1:N  %更新种群
%[a,b]=min(y3);
[~,b]=min(y3);
x1(1,i)=x3(1,b);
%grayCode(i,:)=grayCodeNew(b,:);
grayCode{i}=grayCodeNew{b};
y3(1,b)=inf;
end
end
%经过第T代后，由x1计算出y1,找出最小者
%x1
y1=11*sin(6*x1)+7*cos(5*x1);
[a,b]=min(y1);
x0=x1(1,b);
y0=a;
disp(['x0=',num2str(x0)]);
disp(['y0=',num2str(y0)]);运行结果如下：


展开全文
• 遗传算法求解函数最小值问题 继上一次用遗传算法求解TSP问题问题以后，万万没有想到，实验的时候，老师居然改了题目，改成了求解函数的最小值问题（有点坑哈），而且要求结果尽量的稳定，可以确定得到最小值，并且，...
遗传算法求解函数最小值问题
继上一次用遗传算法求解TSP问题问题以后，万万没有想到，实验的时候，老师居然改了题目，改成了求解函数的最小值问题（有点坑哈），而且要求结果尽量的稳定，可以确定得到最小值，并且，精度尽可能的高……虽然有点坑，不过老师还是简单的说明了一下基本的思路，思路和上一次没有太大的变化，唯一的难点就是怎样尽可能的提高解的精度。
不管怎样，终究在实验课的时候解决了这个问题，唯一的问题就是进度最多10的负六次方，老师说他的精度可以达到10的负几百次方（膜拜……）。
思路不变，选择用轮盘赌，变异要稍微变一下，具体会在下面讲解，废话少说，进入正题。.
问题描述：
设计高效遗传算法，求解下列函数在-5<=x1,x2<=5上的最小值：
在正式的开始求解之前，老师先将函数的图片展示了出来，如下图所示：
并且公布结果，在（0,0）的位置取得最小值0。
在这个结果的基础上，我们开始试验。
代码编写：
首先是个体的类代码：
class problem1_individual(object):
def __init__(self, n1, n2):
self.gene = [n1, n2]
self.score = 0
pass

接着轮盘赌选择的代码，和上一次没有多少变化，同样是采用倒数的方式来作为个体的适配值，因为事先知道结果的最小值为0，所以采用倒数的方式很好，因为越接近0，倒数越大，被选中的概率就越大。
代码如下所示：
def roulette_wheel(self):
"""
轮盘赌普通方法得到被选中的基因型
:param individuals: 种群中各个基因类型的数量
:return: 返回被选中的基因型的代号
"""
all_individual = 0
for i in range(len(self.list)):
all_individual += 1 / self.list[i].score
probabilities = []
for i in range(len(self.list)):
probabilities.append((1 / self.list[i].score) / all_individual)
selected_individual = random.uniform(0, 1)
now_individual = 0.0
for ind, val in enumerate(probabilities):
now_individual += val
if now_individual > selected_individual:
return self.list[ind]

接着是交叉的代码。在编写之前还没有办法，个体是两个自变量，但是交叉怎么办？上网查了一下，有了思路，很简单，就是用不同的比例进行划分。
随机生成一0-1的数字，作为其中一个父个体的基因比例，再用1减去这个数字，得到另一个父个体的基因比例，两者相加得到的就是最后的孩子的基因序列：
def crossgene(self, parent1, parent2, index1, index2):
child = [0, 0]
child[0] = parent1.gene[0] * index1 + parent2.gene[0] * index2
child[1] = parent1.gene[1] * index1 + parent2.gene[1] * index2
return child

def crossover(self, father, mother):
"""
:param father: 需要进行遗传的父类个体
:param mother: 需要进行遗传的母类个体
:return:
"""
x = random.randint(0, 9999)
# 变异有概率，大于某个值就不发生，小于某个值就发生变异
k = 10000 * self.variationrate
if x < k:
# 进行单点交换
index1 = random.uniform(0, 1)
index2 = 1 - index1
child1 = self.crossgene(father, mother, index1, index2)
child2 = self.crossgene(mother, father, index1, index2)
else:
child1 = father.gene
child2 = mother.gene
return child1, child2

结果测试：
代码编写完毕，现在进行测试，看看结果如何：
from problem1_GA import problem1_GA

test = problem1_GA(1, 1)
test.initpopulation()
for i in range(10000):
test.next_generation()
print()
pass

迭代次数就采用10000次，看看最后的结果达到什么样的精度：

运气不错，最后的结果精度可以达到10^-9次方的水平。当然这次是运气好，但是不是每一次都可以重现这种操作，我还会继续的进行代码的优化，下一次让结果有更好的精度。
当然这都是后话。
最后完整的代码就放在以下链接中
遗传算法求解函数最小值问题
提取码：v2y6
还有上一次的文章缺少的CSDN链接，是tomcat的安装包和eclipse插件：
CSDN—tomcat
谢谢大家阅读！


展开全文
• 一、传统遗传算法求解函数最小值 ①对于函数 其最小值位于时，最小值为0 matlab多次结果如下： 从上图能够看到传统能够得到最终结果，但是稳定性较差，不易得到较好的结果 ②对函数做平移，即可得到 其...
一、传统遗传算法求解函数最小值

①对于函数

$f(x)=100(x_{1}^2-x_{2})^2+(1-x_{1})^2 -2.048\leq x1,x2\leq 2.048$

其最小值位于$x_{1}=1,x_{2}=1$时，最小值为0

matlab多次结果如下：

从上图能够看到传统能够得到最终结果，但是稳定性较差，不易得到较好的结果

②对函数做平移，即可得到

$f(x)=100((x_{1}+2)^2-x_{2}-2)^2+(1-x_{1}-2)^2 -2.048\leq x1,x2\leq 2.048$

其最小值位于$x_{1}=-1,x_{2}=-1$时，最小值为0

多次运行结果为：

结果与函数①类似

二、改进遗传算法求解函数最小值

同样求函数②

能够看出改进后的结果更稳定，结果更接近实际最小值。


展开全文
• 遗传算法，GA，求最小值，选择、交叉、变异算子
• 求解函数最小值的自适应遗传算法 （Matlab程序）
• 遗传算法计算函数最小值f（x）=∑xi^2 基于matlib与python对比 采用种群数100，实数编码，进化100代交叉概率0.8，变异概率0.1 # -*- coding: utf-8 -*- """ """ import numpy as np #适应度函数 def func2(x):...
• 能够求解规定定义域内函数的最值问题，包括负数域，同时进行了一定的改进，使遗传算法的计算更加稳定
• 下列二元函数的最大值，f(x1,x2)=x1^2+x2^2,x1与x2的取值区间为{0,1,2，...，7}
• 今天小编就为大家分享一篇使用遗传算法求二元函数最小值，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
• 问题：在下面的程序中将要运用遗传算法对一个多项式求最小值： y=x^6-10x^5-26x^4+344x^3+193x^2-1846x-1680 要求在(-8,8)间寻找使表达式达到最小的x，误差为0.001。 问题分析： 编码：采用常规码，即二进制码...
• 这是一种计算函数最小值的简单遗传算法。 它没有任何改进，但我有一些像精英主义、代沟和重整化这样的改进。
• 用标准遗传算法求函数： 的最小值函数图像如图（及程序）所示： clear all; close all; clc; x=0:0.01:10; y=x+10*cos(5*x)+7*sin(4*x); figure plot(x,y) grid on xlabel('x') ylabel('f(x)') title('f(x)=...
• Matlab实数编码遗传算法求函数极大值-实数编码遗传算法求Rosenbrock函数极大值.rar 所含文件： Figure19.jpg Matlab实数编码遗传算法求函数极大值 运行结果： ...
• 遗传算法求最小值 经本人调试 十分好用 用run命令调用mainmin1和mainmin2 就可以算出了 f='-(exp(-1))+(x-20).*(x-22)';可以改为其他计算其他函数最小值
• 利用C++语言模拟遗传算法进行对Rosenbrocks函数最小值求值。之前自动涨上去的，重新把积分减下来了
• 求函数极值
• 二元函数为y=x1^2+x2^2,x∈[-5,5]
• 使用C语言编写的求最小值遗传算法程序，非常适合初学者理解遗传算法
• python遗传算法求函数极值
• python遗传算法求解函数极值问题
• 四目标遗传算法最小值优化代码，c++，目标函数可以自行更改。

...