课程要求函数如下：

sqrt为开根号运算，x(j)的取值范围为[-500,500],初始群体大小为100。

适应度函数的大小就是函数值大小，仅仅做了归一化。

以后可能还会用到，代码做个保存，具体实现如下：交叉，畸变，选择概率可以根据具体情况修改

import matplotlib.pyplot as plt

import numpy as np

import random

import math

# 定义遗传算法参数

pop_size = 100 # 种群大小

generation = 10 # 最大遗传代数

length = 30 # 个体长度

pc = 0.65 # 交叉概率

# 变异产生新的个体，选择导致个体消亡，可以通过调节变异概率和选择概率保证种群完好

pm = 0.1 # 变异概率

# 每个个体随机编码

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

# 计算目标值 x介于lb和ub之间

def calValue(pop, length, lb, ub):

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函数值

x_value.append(x)

obj_value.append(np.sin(np.sqrt(x))*x) # 计算y函数值

return obj_value

# 计算适应度 适应度就是对应的函数值

def fitness(pop, length, lb, ub):

obj_value = calValue(pop, length, lb, ub)

fit_value = []

for i in range(len(obj_value)):

fit_value.append(obj_value[i])

# fitness_value = list(map(abs, fitness_value))

fit_value = list(map(lambda x: -x+max(fit_value), fit_value))

return fit_value

# 选择函数 根据适应度值进行选择

def selection(pop, fitness_value):

newfitness_value = []

accumulation_value = []

# total_fit = np.sum(fitness_value)

fit_min = np.min(fitness_value)

fit_max = np.max(fitness_value)

for i in range(len(fitness_value)):

newfitness_value.append(fitness_value[i]-fit_min/(fit_max - fit_min)) # 计算适应度的相对值

accumulation_value = newfitness_value

ms = []

for i in range(len(pop)):

ms.append(random.random())

newpop = []

for j in range(len(accumulation_value)):

if 0.01 < accumulation_value[j]:

if j >= len(pop):

print(j, len(pop))

t = pop[j]

newpop.append(t)

# # 人口膨胀

# if len(accumulation_value)>1000:

return newpop

# 交叉函数

def crossover(pop, fitness_value, pc):

new_pop = selection(pop, fitness_value)

m = len(new_pop)

# n = len(new_pop[0])/2 # 一半的基因交叉重组

for i in range(m-1):

# rm = random.randint(0, m-1)

if random.random() < pc:

# 父代可以不保存

# new1 = new_pop[i].copy()

# new2 = new_pop[rm].copy()

for j in range(10):

k = random.randint(0, length-1)

temp1 = new_pop[i][k]

temp2 = new_pop[i+1][k]

new_pop[i+1][k] = temp1

new_pop[i][k] = temp2

# new_pop.append(new1)

return new_pop

# 变异函数

def mutation(pop, fitness_value, pc, pm, length):

newpop = crossover(pop, fitness_value, pc)

for i in range(len(newpop)):

new = []

if random.random() < pm:

new = newpop[i].copy()

m1 = random.randint(0, length-1)

m2 = random.randint(0, length - 1)

m3 = random.randint(0, length - 1)

if new[m1] == 1:

new[m1] = 0

else:

new[m1] = 1

if new[m2] == 1:

new[m2] = 0

else:

new[m2] = 1

if new[m3] == 1:

new[m3] = 0

else:

new[m3] = 1

newpop.append(new)

return newpop

if __name__ == "__main__":

# 画出函数图

plt.figure(1)

lb = 0

ub = 500

x = np.arange(lb, ub, 0.01)

y = np.sin(np.sqrt(x))*x

plt.plot(x, y)

plt.xlabel("自变量X"); plt.ylabel("应变量Y"); plt.title("sin(sqrt(x)*x")

# 初始化群体

pop = genEncoding(pop_size, length)

obj_value = calValue(pop, length, lb, ub)

gen = 0

x_value = []

best_x = []

best_individual = []

Generation = []

Mmax = 0

while gen < generation:

# 计算函数值

fit_value = fitness(pop, length, lb, ub)

# 交叉变异

newpop = mutation(pop, fit_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 = calValue(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) # 最佳个体

if obj_value[j] > Mmax:

Mmax = obj_value[j]

best_x.append(x_value[j])

fitness_value = fitness(newpop, length, lb, ub)

Generation.append(gen)

gen = gen+1

pop = newpop

k = 0

j = 0

for i in range(len(best_individual)):

if k > best_individual[i]:

k = best_individual[i]

j = i

print(max(best_individual))

print(-Mmax*30)

best_individual.sort(reverse=True)

plt.figure(2)

plt.plot(Generation, best_individual)

plt.xlabel("遗传代数")

plt.ylabel("解的变化")

plt.title("进化过程")

plt.show()

实验结果如下：

最佳个体最大函数值max(best_individual)：418.98264752959625

原函数最小值-max(best_individual)*30：-12569.479425887888