灰狼优化算法（GWO）python
目录
一、灰狼优化算法的python实现
二、灰狼优化算法与遗传算法的对比分析（python）
2.1 GWO1.py
2.2 GA1.py
2.3 GWO_vs_GA.py
2.4 运行结果
三、基于莱维飞行改进的灰狼优化算法的python实现
一、灰狼优化算法的python实现
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
'''定义函数'''
def function(X0):
'''
:param X0: x的取值
:param dim: 维度
:return: 函数值
'''
s=0
s=1/(1+np.abs(X0[0])+np.abs(X0[1])+np.abs(X0[2])+np.abs(X0[3]))
return s
'''灰狼优化算法——GWO'''
def GWO(NP,dim,NG,amax,x_max,x_min):
'''
:param NP:种群规模
:param dim: 数据维度
:param NG: 最大迭代步数
:param amax: 系数向量初始值
:param x_max: 解允许的最大值
:param x_min: 解允许的最小值
:return: 最优解的目标函数值
'''
'''随机产生初始解'''
X0=np.zeros((NP,dim))
value0=[] #函数值
for i in range(NP):
X0[i]=np.random.uniform(low=x_min,high=x_max,size=(1, dim))
value0.append(function(X0[i]))
'''存储历史最优解和历史最优函数值'''
X_best=[] #历史最优解
value_best=[] #历史最优函数值
'''对初始解的目标函数值进行降序排序，并一一对应得到相应的解'''
#得到对目标函数值列表value0升序排列后的索引
index_sort=np.argsort(np.array(value0))
#对value0进行降序排列
value0_sort=[value0[i] for i in index_sort[::-1]]
#对X0进行相应的排列
X0_sort=[X0[i] for i in index_sort[::-1]]
'''得到初始解的最优解和最优函数值'''
X_best.append(X0_sort[0])
value_best.append(value0_sort[0])
print("--------------------灰狼优化算法--------------------")
print("初始最优解：\n{}".format(X_best[0].tolist()))
print("初始最优函数值：\n{}".format(value_best[0]))
'''选出最优的三个个体，并获得它们的位置信息'''
Xalpha=X0_sort[0]
Xbeta=X0_sort[1]
Xdelta=X0_sort[2]
'''开始利用灰狼优化算法进行训练'''
for i in range(NG):
'''计算系数向量的参数a'''
ratio=i/NG
a=amax*(1-ratio)
'''对每个个体的位置进行更新'''
for j in range(NP):
'''分别计算在函数值最优的前三个个体的影响下，个体的位置移动量X1、X2、X3'''
C1=2*np.random.rand()
Dalpha=np.abs(C1*Xalpha-X0[j])
A1=2*a*np.random.rand()-a
X1=Xalpha-A1*Dalpha
C2=2*np.random.rand()
Dbeta=np.abs(C2*Xbeta-X0[j])
A2=2*a*np.random.rand()-a
X2=Xbeta-A2*Dbeta
C3=2*np.random.rand()
Ddelta=np.abs(C3*Xdelta-X0[j])
A3=2*a*np.random.rand()-a
X3=Xdelta-A3*Ddelta
'''计算个体移动后的位置及函数值'''
X0[j]=(X1+X2+X3)/3
value0[j]=function(X0[j])
'''对种群历史最优解和历史最优函数值进行更新'''
if max(value0)>max(value_best):
value_best.append(max(value0))
X_best.append(X0[value0.index(max(value0))])
else:
value_best.append(value_best[-1])
X_best.append(X_best[-1])
'''对初始解的目标函数值进行降序排序，并一一对应得到相应的解'''
#得到对目标函数值列表value0升序排列后的索引
index_sort=np.argsort(np.array(value0))
#对X0进行相应的降序排列
X0_sort=[X0[i] for i in index_sort[::-1]]
'''选出最优的三个个体，并获得它们的位置信息'''
Xalpha=X0_sort[0]
Xbeta=X0_sort[1]
Xdelta=X0_sort[2]
'''返回最优解和最优函数值'''
return X_best,value_best
二、灰狼优化算法与遗传算法的对比分析（python）
2.1 GWO1.py
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
'''定义函数'''
def function(X0):
'''
:param X0: x的取值
:param dim: 维度
:return: 函数值
'''
s=0
s=1/(1+np.abs(X0[0])+np.abs(X0[1])+np.abs(X0[2])+np.abs(X0[3]))
return s
'''灰狼优化算法——GWO'''
def GWO(NP,dim,NG,amax,x_max,x_min):
'''
:param NP:种群规模
:param dim: 数据维度
:param NG: 最大迭代步数
:param amax: 系数向量初始值
:param x_max: 解允许的最大值
:param x_min: 解允许的最小值
:return: 最优解的目标函数值
'''
'''随机产生初始解'''
X0=np.zeros((NP,dim))
value0=[] #函数值
for i in range(NP):
X0[i]=np.random.uniform(low=x_min,high=x_max,size=(1, dim))
value0.append(function(X0[i]))
'''存储历史最优解和历史最优函数值'''
X_best=[] #历史最优解
value_best=[] #历史最优函数值
'''对初始解的目标函数值进行降序排序，并一一对应得到相应的解'''
#得到对目标函数值列表value0升序排列后的索引
index_sort=np.argsort(np.array(value0))
#对value0进行降序排列
value0_sort=[value0[i] for i in index_sort[::-1]]
#对X0进行相应的排列
X0_sort=[X0[i] for i in index_sort[::-1]]
'''得到初始解的最优解和最优函数值'''
X_best.append(X0_sort[0])
value_best.append(value0_sort[0])
print("--------------------灰狼优化算法--------------------")
print("初始最优解：\n{}".format(X_best[0].tolist()))
print("初始最优函数值：\n{}".format(value_best[0]))
'''选出最优的三个个体，并获得它们的位置信息'''
Xalpha=X0_sort[0]
Xbeta=X0_sort[1]
Xdelta=X0_sort[2]
'''开始利用灰狼优化算法进行训练'''
for i in range(NG):
'''计算系数向量的参数a'''
ratio=i/NG
a=amax*(1-ratio)
'''对每个个体的位置进行更新'''
for j in range(NP):
'''分别计算在函数值最优的前三个个体的影响下，个体的位置移动量X1、X2、X3'''
C1=2*np.random.rand()
Dalpha=np.abs(C1*Xalpha-X0[j])
A1=2*a*np.random.rand()-a
X1=Xalpha-A1*Dalpha
C2=2*np.random.rand()
Dbeta=np.abs(C2*Xbeta-X0[j])
A2=2*a*np.random.rand()-a
X2=Xbeta-A2*Dbeta
C3=2*np.random.rand()
Ddelta=np.abs(C3*Xdelta-X0[j])
A3=2*a*np.random.rand()-a
X3=Xdelta-A3*Ddelta
'''计算个体移动后的位置及函数值'''
X0[j]=(X1+X2+X3)/3
value0[j]=function(X0[j])
'''对种群历史最优解和历史最优函数值进行更新'''
if max(value0)>max(value_best):
value_best.append(max(value0))
X_best.append(X0[value0.index(max(value0))])
else:
value_best.append(value_best[-1])
X_best.append(X_best[-1])
'''对初始解的目标函数值进行降序排序，并一一对应得到相应的解'''
#得到对目标函数值列表value0升序排列后的索引
index_sort=np.argsort(np.array(value0))
#对X0进行相应的降序排列
X0_sort=[X0[i] for i in index_sort[::-1]]
'''选出最优的三个个体，并获得它们的位置信息'''
Xalpha=X0_sort[0]
Xbeta=X0_sort[1]
Xdelta=X0_sort[2]
'''返回最优解和最优函数值'''
return X_best,value_best
2.2 GA1.py
import random
import math
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
'''产生初始种群'''
def initialpopulation(NP,n,x0,x1):
'''NP代表种群规模，n代表目标函数的未知量的个数;
x0代表未知数取值的下限，x1代表未知数取值的上限'''
initial=[]
for i in range(NP):
n_initial=[random.uniform(x0,x1) for j in range(n)]
initial.append(n_initial)
return initial
'''标定适值函数'''
def fitnessfunction(X):
'''X代表存储各个未知量的取值的列表'''
return 1/(math.sqrt(X[0]**2)+math.sqrt(X[1]**2)+math.sqrt(X[2]**2)+math.sqrt(X[3]**2)+1)
'''采用轮盘赌选择算法选择个体'''
def selection(NP,X0):
'''NP代表种群规模，X0代表种群'''
#计算种群中各个个体的适应值
value=[]
for i in range(NP):
value.append(fitnessfunction(X0[i]))
'''计算适应度和累计概率函数'''
#计算选择概率
fsum=0
for i in range(NP):
fsum=fsum+value[i]**2
value_ratio=[]
for i in range(NP):
value_ratio.append((value[i]**2)/fsum)
#计算累加概率
value_ratio_add=[]
for i in range(NP):
if i==0:
value_ratio_add.append(value_ratio[i])
else:
value_ratio_add.append(value_ratio_add[i-1]+value_ratio[i])
#产生[0,1]之间的随机数，进行NP次轮转
random_ratio=[random.uniform(0,1) for i in range(NP)]
#进行轮盘赌选择
choose_index=[] #从0开始计
value_ratio_add0=[0,*value_ratio_add] #在列表value_ratio_add的最前面加上一个0
for i in range(NP):
for j in range(NP):
if random_ratio[i]>=value_ratio_add0[j] and random_ratio[i]=history_max:
history_max=value_max
history.append(history_max)
history_X0.append(valueX0_max)
else:
history.append(history_max)
history_X0.append(history_X0[i-1])
#print("第{}代：{} value_max={}".format(i + 1, history_X0[i], history[i]))
'''选择'''
X1=selection(NP,X0)
'''双切点交叉运算'''
X2=crossover1(X1,pc,NP,4)
'''变异运算'''
X3=mutation(X2,pm,NP,4,-10,10)
X0=X3
print("最优解Best={}".format(history[-1]))
#print("---------------------------------------------------------------进程结束---------------------------------------------------------------")
'''返回历代的最优函数值和最优解'''
return history,history_X0 2.3 GWO_vs_GA.py
import GWO1
import GA1
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
if __name__=="__main__":
'''得到遗传算法求解结果'''
#最大迭代步数
NG=1000
#种群规模
NP=100
#交叉率
pc=0.9
#变异率
pm=0.1
#染色体基因数
n=4
#未知数的下限
x0=-10
#未知数的上限
x1=10
#进行双切点交叉的遗传运算
historymax,historymaxX0=GA1.GA1(NP,NG,n,x0,x1,pc,pm)
print("最优解：\n{}".format(historymaxX0[-1]))
print("最优函数值：\n{}".format(historymax[-1]))
'''得到灰狼优化算法的求解结果'''
#最大迭代步数
NG=1000
#种群规模
NP=100
#数据维度
dim=4
#x允许的最大值和最小值
x_max=10
x_min=-10
#系数向量初始值
amax=2
'''灰狼优化算法'''
X_best,value_best=GWO1.GWO(NP,dim,NG-1,amax,x_max,x_min)
print("最优解：\n{}".format(X_best[-1]))
print("最优函数值：\n{}".format(value_best[-1]))
'''绘制遗传算法和灰狼优化算法的优化过程'''
plt.plot([int(i) for i in range(NG)],historymax,label="GA")
plt.plot([int(i) for i in range(NG)],value_best,label="GWO",c="red")
plt.title("遗传算法（GA）和灰狼优化算法（GWO）的优化过程")
plt.xlabel("代数")
plt.ylabel("函数值")
plt.grid()
plt.legend()
plt.show()
2.4 运行结果
三、基于莱维飞行改进的灰狼优化算法的python实现
import numpy as np
import math
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
'''定义函数并求解函数值'''
def function(X0):
'''
:param X0:解向量
:return: 函数值
'''
s1=0
for i in range(len(X0)):
s1=s1+(X0[i])**2
s2=0
for i in range(len(X0)):
s2=s2+np.cos(2*(np.pi)*X0[i])
s=-20*np.exp(-0.2*(np.sqrt((1/len(X0))*s1)))-np.exp((1/len(X0))*s2)+20+np.e
return s
'''嵌入莱维飞行的灰狼优化算法'''
def LGWO(NP,dim,NG,amax,x_max,x_min):
'''
:param NP:种群规模
:param dim: 数据维度
:param NG: 最大迭代步数
:param amax: 系数向量初始值
:param x_max: 解允许的最大值
:param x_min: 解允许的最小值
:return: 最优解和最优解的目标函数值
'''
'''随机产生初始解'''
X0=np.zeros((NP,dim))
value0=[] #函数值
for i in range(NP):
X0[i]=np.random.uniform(low=x_min,high=x_max,size=(1, dim))
value0.append(function(X0[i]))
'''存储历史最优解和历史最优函数值'''
X_best=[] #历史最优解
value_best=[] #历史最优函数值
'''对初始解的目标函数值进行升序排序，并一一对应得到相应的解'''
#得到对目标函数值列表value0升序排列后的索引
index_sort=np.argsort(np.array(value0))
#对value0进行升序排列
value0_sort=[value0[i] for i in index_sort]
#对X0进行相应的排列
X0_sort=[X0[i] for i in index_sort]
'''得到初始解的最优解和最优函数值'''
X_best.append(X0_sort[0])
value_best.append(value0_sort[0])
print("初始最优解：\n{}".format(X_best[0].tolist()))
print("初始最优函数值：\n{}".format(value_best[0]))
'''选出最优的两个个体，并获得它们的位置信息'''
Xalpha=X0_sort[0]
Xalpha_score=value0_sort[0]
Xbeta=X0_sort[1]
Xbeta_score=value0_sort[1]
'''进行嵌入莱维飞行的灰狼优化算法'''
for i in range(NG):
'''计算系数向量的参数a'''
ratio=i/NG
a=amax*(1-ratio)
for j in range(NP):
'''边界处理'''
for k in range(dim):
if X0[j][k]>x_max:
X0[j][k]=x_max
if X0[j][k]function(X0_old) and rnew 
