遗传算法是通过模拟大自然中生物进化的历程,来解决问题的。大自然中一个种群经历过若干代的自然选择后,剩下的种群必定是适应环境的。把一个问题所有的解看做一个种群,经历过若干次的自然选择以后,剩下的解中是有问题的最优解的。当然,只能说有最优解的概率很大。这里,我们用遗传算法求一个函数的最大值。
f(x) = 10 * sin( 5x ) + 7 * cos( 4x ), 0 <= x <= 10
取基因片段的长度为10, 则10位二进制位可以表示的范围是0到1023。基因与自变量转变的公式是x = b2d(individual) * 10 / 1023。构造初始的种群pop。每个个体的基因初始值是[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
根据自变量与基因的转化关系式,求出每个个体的基因对应的自变量,然后将自变量代入函数f(x),求出每个个体的目标函数值。
适应度函数是用来评估个体适应环境的能力,是进行自然选择的依据。本题的适应度函数直接将目标函数值中的负值变成0. 因为我们求的是最大值,所以要使目标函数值是负数的个体不适应环境,使其繁殖后代的能力为0.适应度函数的作用将在自然选择中体现。
自然选择的思想不再赘述,操作使用轮盘赌算法。其具体步骤:
假设种群中共5个个体,适应度函数计算出来的个体适应性列表是fitvalue = [1 ,3, 0, 2, 4] ,totalvalue = 10 , 如果将fitvalue画到圆盘上,值的大小表示在圆盘上的面积。在转动轮盘的过程中,单个模块的面积越大则被选中的概率越大。选择的方法是将fitvalue转化为[1 , 4 ,4 , 6 ,10], fitvalue / totalvalue = [0.1 , 0.4 , 0.4 , 0.6 , 1.0] . 然后产生5个0-1之间的随机数,将随机数从小到大排序,假如是[0.05 , 0.2 , 0.7 , 0.8 ,0.9],则将0号个体、1号个体、4号个体、4号个体、4号个体拷贝到新种群中。自然选择的结果使种群更符合条件了。
假设个体a、b的基因是
a = [1, 0, 0, 0, 0, 1, 1, 1, 0, 0]
b = [0, 0, 0, 1, 1, 0, 1, 1, 1, 1]
这两个个体发生基因交换的概率pc = 0.6.如果要发生基因交换,则产生一个随机数point表示基因交换的位置,假设point = 4,则:
a = [1, 0, 0, 0, 0, 1, 1, 1, 0, 0]
b = [0, 0, 0, 1, 1, 0, 1, 1, 1, 1]
交换后为:
a = [1, 0, 0, 0, 1, 0, 1, 1, 1, 1]
b = [0, 0, 0, 1, 0, 1, 1, 1, 0, 0]
遍历每一个个体,基因的每一位发生突变(0变为1,1变为0)的概率为0.001.突变可以增加解空间
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
def
b2d
(
b
):
#将二进制转化为十进制 x∈[0,10]
t
=
0
for
j
in
range
(
len
(
b
)):
t
+=
b
[
j
]
*
(
math
.
pow
(
2
,
j
))
t
=
t
*
10
/
1023
return
t
popsize
=
50
#种群的大小
#用遗传算法求函数最大值:
#f(x)=10*sin(5x)+7*cos(4x) x∈[0,10]
chromlength
=
10
#基因片段的长度
pc
=
0.6
#两个个体交叉的概率
pm
=
0.001
;
#基因突变的概率
results
=
[[]]
bestindividual
=
[]
bestfit
=
0
fitvalue
=
[]
tempop
=
[[]]
pop
=
[[
0
,
1
,
0
,
1
,
0
,
1
,
0
,
1
,
0
,
1
]
for
i
in
range
(
popsize
)]
for
i
in
range
(
100
):
#繁殖100代
objvalue
=
calobjvalue
(
pop
)
#计算目标函数值
fitvalue
=
calfitvalue
(
objvalue
);
#计算个体的适应值
[
bestindividual
,
bestfit
]
=
best
(
pop
,
fitvalue
)
#选出最好的个体和最好的函数值
results
.
append
([
bestfit
,
b2d
(
bestindividual
)])
#每次繁殖,将最好的结果记录下来
selection
(
pop
,
fitvalue
)
#自然选择,淘汰掉一部分适应性低的个体
crossover
(
pop
,
pc
)
#交叉繁殖
mutation
(
pop
,
pc
)
#基因突变
results
.
sort
()
print
(
results
[
-
1
])
#打印函数最大值和对应的
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
import
math
def
decodechrom
(
pop
):
#将种群的二进制基因转化为十进制(0,1023)
temp
=
[];
for
i
in
range
(
len
(
pop
)):
t
=
0
;
for
j
in
range
(
10
):
t
+=
pop
[
i
][
j
]
*
(
math
.
pow
(
2
,
j
))
temp
.
append
(
t
)
return
temp
def
calobjvalue
(
pop
):
#计算目标函数值
temp1
=
[];
objvalue
=
[];
temp1
=
decodechrom
(
pop
)
for
i
in
range
(
len
(
temp1
)):
x
=
temp1
[
i
]
*
10
/
1023
#(0,1023)转化为 (0,10)
objvalue
.
append
(
10
*
math
.
sin
(
5
*
x
)
+
7
*
math
.
cos
(
4
*
x
))
return
objvalue
#目标函数值objvalue[m] 与个体基因 pop[m] 对应
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import
random
def
crossover
(
pop
,
pc
):
#个体间交叉,实现基因交换
poplen
=
len
(
pop
)
for
i
in
range
(
poplen
-
1
):
if
(
random
.
random
()
<
pc
):
cpoint
=
random
.
randint
(
0
,
len
(
pop
[
0
]))
temp1
=
[]
temp2
=
[]
temp1
.
extend
(
pop
[
i
][
0
:
cpoint
])
temp1
.
extend
(
pop
[
i
+
1
][
cpoint
:
len
(
pop
[
i
])])
temp2
.
extend
(
pop
[
i
+
1
][
0
:
cpoint
])
temp2
.
extend
(
pop
[
i
][
cpoint
:
len
(
pop
[
i
])])
pop
[
i
]
=
temp1
pop
[
i
+
1
]
=
temp2
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
import
random
def
sum
(
fitvalue
):
total
=
0
for
i
in
range
(
len
(
fitvalue
)):
total
+=
fitvalue
[
i
]
return
total
def
cumsum
(
fitvalue
):
for
i
in
range
(
len
(
fitvalue
)):
t
=
0
;
j
=
0
;
while
(
j
<=
i
):
t
+=
fitvalue
[
j
]
j
=
j
+
1
fitvalue
[
i
]
=
t
;
def
selection
(
pop
,
fitvalue
):
#自然选择(轮盘赌算法)
newfitvalue
=
[]
totalfit
=
sum
(
fitvalue
)
for
i
in
range
(
len
(
fitvalue
)):
newfitvalue
.
append
(
fitvalue
[
i
]
/
totalfit
)
cumsum
(
newfitvalue
)
ms
=
[];
poplen
=
len
(
pop
)
for
i
in
range
(
poplen
):
ms
.
append
(
random
.
random
())
#random float list ms
ms
.
sort
()
fitin
=
0
newin
=
0
newpop
=
pop
while
newin
<
poplen
:
if
(
ms
[
newin
]
<
newfitvalue
[
fitin
]):
newpop
[
newin
]
=
pop
[
fitin
]
newin
=
newin
+
1
else
:
fitin
=
fitin
+
1
pop
=
newpop
|