最优化matlab代码,matlab智能算法30个案例分析代码

　　灰狼优化算法是一种群体智能优化算法，其独特之处在于少数拥有绝对话语权的灰狼带领一群灰狼走向猎物。本文具体介绍了灰狼优化算法的两个实现示例代码，可供参考。

　　00-1010 1灰狼优化算法的基本思想2灰狼捕食猎物的过程2.1社会等级2.2包围猎物2.3狩猎2.4攻击猎物2.5搜索猎物3实现步骤及程序框图3.1步骤3.2程序框图4 Python代码实现5 Matlab实现

　　灰狼一般分为四个等级：第一级的灰狼用表示，第二级的灰狼用表示，第三级的灰狼用表示，第四级的灰狼用表示。根据上面的分类，灰狼对灰狼，，有绝对优势。灰太狼对灰太狼和有绝对优势；灰太狼对灰太狼有绝对控制权。

1 灰狼优化算法基本思想

　　GWO优化过程包括灰狼的社会分层、跟踪、包围和攻击猎物等步骤，步骤细节如下。

2 灰狼捕食猎物过程

　　在设计《GWO》时，我们首先要构建灰太狼的社会等级模型。计算种群中每个个体的适应度，将适应度最好的三只灰狼标记为、、，其余灰狼标记为。也就是说，灰太狼群体的社会等级从高到低依次是、、、。GWO的优化过程主要由每代种群中的最佳三个解(即、和)来指导。

2.1 社会等级分层

　　灰狼群体通过以下公式逐渐接近并包围猎物：

　　其中T是当前迭代代数，A和C是系数向量，Xp和X分别是猎物和灰狼的位置向量。a和c通过以下公式计算：3360

　　其中a是收敛因子，随着迭代次数从2线性减少到0，r1和r 2服从[0，1]之间的均匀分布。

2.2 包围猎物

　　狼群中的其他灰狼个体根据、、白的位置Xa、XB、Xo更新位置：

　　公式中，Da、D和D6分别代表A、和5与其他个体的距离；Xa、X和X6分别代表A、和5的当前位置；C1、C2、C3是随机向量，X是灰狼的当前位置。

　　更新灰狼个体位置的公式如下：3360

2.3 狩猎

　　在建立攻击猎物模型的过程中，根据2)中的公式，a值的减小会引起a值的波动。换句话说，A是区间[-a，a]中的随机向量(注：这里是原作者第一篇论文中的[-2a，2a]，后面的论文中更正为[-a，a])，其中A在迭代过程中线性递减。当a在[-1，1]的区间内时，搜索代理的下一个时间位置可以是当前灰狼和猎物之间的任何位置。

2.4 攻击猎物

　　灰狼主要依靠，，的信息来寻找猎物。他们开始分散搜索猎物位置信息，然后集中攻击猎物。对于分散模型的建立，搜索方法 a >1让它的代理远离猎物，这使GWO能够进行全球搜索。

　　索。GWO 算法中的另一个搜索系数是Ｃ。从2.2中的公式可知，Ｃ向量是在区间范围［０，２］上的随机值构成的向量，此系数为猎物提供了随机权重，以便増加（｜Ｃ｜＞１）或减少（｜Ｃ｜＜１）。这有助于 GWO 在优化过程中展示出随机搜索行为，以避免算法陷入局部最优。值得注意的是，Ｃ并不是线性下降的，Ｃ在迭代过程中是随机值，该系数有利于算法跳出局部，特别是算法在迭代的后期显得尤为重要。

3 实现步骤及程序框图

3.1 步骤

　　Step1:种群初始化:包括种群数量N，最大迭代次数Maxlter，调控参数a,A，C.

　　Step2:根据变量的上下界来随机初始化灰狼个体的位置X。

　　Step3:计算每一头狼的适应度值，并将种群中适应度值最优的狼的位置信息保存X_α，将种群中适应度值次优的狼的位置信息保存为X_β，将种群中适应度第三优的灰狼的位置信息保存为X_γ。

　　Step4:更新灰狼个体X的位置。

　　step5:更新参数a，A和C。

　　Step6:计算每一头灰狼的适应度值，并更新三匹头狼的最优位置。

　　Step7:判断是否到达最大迭代次数Maxlter，若满足则算法停止并返回Xa的值作为最终得到的最优解，否则转到Step4。

3.2 程序框图

4 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
　　 #========初始化所有狼的位置===================
　　 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。
　　 #===========以上的循环里，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)

5 Matlab实现

% 主程序 GWO
　　clear
　　close all
　　clc
　　%%完整代码见微信公众号：电力系统与算法之美
　　%输入关键字：灰狼算法
　　SearchAgents_no = 30 ; %种群规模
　　dim = 10 ; % 粒子维度
　　Max_iter = 1000 ; %迭代次数
　　ub = 5 ;
　　lb = -5 ;
　　%% 初始化三匹头狼的位置
　　Alpha_pos=zeros(1,dim);
　　Alpha_score=inf; 
　　Beta_pos=zeros(1,dim);
　　Beta_score=inf; 
　　Delta_pos=zeros(1,dim);
　　Delta_score=inf; 
　　Convergence_curve = zeros(Max_iter,1);
　　%% 开始循环
　　for l=1:Max_iter
　　 for i=1:size(Positions,1) 
　　 %% 返回超出搜索空间边界的搜索代理
　　 Flag4ub=Positions(i,:)>ub;
　　 Flag4lb=Positions(i,:)<lb;
　　 Positions(i,:)=(Positions(i,:).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb; 
　　 %% 计算每个搜索代理的目标函数
　　 fitness=sum(Positions(i,:).^2);
　　 %% 更新 Alpha, Beta, and Delta
　　 if fitness<Alpha_score 
　　 Alpha_score=fitness; % Update alpha
　　 Alpha_pos=Positions(i,:);
　　 end
　　 if fitness>Alpha_score && fitness<Beta_score 
　　 Beta_score=fitness; % Update beta
　　 Beta_pos=Positions(i,:);
　　 end
　　 if fitness>Alpha_score && fitness>Beta_score && fitness<Delta_score 
　　 Delta_score=fitness; % Update delta
　　 Delta_pos=Positions(i,:);
　　 end
　　 end
　　 a=2-l*((2)/Max_iter); % a decreases linearly fron 2 to 0
　　 %% 更新搜索代理的位置，包括omegas
　　 for i=1:size(Positions,1)
　　 for j=1:size(Positions,2) 
　　 r1=rand(); % r1 is a random number in [0,1]
　　 r2=rand(); % r2 is a random number in [0,1]
　　 A1=2*a*r1-a; % Equation (3.3)
　　 C1=2*r2; % Equation (3.4)
　　 D_alpha=abs(C1*Alpha_pos(j)-Positions(i,j)); % Equation (3.5)-part 1
　　 X1=Alpha_pos(j)-A1*D_alpha; % Equation (3.6)-part 1
　　 r1=rand();
　　 r2=rand();
　　 A2=2*a*r1-a; % Equation (3.3)
　　 C2=2*r2; % Equation (3.4)
　　 D_beta=abs(C2*Beta_pos(j)-Positions(i,j)); % Equation (3.5)-part 2
　　 X2=Beta_pos(j)-A2*D_beta; % Equation (3.6)-part 2 
　　 r1=rand();
　　 r2=rand(); 
　　 A3=2*a*r1-a; % Equation (3.3)
　　 C3=2*r2; % Equation (3.4)
　　 D_delta=abs(C3*Delta_pos(j)-Positions(i,j)); % Equation (3.5)-part 3
　　 X3=Delta_pos(j)-A3*D_delta; % Equation (3.5)-part 3 
　　 Positions(i,j)=(X1+X2+X3)/3;% Equation (3.7)
　　 end
　　 end
　　 Convergence_curve(l)=Alpha_score;
　　 disp([Iteration = num2str(l) , Evaluations = num2str(Alpha_score)]);
　　end
　　%========可视化==============
　　figure(unit,normalize,Position,[0.3,0.35,0.4,0.35],color,[1 1 1],toolbar,none)
　　%% 目标空间
　　subplot(1,2,1);
　　x = -5:0.1:5;y=x;
　　L=length(x);
　　f=zeros(L,L);
　　for i=1:L
　　 for j=1:L
　　 f(i,j) = x(i)^2+y(j)^2;
　　 end
　　end
　　surfc(x,y,f,LineStyle,none);
　　xlabel(x_1);
　　ylabel(x_2);
　　zlabel(F)
　　title(Objective space)
　　%% 狼群算法 
　　subplot(1,2,2);
　　semilogy(Convergence_curve,Color,r,linewidth,1.5)
　　title(Convergence_curve)
　　xlabel(Iteration);
　　ylabel(Best score obtained so far);
　　axis tight
　　grid on
　　box on
　　legend(GWO)
　　display([The best solution obtained by GWO is : , num2str(Alpha_pos)]);
　　display([The best optimal value of the objective funciton found by GWO is : , num2str(Alpha_score)]);

　　以上就是Python&Matlab实现灰狼优化算法的示例代码的详细内容，更多关于Python Matlab灰狼优化算法的资料请关注盛行IT软件开发工作室其它相关文章！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。