Python和Matlab实现蝙蝠算法的示例代码

#=========导入相关库===============
import numpy as np
from numpy.random import random as rand
 
#========参数设置==============
# objfun:目标函数 
# N_pop: 种群规模，通常为10到40
# N_gen: 迭代数
# A: 响度（恒定或降低） 
# r: 脉冲率（恒定或减小） 
# 此频率范围决定范围
# 如有必要，应更改这些值 
# Qmin: 频率最小值
# Qmax: 频率最大值
# d: 维度
# lower: 下界
# upper: 上界
 
def bat_algorithm(objfun, N_pop=20, N_gen=1000, A=0.5, r=0.5,
    Qmin=0, Qmax=2, d=10, lower=-2, upper=2):
 
    N_iter = 0 # Total number of function evaluations
 
    #=====速度上下限================
    Lower_bound = lower * np.ones((1,d))
    Upper_bound = upper * np.ones((1,d))
 
    Q = np.zeros((N_pop, 1)) # 频率
    v = np.zeros((N_pop, d)) # 速度
    S = np.zeros((N_pop, d))
 
    #=====初始化种群、初始解=======
    # Sol = np.random.uniform(Lower_bound, Upper_bound, (N_pop, d))
    # Fitness = objfun(Sol)
    Sol = np.zeros((N_pop, d))
    Fitness = np.zeros((N_pop, 1))
    for i in range(N_pop):
        Sol[i] = np.random.uniform(Lower_bound, Upper_bound, (1, d))
        Fitness[i] = objfun(Sol[i])
 
    #====找出初始最优解===========
    fmin = min(Fitness)
    Index = list(Fitness).index(fmin)
    best = Sol[Index]
 
    #======开始迭代=======
    for t in range(N_gen):
 
        #====对所有蝙蝠/解决方案进行循环 ======
        for i in range(N_pop):
            # Q[i] = Qmin + (Qmin - Qmax) * np.random.rand
            Q[i] = np.random.uniform(Qmin, Qmax)
            v[i] = v[i] + (Sol[i] - best) * Q[i]
            S[i] = Sol[i] + v[i]
 
            #===应用简单的界限/限制====
            Sol[i] = simplebounds(Sol[i], Lower_bound, Upper_bound)
            # Pulse rate
            if rand() > r:
                # The factor 0.001 limits the step sizes of random walks
                S[i] = best + 0.001*np.random.randn(1, d)
 
            #====评估新的解决方案 ===========
            # print(i)
            Fnew = objfun(S[i])
            #====如果解决方案有所改进，或者声音不太大，请更新====
            if (Fnew <= Fitness[i]) and (rand() < A):
                Sol[i] = S[i]
                Fitness[i] = Fnew
 
            #====更新当前的最佳解决方案======
            if Fnew <= fmin:
                best = S[i]
                fmin = Fnew
 
        N_iter = N_iter + N_pop
 
    print('Number of evaluations: ', N_iter)
    print("Best = ", best, '\n fmin = ', fmin)
 
    return best
 
 
def simplebounds(s, Lower_bound, Upper_bound):
 
    Index = s > Lower_bound
    s = Index * s + ~Index * Lower_bound
    Index = s < Upper_bound
    s = Index * s + ~Index * Upper_bound
 
    return s
 
 
#====目标函数=============
def test_function(u):
    a = u ** 2
    return a.sum(axis=0)
 
 
if __name__ == '__main__':
    # print(bat_algorithm(test_function))
    bat_algorithm(test_function)

clear
wmax=0.9;%惯性权重最大值
wmin=0.4;%惯性权重最小值
n=10000; % 群体大小
A=rand(1,n); % 声音响度 (不变或者减小)
%% 频率范围
Qmin=0; % 最低频率
Qmax=1; % 最高频率
d=2;% 搜索变量的维数（即频率和速度）
%% 初始矩阵
Q=zeros(n,1); % 频率矩阵初始化
v=zeros(n,d); % 速度矩阵初始化，初始化意义就是产生一个初始矩阵
%% x自变量范围
u=-3;
o=12.1;
% y自变量范围
p=4.1;
l=5.8;
%% 初始化群体/解
for i=1:n
    Sol(i,1)=-3+(12.1+3)*rand(1,1);%x自变量范围【-3，12.1】
    Sol(i,2)=4.1+(5.8-4.1)*rand(1,1);%y自变量【4.1，5.8范围】
    %将随机生成的两个自变量带入函数式
    Fitness(i)=Fun(Sol(i,:));%函数值
end
%% 寻找当前最优解
[fmax,I]=max(Fitness);
best=Sol(I,:);
T=100;%飞行次数
%% 开始飞行
for t=1:T
    for i=1:n,
        Q(i)=Qmin+(Qmin-Qmax)*rand;%rand均匀分布的随机数
        %v(i,:)=v(i,:)+(Sol(i,:)-best)*Q(i);（原速度）
        w=(wmax-wmin)*exp(-2*(t/T)^2)+wmin;%惯性权重因子
        v(i,:)=w*v(i,:)+(Sol(i,:)-best)*A(i)*Q(i);%更改后的速度
        S(i,:)=Sol(i,:)+v(i,:);%位置移动
       %% 边界问题，如果下次飞行超出自变量范围外了，那么下次飞行的位置为投影在的边界上的位置
        %x轴
        if S(i,1)>o
            S(i,1)=o;
        end
        if S(i,1)<u
            S(i,1)=u;
        end
        %y轴
        if S(i,2)>l
            S(i,2)=l;
        end
        if S(i,2)<p
            S(i,2)=p;
        end
        %% 评估该次飞行后产生的新解
        Fnew(i)=Fun(S(i,:));
    end
    [Fmax,Z]=max(Fnew);%找出该次飞行后产生的最大值
    C(t,:)=S(Z,:);
    FFnew(t)=Fmax;
end
[Ffmax,N]=max(FFnew);%找出整个飞行过程中的最大值
M=C(N,:)
Ffmax

%目标函数
function z=Fun(u)
   z=21.5+u(1)*sin(4*pi*u(1))+u(2)*sin(20*pi*u(2));