算法优化笔记|蝙蝠算法的理解及实现

最新推荐文章于 2025-02-08 14:13:27 发布

鱼公主

最新推荐文章于 2025-02-08 14:13:27 发布

阅读量1.4w

点赞数 26

分类专栏：算法学习与理解文章标签：算法蝙蝠算法 BA matlab python

本文链接：https://blog.youkuaiyun.com/welcome_yu/article/details/112131446

版权

算法学习与理解专栏收录该内容

10 篇文章

订阅专栏

蝙蝠算法（Bat Algorithm,BA ）理解及实现

一、蝙蝠算法背景介绍
二、蝙蝠算法原理
三、蝙蝠模型构建
四、蝙蝠算法的Python实现
五、总结

一、蝙蝠算法背景介绍

蝙蝠算法是2010年杨教授基于群体智能提出的启发式搜索算法，是一种搜索全局最优解的有效方法。
该算法基于迭代优化，初始化为一组随机解，然后迭代搜寻最优解，且在最优解周围通过随机飞行产生局部新解，加强局部搜索速度。
该算法具有实现简单、参数少等特点。

二、蝙蝠算法原理

将种群中的蝙蝠个体映射为D维问题空间中的NP个可行解,将优化过程和搜索模拟成种群蝙蝠个体移动过程和搜寻猎物，利用求解问题的适应度函数值来衡量蝙蝠所处位置的优劣，将个体的优胜劣汰过程类比为优化和搜索过程中用好的可行解替代较差可行解的迭代过程。
在蝙蝠的随机搜索过程中，为了更方便的模拟蝙蝠探测猎物、避免障碍物，需假设如下三个近似的或理想化的规则：
（1）所有蝙蝠都采用回声定位感知距离；
（2）蝙蝠在位置xi以速度vi随机飞行，具有固定的频率fmin,同时根据自身与猎物的距离，自动调整波长和脉冲响度；
（3）假设脉冲响度的变化方式为从一个最大值A0 整数变化到固定最小值Amin,变化区间根据问题调整。

三、蝙蝠模型构建

算法描述：
每个虚拟蝙蝠以随机的速度Vi在位置Xi（问题的解）飞行，同时蝙蝠具有不同的波长、响度Ai和脉冲发射率r。蝙蝠狩猎和发现猎物时，它改变频率、响度和脉冲发射率，进行最佳解的选择，直到目标停止或条件得到满足。这本质上就是使用调谐技术来控制蝙蝠群的动态行为，平衡调整算法相关的参数，以取得蝙蝠算法的最优。通过对多个标准测试函数的测试，展现了在连续性优化问题中的较好应用。
模型构建
在这里插入图片描述
算法流程

四、蝙蝠算法的Python实现

#!/usr/bin/env python3
 
"""An implementation of Bat Algorithm
"""
 
import numpy as np
from numpy.random import random as rand
 
# Parameters setting
# objfun: objective function
# N_pop: population size, typically 10 to 40
# N_gen: number of generation
# A: loudness (constant or decreasing)
# r: pulse rate (constant or decreasing)
# This frequency range determines the scalings
# You should change these values if necessary
# Qmin: frequency minmum
# Qmax: frequency maxmum
# d: number of dimensions
# lower: lower bound
# upper: upper bound
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
    # Limit bounds
    Lower_bound = lower * np.ones((1,d))
    Upper_bound = upper * np.ones((1,d))
 
    Q = np.zeros((N_pop, 1)) # Frequency
    v = np.zeros((N_pop, d)) # Velocities
    S = np.zeros((N_pop, d))
 
    # Initialize the population/soutions
    # 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])
 
    # Find the initial best solution
    fmin = min(Fitness)
    Index = list(Fitness).index(fmin)
    best = Sol[Index]
 
    # Start the iterations
    for t in range(N_gen):
 
        # Loop over all bats/solutions
        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]
            # Apply simple bounds/limits
            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)
 
            # Evaluate new solutions
            # print(i)
            Fnew = objfun(S[i])
            # Update if the solution improves, or not too loud
            if (Fnew <= Fitness[i]) and (rand() < A):
                Sol[i] = S[i]
                Fitness[i] = Fnew
 
            # update the current best solution
            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
 
 
# u: array-like
def test_function(u):
    a = u ** 2
    return a.sum(axis=0)
 
 
if __name__ == '__main__':
    # print(bat_algorithm(test_function))
    bat_algorithm(test_function)