import random
import numpy as np
import geatpy as ea
import xlrd
import math
import matplotlib.pyplot as plt
import xlwt
import pysnooper
plt.rcParams['font.sans-serif'] = ['SimHei']
##已知数据
q1='F:\共享车选址调度\共享汽车数据\候选点之间的OD(13).xlsx'
T1='F:\共享车选址调度\共享汽车数据\候选点之间的最短期望时间Tik(13).xlsx'
wt1='F:\共享车选址调度\共享汽车数据\需求中心到备选点的步行时间(50行13列).xlsx'
D1='F:\共享车选址调度\共享汽车数据\每个需求中心的需求量(50网格).xlsx'
# ####excel转为矩阵
def excel_to_matrix(path,a): #路径,sheet
table = xlrd.open_workbook(path).sheets()[a]#获取第一个sheet表
row = table.nrows # 行数
col = table.ncols # 列数
datamatrix = np.zeros((row, col))#生成一个nrows行ncols列,且元素均为0的初始矩阵
for x in range(col):
cols = np.matrix(table.col_values(x)) # 把list转换为矩阵进行矩阵操作
datamatrix[:, x] = cols # 按列把数据存进矩阵中
return datamatrix
q=excel_to_matrix(q1,0)
T=excel_to_matrix(T1,0)
wt=excel_to_matrix(wt1,0)
D=excel_to_matrix(D1,1) # 多维数组,50行1列
# #############参数##########################
Cs=1*10
Cp=12*10
Cv=56*10
Ce=6
M=10000
alpha=0.8
beta=0.5
gama=2
I=13
J=50
Pmax=100
w1=50
H =500000 # 成本的最大值
##########################################
##距离衰减
s=np.zeros((J, I)) # 创建一个J*I的零矩阵,矩阵这里zeros函数的参数是一个tuple类型(J,I)
for i in range(I):
for j in range(J):
if wt[j,i]<w1:
a=-(wt[j,i])**4+w1**4
b=(w1**4)*(math.exp((wt[j,i]/40)**3))
s[j,i]=a/b
elif wt[j,i]>w1:
s[j,i]=0
## qik/qi
n=np.zeros((J, I))
for i in range(I):
for k in range(I):
if sum(q[i])>0: #每一行的和
n[i,k]=q[i,k]/sum(q[i])
else:
n[i,k]=0
'''1.目标函数'''
def objection(X,P,V,z):
z0=np.array(z).reshape(J,I) #列表转一维数组,转多维数组
for i in range(I):
Ti = T[i, :] # 多维数组,第i行
ni = n[i, :]
ui= [sum(D[:,0]*z0[:,i]*s[:,i]) for i in range(I)] # 输出为一个列表,其中含有13个元素,表示分布从13个备选站点出发的租车辆
# ob = [Cs * X[i] + Cp * P[i] + Cv * V[i] + Ce * sum(Ti * ni) * ui[i] for i in range(I)] # 输出为一个列表,其中含有13个元素,每个元素对应一个站点的成本
obj=sum([Cs * X[i] + Cp * P[i] + Cv * V[i] + Ce * sum(Ti * ni) * ui[i] for i in range(I)]) #输出结果为总成本,约29万
return obj
'''2.实数编码'''
def code():
Chrom = []
X_0 = np.random.randint(0, 2, I) # 随机产生13个只含0,1元素的列表,13为初始种群的个数
P_0 = np.random.randint(2, 101, I) # 随机产生13个2到100中的正整数的列表,如果取0,1,V_0的取值要小于0.8*0/1,是没有值的
V_0 = np.random.randint(1, 81, I) # 随机产生13个1到80中的正整数的列表.80=100*alpha.
z0 = np.random.random((J, I)) # J=50,I=30,50行13列的二维数组
for i in range(len(X_0)):
if X_0[i] == 0:
P_0[i], V_0[i], z0[:, i] = 0, 0, 0 # 如果站点没有被选中,X_0[i] = 0,那么V,P,z都为0
else:
P_0[i], V_0[i], z0[:, i] = P_0[i], np.random.randint(1, math.ceil(alpha*P_0[i])), z0[:,
i] # 如果站点被选中,X_0[i] = 1,那么V,z不变,P=alpha*V
z_0 = z0.flatten() # 转化为一维数组,按行转化
u_0 = [sum(D[j, 0] * z_0[I * j + i] * s[j, i] * n[i, k] for j in range(J)) for i in range(I) for k in
range(I)] # 含有I*I=169个元素,uik
Chrom.extend(X_0)
Chrom.extend(P_0)
Chrom.extend(V_0)
Chrom.extend(z_0)
Chrom.extend(u_0)
return Chrom
'''3.区分各个变量'''
def Chrom_to_var(Chrom):
X=Chrom[:I] #前13个元素为X
P=Chrom[I:2*I] # 共13个元素
V=Chrom[2*I:3*I] # 共13个元素
z=Chrom[3*I:3*I+I*J] # 共50*13个元素
u=Chrom[3*I+I*J:] # 共13*13个元素
return X,P,V,z,u
'''5.需求约束'''
# @pysnooper.snoop()
def demand_feasible(Chrom):
X,P,V,z,u=Chrom_to_var(Chrom)
g5 =[z[I*j+i]-X[i] for i in range(I) for j in range(J)] # J*I个约束
# g5_n = np.array(g5).reshape(J, I) # 将一维列表转化为J行I列的数组
# g5_c = [sum(g5_n[:, i]) for i in range(I)] # 对每一列求和,得到每个染色体(每个站点)对应的约束,输出为含有I个元素的列表
g6 =[sum(z[I * j + i] for i in range(I))-1 for j in range(J)] # J个约束
g7 =[sum(D[j,0]*z[I*j+i] for i in range(I))-D[j,0] for j in range(J)] # J个约束
g8 =[sum(D[j,0]*z[I*j+i] for j in range(J))-P[i] for i in range(I)] # I个约束
g9 =[beta*sum(D[j,0] for j in range(J))-sum(sum(D[j,0]*z[I*j+i]*s[j,i] for i in range(I)) for j in range(J))] # 1个约束
# g10 =[sum(D[j,0]*z[I*j+i]*s[j,i]*n[i,k] for j in range(J))-u[I*i+k] for i in range(I) for k in range(I)] # I*I个约束
# g11 =[u[I*i+k]-sum(D[j,0]*z[I*j+i]*s[j,i]*n[i,k] for j in range(J)) for i in range(I) for k in range(I)] # I*I个约束
g12 =[sum(u[I*i+k] for k in range(I))-V[i] for i in range(I)] # I个约束
g13 =[sum(u[I*i+k] for i in range(I) for k in range(I))*0.657+11.89-sum(V[i] for i in range(I))] # 1个约束
g_1 = g5+g6+g7+g8+g9+g12+g13 # 将前面所以约束放到同一个列表中,1116个元素
g_pos = sum([abs(i) for i in g_1]) # 将g_1中的元素转化为正值并求和
num_cons = I*J+J+J+I+1+I+1
rhs = [0] * num_cons # 输出为有I*J+J+J+I+1+I*I+I*I+I+1个元素的列表,每个元素都是0
cons_1 = [g_1[m] <= rhs[m] for m in range(len(rhs))] # 前面将约束写为<=0的形式,这里进行判断,输出为[True,False……]
return g_1,g_pos,cons_1
'''6.产生初始种群'''
def initial_pop(Nind): # Nind为种群数量
pop=[]
i=0
while i<Nind:
IND=code()
pop.append(IND)
i += 1
return pop # 输出为含有Nind个染色体的种群,是一个列表
'''7.计算适应度'''
def get_fitness(pop, Nind,C,c): # C是一个足够大的数,目标函数的最大估计,Nind为种群数量
fit=[]
for i in range(Nind):
X=Chrom_to_var(pop[i])[0]
P = Chrom_to_var(pop[i])[1]
V = Chrom_to_var(pop[i])[2]
z = Chrom_to_var(pop[i])[3]
H=objection(X,P,V,z)
if all(demand_feasible(pop[i])[2]) is True:
fitness=C-H # Z为目标函数
else:
fitness=C-H-c*demand_feasible(pop[i])[1] #g(x)为约束条件,c为正值常数
fit.append(fitness) # 将每次循环的结果存入列表中,输出为[89688.98555388054, 144668.3419467736, 97700.61376721218, 173935.77171023752, 160989.79620219418]
return fit
'''8.适应度排序'''
def fit_sort(fit):
fit2 = fit[:] # 通过分片操作将列表FitnV_l的元素全部拷贝给FitnV2,产生一个新副本,不改变fit的适应度排序,便于后面染色体的索引
fit2.sort(reverse=True) # 适应度降序排序,产生一个排序好的副本,同时保持原有列表不变
return fit2
'''9.得到精英个体'''
def get_elite(pop,fit,fit2,eli_n):
Se_eli =fit2[:eli_n] #选择前eli_n个个体直接进入子代
See_ind = [fit.index(i) for i in Se_eli] #得到被选择个体的索引
pop_e=[]
for i in See_ind:
pop_e.append(pop[i])
return pop_e # 返回值为直接进入子代的精英个体
'''10.自然选择:轮盘赌'''
def selection(pop,fit,Nsel):
# USe_eli = fit2[eli_n:] # 精英选择中未被选择的个体
n_fit=len(fit)
USe_eli1=np.array(fit).reshape(n_fit,1) # 转化为多维数组,N为种群数量
se_ind =ea.rws(USe_eli1,Nsel) # 得到被选择个体的索引, Nsel被选择个体的数目
pop_s = []
for i in se_ind:
pop_s.append(pop[i])
return pop_s # 列表嵌套列表,外列表内有Nsel个元素,每个元素代表一个个体,内列表有I+I+I+J*I+I*I个元素,每个元素代表一个基因
# pop_1 = selection(pop,fit,Nsel) # 参与交叉的个体
# print(pop_1)
'''11.交叉:线性交叉'''
def crossover(pop_s,pc):
j = 0
while j <= 2:
chrom = random.sample(pop_s, 2) # 抽取pop_1中的两个个体染色体进行交叉。[[],[]]
# print(chrom)
chrom_ind = [pop_s.index(i) for i in chrom] # 得到进行交叉的染色体在pop_1中的索引
# n_chorm=pop_1[row_rand_array[2:]]
c_point1 = random.randint(0, len(chrom[0])-1)
c_point2 = random.randint(0, len(chrom[0])-1) # 随机得到两个数,用于确定交叉的起止点
if c_point1 <= c_point2:
s_point = c_point1
e_point = c_point2
else:
s_point = c_point2 # 小的数作为起点
e_point = c_point1 # 大的数作为终点
# print(s_point, e_point)
r = random.random()
if r > pc: # 如果小于交叉概率
pop_s[chrom_ind[0]] = pop_s[chrom_ind[0]] # 两个染色体不进行交叉操作
pop_s[chrom_ind[1]] = pop_s[chrom_ind[1]]
# print(new_C)
else:
a = random.random()
b = random.random()
# print(a, b)
chrom_n1 = chrom[0] # 父代1
chrom_n2 = chrom[1] # 父代2
for i in range(s_point, e_point + 1): # 遍历每个交叉点
Ge1 = chrom[0][i] # 父代1交叉前的基因
Ge2 = chrom[1][i]
if 0<=i<=3*I-1: #如果进行交叉的基因是前3*I个,前3*I个基因为整数型,要进行判断
Ge1 = int(Ge2 + a * (Ge1 - Ge2))
Ge2 = int(Ge1 + b * (Ge2 - Ge1)) # 交叉后的基因
else: # 后面的基因是浮点型
Ge1 = Ge2 + a * (Ge1 - Ge2)
Ge2 = Ge1 + b * (Ge2 - Ge1)
# print(Ge1, Ge2)
chrom_n1[i] = Ge1
chrom_n2[i] = Ge2 #更新染色体
for chrom_c in [chrom_n1,chrom_n2]: #对交叉后的两个染色体分别进行判断是否满足基本约束条件
for k in range(I):
if chrom_c[k] == 0: #如果X=0,站点没有被选中
chrom_c[I + k] = 0 # 对应的P=0
chrom_c[2 * I + k] = 0 # 对应的V=0
for g in range(0, J ):
chrom_c[(g+3) * I + k] = 0 # 对应的z=0
for t in range(I):
chrom_c[(3 + J + k) * I + t] = 0
else:
chrom_c[I + k] = chrom_c[I + k] # 对应的P=交叉后的结果,不改变
chrom_c[2 * I + k] = np.random.randint(0, math.ceil(alpha*chrom_c[I + k])) # 对应的V=alpha*P
# 对应的z=0
for g in range(0, J ):
chrom_c[(g+3) * I + k] = chrom_c[(g+3) * I + k] # 对应的z=交叉后的结果,不改变
for t in range(I): # u与z的对应关系
chrom_c[(3 + J + k) * I + t] = sum(D[j, 0] * chrom_c[(j+3) * I + k] * s[j, k] * n[k, t] for j in range(J))
# print(chorm_n1, chorm_n2)
# print(chorm_n1, chorm_n2) # 注意缩进,只要最后每个点交叉后最终的迭代结果
pop_s[chrom_ind[0]] = chrom_n1
pop_s[chrom_ind[1]] = chrom_n2 # 更新整个种群,将交叉后的染色体存入种群中
j += 2
return pop_s
# @pysnooper.snoop()
def mutate(pop_s,pm):
j = 0
while j <= 3:
px = len(pop_s) # 种群中染色体的数目
py = len(pop_s[0]) #每个染色体中基因的数目
im = random.randint(0, px - 1) # im为进行变异的染色体的索引
# chrom_m = pop_1[im] # 进行变异的染色体
# 判断每条染色体的每个基因是否需要变异
for i in range(py):
if (random.random() > pm):
pop_s[im][i] = pop_s[im][i] # 如果随机值小于变异概率,则不需变异,基因不改变
else:
if 0 <= i <= I-1: # 如果进行变异的基因是X,前I个
if pop_s[im][i]==0: # 如果该基因取值为0
pop_s[im][i] = 1 # 变异后的基因为1
pop_s[im][I+i]= random.randint(2, 101) # 对应的P值也不等于0,在取值范围中随机产生一个值
pop_s[im][2*I+i]=random.randint(1,math.ceil(alpha*pop_s[im][I+i])) # V=alpha*P 向上取值
for g in range(0, J):
pop_s[im][(g + 3) * I + i] =random.uniform(0, 1) #对应的z值
for t in range(I): # u是与z有关的变量,随z变化
pop_s[im][(3 + J + i) * I + t]=sum(D[j, 0] * pop_s[im][(j+3) * I + i] * s[j, i] * n[i, t] for j in range(J))
else:
pop_s[im][i]=0 # 否则,变异为0,那么对应的P,V,z,u都取0
pop_s[im][I + i] =0
pop_s[im][2 * I + i] =0
for g in range(0, J):
pop_s[im][(g + 3) * I + i]=0
for t in range(I):
pop_s[im][(3 + J + i) * I + t]=0
elif i <=2*I-1: # 如果变异基因为P
if pop_s[im][i]==0: # 规定是P不为0是才进行变异,若P=0
pop_s[im][i] =0 # 该值仍取0
else: # 若P不为0
pop_s[im][i] = random.randint(2, 100) # 变异值为范围内随机一个值
pop_s[im][I+i]=random.randint(1,math.ceil(pop_s[im][i]*alpha)) # 对应的V=P*alpha
elif i <=3*I-1: # 如果变异基因为V
if pop_s[im][i]==0: # 规定是V不为0是才进行变异,若V=0
pop_s[im][i] =0 # 该仍取0
else: # 若V不为0
pop_s[im][i] = random.randint(0, pop_s[im][i-I])
elif i <=(3+I)*J-1: # 如果变异基因为z
if pop_s[im][i]==0: # 规定是z不为0是才进行变异,若z=0
pop_s[im][i] =0 # 该仍取0
else: # 若z不为0
pop_s[im][i] = random.uniform(0, 1) # 变异值在0,1内随机生成一个小数
k = divmod(i-3*I, I)[1] #k=i-3*I/I的余数,将i值从(3*I-(3+J)*I-1)映射到(0,I-1)
for t in range(I): #用k代替279行中的i,得到u关于z的关系式
pop_s[im][(3 + J +k) * I + t]=sum(D[j, 0] * pop_s[im][(j+3)*I+k] * s[j, k] * n[k, t] for j in range(J))
else:
pop_s[im][i] = pop_s[im][i] # u值不变异,根据z值得到
j+=1
return pop_s
# @pysnooper.snoop()
def evlotion(obj_mins,obj_minb,pop_newi,chrom_optii,epsilon):
j=0
ite_num=[0]
obj_opt=[obj_mins]
while obj_minb-obj_mins>epsilon: # 如果两次迭代的结果<epsilon,终止迭代
fit = get_fitness(pop_newi, 7, 500000, 0.5) # 得到每个个体的适应度,列表
fit2 = fit_sort(fit) # 得到降序排列的适应度
pop_e = get_elite(pop_newi, fit, fit2, 2) # 选取2个精英个体直接进入子代
pop_s = selection(pop_newi, fit, 6) # 从初始种群中选择6个进行遗传操作
pop_c = crossover(pop_s, 0.7) # 得到交叉后的个体,列表,内含6个个体
# print(pop_c)
# print(len(pop_c))
fit_c = get_fitness(pop_c, 6, 500000, 0.5) # 得到交叉后的种群中的每个个体的适应度
fit_c2 = fit_sort(fit_c) # 得到降序排列的适应度
pop_e2 = get_elite(pop_c, fit_c, fit_c2, 2) # 从交叉后的种群中选择eli_n个直接进入子代
pop_m = mutate(pop_c, 0.2) # 得到变异后的种群
# print(pop_m)
# print(len(pop_m))
fit_m = get_fitness(pop_m, 6, 500000, 0.5) # 得到交叉后的种群中的每个个体的适应度
fit_m2 = fit_sort(fit_m)
pop_e3 = get_elite(pop_m, fit_m, fit_m2, 3) # 种群中共7个个体,父代和交叉后各两个直接进入子代,则变异后只需适应度前3的个体
pop_new2 = pop_e + pop_e2 + pop_e3 # 产生一个新的子代种群
obj = []
for i in range(len(pop_new2)):
Chrom_ave = pop_new2[i] # 子代中的每一个个体
X = Chrom_to_var(Chrom_ave)[0]
P = Chrom_to_var(Chrom_ave)[1]
V = Chrom_to_var(Chrom_ave)[2]
z = Chrom_to_var(Chrom_ave)[3]
obj_a = objection(X, P, V, z) # 一个个体的目标函数值
obj.append(obj_a) # obj中包括每一个个体的目标值,列表
obj_min2 = min(obj) # 得到子代中的最优个体的目标值
opti_index2 = obj.index(obj_min2) # 得到最优目标值的索引
chrom_opti2 = pop_new2[opti_index2] # 得到最优目标值对应的最优个体
# print(obj_min2)
if obj_mins<obj_min2: # 将产生的新子代的最优值与之前得到的最优值进行比较
obj_mins=obj_mins # 将小的那个储存在obj_mins中,若迭代终止,该值存储着最优值
obj_minb = obj_min2 # 将大的那个储存在obj_minb中
pop_newi=pop_newi # 将小的最优值对应的子代储存在pop_newi,作为产生新子代的父代,参与下面的迭代
chrom_optii=chrom_optii # 最优值对应的个体,若迭代终止,该值存储着最优个体
else:
obj_mins=obj_min2
obj_minb = obj_mins
pop_newi = pop_new2
chrom_optii=chrom_opti2
j+=1
ite_num.append(j)
obj_opt.append(obj_mins)
print(j)
print(obj_opt)
x_axis_data = ite_num
y_axis_data = obj_opt
# plot中参数的含义分别是横轴值,纵轴值,颜色,透明度和标签
plt.plot(x_axis_data, y_axis_data, 'ro-', color='#4169E1', alpha=0.8, label='进化过程')
# 显示标签,如果不加这句,即使加了label='进化过程'的参数,最终还是不会显示标签
plt.legend(loc="upper right")
plt.xlabel('进化次数')
plt.ylabel('最低成本')
plt.show()
return obj_mins,chrom_optii,j
if __name__ == '__main__':
pop = initial_pop(7) # 初始种群,内有7个个体,列表
print(pop)
print(len(pop))
fit = get_fitness(pop, 7, 2000000, 0.5) # 得到每个个体的适应度,列表
fit2 = fit_sort(fit) #得到降序排列的适应度
pop_e = get_elite(pop, fit, fit2, 2) # 选取2个精英个体直接进入子代
pop_s = selection(pop, fit, 6) # 从初始种群中选择6个进行遗传操作
print(pop_s)
print(len(pop_s))
pop_c = crossover(pop_s, 0.7) # 得到交叉后的个体,列表,内含6个个体
# print(pop_c)
# print(len(pop_c))
fit_c=get_fitness(pop_c,6,500000,0.5) # 得到交叉后的种群中的每个个体的适应度
fit_c2=fit_sort(fit_c) #得到降序排列的适应度
pop_e2=get_elite(pop_c,fit_c,fit_c2,2) # 从交叉后的种群中选择eli_n个直接进入子代
pop_m = mutate(pop_c, 0.2) # 得到变异后的种群
# print(pop_m)
# print(len(pop_m))
fit_m = get_fitness(pop_m, 6, 500000, 0.5) # 得到交叉后的种群中的每个个体的适应度
fit_m2 = fit_sort(fit_m)
pop_e3 = get_elite(pop_m, fit_m, fit_m2, 3) # 种群中共7个个体,父代和交叉后各两个直接进入子代,则变异后只需适应度前3的个体
pop_new = pop_e + pop_e2 + pop_e3
print(pop_new)
print(len(pop_new))
obj = []
for i in range(len(pop_new)):
Chrom_a = pop_new[i] #子代中的每一个个体
X = Chrom_to_var(Chrom_a)[0]
P = Chrom_to_var(Chrom_a)[1]
V = Chrom_to_var(Chrom_a)[2]
z = Chrom_to_var(Chrom_a)[3]
obj_a = objection(X, P, V, z) # 一个个体的目标函数值
obj.append(obj_a) # obj中包括每一个个体的目标值,列表
obj_min = min(obj) #得到子代中的最优个体的目标值
opti_index=obj.index(obj_min) # 得到最优目标值的索引
chrom_opti=pop_new[opti_index] # 得到最优目标值对应的最优个体
print(obj,obj_min)
# print(chrom_opti)
fit1 = get_fitness(pop_new, 7, 500000, 0.5) # 得到每个个体的适应度,列表
fit21 = fit_sort(fit1) # 得到降序排列的适应度
pop_e1 = get_elite(pop_new, fit1, fit21, 2) # 选取2个精英个体直接进入子代
pop_s1 = selection(pop_new, fit1, 6) # 从初始种群中选择6个进行遗传操作
pop_c1 = crossover(pop_s1, 0.7) # 得到交叉后的个体,列表,内含6个个体
# print(pop_c)
# print(len(pop_c))
fit_c1 = get_fitness(pop_c1, 6, 500000, 0.5) # 得到交叉后的种群中的每个个体的适应度
fit_c21 = fit_sort(fit_c1) # 得到降序排列的适应度
pop_e21 = get_elite(pop_c1, fit_c1, fit_c21, 2) # 从交叉后的种群中选择eli_n个直接进入子代
pop_m1 = mutate(pop_c1, 0.2) # 得到变异后的种群
# print(pop_m)
# print(len(pop_m))
fit_m1 = get_fitness(pop_m1, 6, 500000, 0.5) # 得到交叉后的种群中的每个个体的适应度
fit_m21 = fit_sort(fit_m1)
pop_e31 = get_elite(pop_m1, fit_m1, fit_m21, 3) # 种群中共7个个体,父代和交叉后各两个直接进入子代,则变异后只需适应度前3的个体
pop_new1 = pop_e1 + pop_e21 + pop_e31 # 产生一个新的子代,这是第二个子代
obj1 = []
for i in range(len(pop_new1)):
Chrom_ave1 = pop_new1[i] # 子代中的每一个个体
X1 = Chrom_to_var(Chrom_ave1)[0]
P1 = Chrom_to_var(Chrom_ave1)[1]
V1 = Chrom_to_var(Chrom_ave1)[2]
z1 = Chrom_to_var(Chrom_ave1)[3]
obj_a1 = objection(X1, P1, V1, z1) # 一个个体的目标函数值
obj1.append(obj_a1) # obj中包括每一个个体的目标值,列表
obj_min1 = min(obj1) # 得到子代中的最优个体的目标值j
opti_index1 = obj1.index(obj_min1) # 得到最优目标值的索引
chrom_opti1 = pop_new1[opti_index1] # 得到最优目标值对应的最优个体
print(obj1,obj_min1)
# print(chrom_opti1)
if obj_min1<obj_min: # 比较两个子代的最优值
obj_mins=obj_min1 # 将小的那个储存在obj_min1中
obj_minb=obj_min
pop_newi=pop_new1 # 将小的最优值对应的子代储存在pop_newi,作为产生新子代的父代,参与下面的迭代
chrom_optii=chrom_opti1 # 最优值对应的个体
else:
obj_mins=obj_min
obj_minb = obj_min1
pop_newi = pop_new
chrom_optii=chrom_opti
print(obj_mins,obj_minb)
obj_minf=evlotion(obj_mins,obj_minb,pop_newi,chrom_optii,10000)[0]
chrom_optif=evlotion(obj_mins,obj_minb,pop_newi,chrom_optii,10000)[1]
evl_num=evlotion(obj_mins,obj_minb,pop_newi,chrom_optii,10000)[2]
print('最小成本:%d' % obj_minf)
print('最优结果:%s' % chrom_optif)
print('进化次数:%d' % evl_num)
book = xlwt.Workbook(encoding='utf-8') # 创建Workbook,相当于创建Excel
# 创建sheet,Sheet1为表的名字,cell_overwrite_ok为是否覆盖单元格
sheet1 = book.add_sheet(u'Sheet1', cell_overwrite_ok=True)
# 向表中添加数据
sheet1.write(0, 0, '最小成本') # 第0行第0列
sheet1.write(0, 1, obj_minf) #第0行第1列
sheet1.write(1, 0, '最优结果') # 第1行第0列
chrom_optis=" ".join('%s' %id for id in chrom_optif)
print(chrom_optis)
sheet1.write(1, 1, chrom_optis) # 先将列表中的数字转化为字符串,然后整个列表转字符串
sheet1.write(2, 0, '进化次数') # 第1行第0列
sheet1.write(2, 1, evl_num)
book.save(r'C:\Users\Administrator\Desktop\站点选择结果.xls')
遗传算法包括进化的整个过程,对于结束进化的条件,若两次进化之差小于某值则停止,有点问题,需调整
猜你喜欢
转载自blog.csdn.net/huahua20190514/article/details/103948250
今日推荐
周排行