GWO 算法的等级结构
灰狼优化算法是模拟食物链顶端的捕食者狼群的捕食行为产生的算法。灰狼大都喜欢群居, 且具有非常严格的社会等级制度,如图 1 金字塔结 构的等级制度所示。
GWO 算法的数学模型
在 GWO 算法数学建模中,每只灰狼代表种群 中 1 个候选解,将最优解视为 α α α,第二、第三个最佳 候选解视分别为 β β β 和 δ δ δ,其余的候选解视为 ω ω ω。在 GWO 算法中,搜索( 优化) 由 α α α、 β β β 和 δ δ δ 引导, ω ω ω 狼跟随这三只狼。
假设灰狼的种群数量为
N
N
N,搜索空间为
D
i
m
Dim
Dim 维 空间,第
i
i
i 只灰狼在第
D
i
m
Dim
Dim 维空间中的位置向量可 以表 示
X
i
D
i
m
{X_i}^{Dim}
XiDim 灰 狼围捕猎物的数学模型描述如 式( 4) 、式( 5) 所示:
D
=
∣
C
X
p
(
t
)
−
C
(
t
)
∣
(
4
)
X
(
t
+
1
)
=
X
p
(
t
)
−
A
D
(
5
)
D=|CX_p(t)-C(t)|\qquad\qquad(4)\\ X(t+1)=X_p(t)-AD\qquad\qquad(5)
D=∣CXp(t)−C(t)∣(4)X(t+1)=Xp(t)−AD(5)
式(5) 中:
t
t
t 表示当前迭代次数;
A
A
A 和
C
C
C 为系数向量;
X
p
X_p
Xp 为猎物的位置向量;
D
D
D 为灰狼个体与猎物之间的位置 关系向量;
X
X
X 为灰狼的位置向量。
A
、
C
A、C
A、C 计算公式为
A
=
2
a
r
1
−
a
(
6
)
C
=
2
r
2
(
7
)
A=2ar_1-a\qquad\qquad(6)\\ C=2r_2\qquad\qquad(7)
A=2ar1−a(6)C=2r2(7)
式中:
r
1
r_1
r1 和
r
2
r_2
r2 的模是
[
0
,
1
]
[0,1]
[0,1]的随机数;
a
a
a 为收敛因 子,其数值随着迭代次数的增加从 2 线性减小到 0, 计算公式为
a
=
2
−
2
t
t
m
a
x
(
8
)
a=2-\frac{2t}{t_{max}}\qquad\qquad(8)
a=2−tmax2t(8)
式( 8) 中:
t
t
t 为当前迭代次数;
t
m
a
x
t_{max}
tmax为最大迭代次数。 灰狼追踪猎物位置的数学模型描述如式( 9) ~ 式( 11) 所示:
D
α
=
∣
C
1
X
α
−
X
∣
D
β
=
∣
C
2
X
β
−
X
∣
(
9
)
D
δ
=
∣
C
3
X
δ
−
X
∣
D_{\alpha}=|C_1X_\alpha-X|\qquad\qquad\\ D_{\beta}=|C_2X_\beta-X|\qquad\qquad(9)\\ D_{\delta}=|C_3X_\delta-X|\qquad\qquad
Dα=∣C1Xα−X∣Dβ=∣C2Xβ−X∣(9)Dδ=∣C3Xδ−X∣
式中:
C
1
、
C
2
、
C
3
C_1、C_2、C_3
C1、C2、C3 为随机向量;
D
α
、
D
β
D_α、D_β
Dα、Dβ 和
D
δ
D_δ
Dδ 分别为
α
α
α 狼、
β
β
β 狼和
δ
δ
δ 狼与狼群其他成员之间的距离;
X
α
X_α
Xα、
X
β
X_β
Xβ、
X
δ
X_δ
Xδ 分别为
α
α
α 狼、
β
β
β 狼和
δ
δ
δ 狼的位置;
X
X
X 为当前狼的位置。 狼群中
ω
ω
ω 狼的位置由
α
α
α 狼、
β
β
β 狼和
δ
δ
δ 狼共同决定。
灰狼算法的python实现
import random
import numpy
def GWO(objf, lb, ub, dim, SearchAgents_no, Max_iter):
# 初始化 alpha, beta, and delta_pos
Alpha_pos = numpy.zeros(dim) # 位置.形成30的列表
Alpha_score = float("inf") # 这个是表示“正负无穷”,所有数都比 +inf 小;正无穷:float("inf"); 负无穷:float("-inf")
Beta_pos = numpy.zeros(dim)
Beta_score = float("inf")
Delta_pos = numpy.zeros(dim)
Delta_score = float("inf") # float() 函数用于将整数和字符串转换成浮点数。
# list列表类型
if not isinstance(lb, list): # 作用:来判断一个对象是否是一个已知的类型。 其第一个参数(object)为对象,第二个参数(type)为类型名,若对象的类型与参数二的类型相同则返回True
lb = [lb] * dim # 生成[100,100,.....100]30个
if not isinstance(ub, list):
ub = [ub] * dim
# Initialize the positions of search agents初始化所有狼的位置
Positions = numpy.zeros((SearchAgents_no, dim))
for i in range(dim): # 形成5*30个数[-100,100)以内
Positions[:, i] = numpy.random.uniform(0, 1, SearchAgents_no) * (ub[i] - lb[i]) + lb[i] # 形成[5个0-1的数]*100-(-100)-100
Convergence_curve = numpy.zeros(Max_iter)
#迭代寻优
for l in range(0, Max_iter): # 迭代1000
for i in range(0, SearchAgents_no): # 5
# 返回超出搜索空间边界的搜索代理
for j in range(dim): # 30
Positions[i, j] = numpy.clip(Positions[i, j], lb[j], ub[
j]) # clip这个函数将将数组中的元素限制在a_min(-100), a_max(100)之间,大于a_max的就使得它等于 a_max,小于a_min,的就使得它等于a_min。
# 计算每个搜索代理的目标函数
fitness = objf(Positions[i, :]) # 把某行数据带入函数计算
# print("经过计算得到:",fitness)
# Update Alpha, Beta, and Delta
if fitness < Alpha_score:
Alpha_score = fitness # Update alpha
Alpha_pos = Positions[i, :].copy()
if (fitness > Alpha_score and fitness < Beta_score):
Beta_score = fitness # Update beta
Beta_pos = Positions[i, :].copy()
if (fitness > Alpha_score and fitness > Beta_score and fitness < Delta_score):
Delta_score = fitness # Update delta
Delta_pos = Positions[i, :].copy()
# 以上的循环里,Alpha、Beta、Delta
a = 2 - l * ((2) / Max_iter); # a从2线性减少到0
for i in range(0, SearchAgents_no):
for j in range(0, dim):
r1 = random.random() # r1 is a random number in [0,1]主要生成一个0-1的随机浮点数。
r2 = random.random() # r2 is a random number in [0,1]
A1 = 2 * a * r1 - a; # Equation (3.3)
C1 = 2 * r2; # Equation (3.4)
# D_alpha表示候选狼与Alpha狼的距离
D_alpha = abs(C1 * Alpha_pos[j] - Positions[
i, j]); # abs() 函数返回数字的绝对值。Alpha_pos[j]表示Alpha位置,Positions[i,j])候选灰狼所在位置
X1 = Alpha_pos[j] - A1 * D_alpha; # X1表示根据alpha得出的下一代灰狼位置向量
r1 = random.random()
r2 = random.random()
A2 = 2 * a * r1 - a; #
C2 = 2 * r2;
D_beta = abs(C2 * Beta_pos[j] - Positions[i, j]);
X2 = Beta_pos[j] - A2 * D_beta;
r1 = random.random()
r2 = random.random()
A3 = 2 * a * r1 - a;
C3 = 2 * r2;
D_delta = abs(C3 * Delta_pos[j] - Positions[i, j]);
X3 = Delta_pos[j] - A3 * D_delta;
Positions[i, j] = (X1 + X2 + X3) / 3 # 候选狼的位置更新为根据Alpha、Beta、Delta得出的下一代灰狼地址。
Convergence_curve[l] = Alpha_score;
if (l % 1 == 0):
print(['迭代次数为' + str(l) + ' 的迭代结果' + str(Alpha_score)]); # 每一次的迭代结果
#函数
def F1(x):
s=numpy.sum(x**2);
return s
#主程序
func_details = ['F1', -100, 100, 30]
function_name = func_details[0]
Max_iter = 1000#迭代次数
lb = -100#下界
ub = 100#上届
dim = 30#狼的寻值范围
SearchAgents_no = 5#寻值的狼的数量
x = GWO(F1, lb, ub, dim, SearchAgents_no, Max_iter)
寻优结果
文章来源:https://www.toymoban.com/news/detail-411245.html
下载链接
完整带图形输出的下载链接(点击可下载)文章来源地址https://www.toymoban.com/news/detail-411245.html
到了这里,关于灰狼优化算法GWO的理论知识以及python代码实现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!