布谷鸟搜索算法学习（里面对比了GA ACO PSO ABC CS的优缺点）

最新推荐文章于 2023-07-19 15:41:12 发布

诗筱涵

最新推荐文章于 2023-07-19 15:41:12 发布

阅读量5.2k

点赞数 3

分类专栏：最优化理论

原文链接：https://blog.csdn.net/laexl123/article/details/106707888/?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-5&spm=1001.2101.3001.4242

版权

最优化理论专栏收录该内容

17 篇文章 2 订阅

订阅专栏

我发现这些算法都是求解最优化问题的。

翁weiwei当初也说过智能优化算法

似乎深度学习里面训练的过程就用到了智能优化算法？加快收敛速度？

路径规划本质也是一个最优化问题，所以用智能优化算法？

最优控制理论里面有没有用到最优控制算法呢？

https://zhidao.baidu.com/question/431812315.html

转载自：https://blog.csdn.net/laexl123/article/details/106707888/?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-5&spm=1001.2101.3001.4242

布谷鸟搜索算法学习

置顶张伯亮 2020-06-12 08:37:27 1291 收藏 9

分类专栏：优化算法文章标签：算法

版权

0、引言
布谷鸟搜索算法（Cuckoo Search, CS）是2009年Xin-She Yang 与Suash Deb在《Cuckoo Search via Levy Flights》一文中提出的一种优化算法。布谷鸟算法是一种集合了布谷鸟巢寄生性和莱维飞行（Levy Flights）模式的群体智能搜索技术，通过随机游走的方式搜索得到一个最优的鸟巢来孵化自己的鸟蛋。这种方式可以达到一种高效的寻优模式。
基于对布谷鸟此习性的观察和模仿，提出了布谷鸟搜索算法。本文对布谷鸟搜索算法进行介绍；分析布谷鸟搜索算法的优缺点并与粒子群算法、蜂群算法、蚁群算法进行对比；最后在python语言环境下利用布谷鸟搜索算法解决二元二次方程最大值的求解。

1.布谷鸟搜索算法基本原理
1.1布谷鸟的巢寄生性
布谷鸟最特殊的习性是寄巢产卵。由于其本身没有孵化行为，大自然中有一些布谷鸟会将自己的卵产在寄生鸟巢中，依靠养父母孵化和育雏。为了不被寄主察觉，大布谷鸟在产卵前，会把寄主一枚或数枚卵移走，使得巢穴中卵的数量相等或相近。而当寄主发现鸟巢中陌生的卵。这是，寄主鸟类会丢弃布谷鸟所产的卵，或直接重新筑巢。
在布谷鸟搜索算法中有三个基本假设：
1.每只布谷鸟一次只产一枚卵，并且随机选择一个鸟巢存放；
2.在寻窝的过程中，卵最好的鸟巢将会被保留到下一代；
3.可用鸟巢的数量是固定的，并且设鸟巢中外来卵被发现的概率是P，P∈[0,1]。如果发现外来鸟蛋，则鸟窝主人重新建立一个鸟窝。
基于以上三个假设，可以认为，鸟窝和卵用来指代待求解问题的解，卵是否能够被宿主鸟孵化并茁壮成长，是衡量解好坏的唯一标准。布谷鸟寻找鸟窝下蛋的过程就是在n维空间内寻找解的过程，鸟窝的好坏象征着解的好坏。

1.2莱维飞行
在自然界中，动物会以随机或准随机的方式寻找食物。一般来说，是根据当前的位置或状态和到下一个位置的转移概率而做出下一次移动，因此动物的觅食过程实际上是随机行走，其选取的方向可以用数学建模方法来表示。例如，大量实验表明，动物界中许多如信天翁、蜜蜂等动物的寻觅食物轨迹符合莱维飞行的典型特征。
莱维飞行是一类非高斯随机过程，其平稳增量服从莱维稳定分布。在飞行过程中，步长较小的短距离行走与偶尔较大步长的长距离行走相互交替，有利于增加种群多样性、扩大搜索范围，不至于陷入局部最优。
图1.模拟莱维飞行轨迹示意图

1.3 布谷鸟搜索算法的实现过程
根据布谷鸟的孵化鸟蛋的过程，布谷鸟搜索算法描述如下：
步骤1 定义目标函数，对搜索函数初始化，并随机生成n个鸟窝的初始位置，设置种群规模、问题维数、最大发现概率P和最大迭代次数等参数；
步骤2 选择适应度函数（目标函数）并计算每个鸟窝位置的目标函数值，得到当前的最优函数值；
步骤3 记录上一次最优函数值，利用莱维飞行对其他鸟窝的位置和状态进行更新；
步骤4 现有位置函数值与上一代最优函数值进行比较，若较好，则改变当前最优值；
步骤5 通过位置更新后，用随机数r∈[0,1]与最大发现概率P进行比较，若r<P，则对该巢的位置进行随机改变，反之则不变，最后保留最好的一组鸟窝位置；
步骤6 若未达到最大迭代次数或最小误差要求，则返回步骤2，否则，继续下一步；
步骤7 输出全局最优位置。

2.算法优缺点分析及对比：
CS算法与遗传算法（GA）、蚁群算法（ACO）、粒子群算法（PSO）、蜂群算法（ABC）等均属于群只能优化算法，它们皆为基于种群，借助迭代来实现优化步骤的概率搜索算法。总结与对比了这5种算法的优点、缺点以及适合求解的问题，结果如表1所示：
表1 CS于GA、ACO、PSO、ABC算法的比较在这里插入图片描述

虽然GA、ACO、PSO和ABC的研究及应用比较成熟，但从表1可知，CS算法在参数数目、全局寻优能力等方面综合优势更大，算法可灵活地跟其他算法进行多种组合，并具有更广泛的适用性。CS算法作为后起之秀，它的优越性使其广泛应用于各个研究领域。
3.实验仿真：
本实验采用python编程语言，基于tensorflow框架进行。Python版本为3.7.6，anaconda版本为4.8.3，tensorflow版本为2.1.0，scipy版本为1.4.1，numpy版本为1.18.3。本实验要解决的问题为，在x∈[-3,3]，y∈[-3,3]的情况下，寻找能使-(x-1)2-(y+2)2取到最大值的x值和y值。
假设同时可以存在25个布谷鸟寄生鸟巢，布谷鸟蛋被寄主鸟发现的概率为0.25，迭代次数为100次，可以得到实验结果如图2所示：
在这里插入图片描述
图2. 实验结果图
通过观察实验结果，发现该程序可以较好的完成令目标函数取最大值的参数寻优，所得到的结果较为精确。
实验的全部代码见附录。
4.结论
①布谷鸟搜索算法具有很好的全局搜索能力，能够很好的解决实验中遇到的连续型优化问题，但是在离散优化问题上，难以解决，需要进一步优化该算法，才能够解决离散优化问题。
②针对文中所设置的实验，布谷鸟算法能够很好的解决该优化问题，适合进一步优化和开发。
5.心得体会与收获
布谷鸟搜索算法是一种新型元启发式搜索算法，具有十分广阔的研究前景。与其他群智能算法相比，其优越性已被众多学者认可，不仅表现出鲁棒性强、通用性好等优点，还具有可移植性，平台无关性等强大的活力。为我后续的课程学习和课题研究打下了坚实的基础。
6.附录

import numpy as np
import scipy.special as sc_special

def levy_flight(n, m, beta):
    sigma_u = (sc_special.gamma(1+beta) * np.sin(np.pi*beta/2) / (sc_special.gamma ((1+beta)/2) * beta * (2**((beta-1)/2))))**(1/beta)
    sigma_v = 1
    u =  np.random.normal(0, sigma_u, (n, m))
    v = np.random.normal(0, sigma_v, (n, m))
    steps = u/((np.abs(v))**(1/beta))
return steps

def fit_func(nest):
        x, y = nest        
        #一个*表示乘号，连续两个*表示次方
        #return 3*(1-x)**2*np.e**(-x**2-(y+1)**2) - 10*(x/5-x**3-y**5)*np.e**(-x**2-y**2) - (np.e**(-(x+1)**2-y**2))/3
        return -(x-1)**2-(y+2)**2

def calc_fitness(fit_func, nests): 
    n, m = nests.shape
    fitness = np.empty(n)
    for each_nest in range(n):
        fitness[each_nest] = fit_func(nests[each_nest])
return fitness

def abandon_nests(nests, lower_boundary, upper_boundary, pa):
    lower_boundary = np.array(lower_boundary)
    upper_boundary = np.array(upper_boundary)
    n, m = nests.shape
    for each_nest in range(n):
        if (np.random.rand() < pa):
            step_size = np.random.rand() * (nests[np.random.randint(0, n)] - nests[np.random.randint(0, n)])
            nests[each_nest] += step_size
            # apply boundary condtions 应用边界条件
            nests[each_nest][nests[each_nest] < lower_boundary] = lower_boundary[nests[each_nest] < lower_boundary]
            nests[each_nest][nests[each_nest] > upper_boundary] = upper_boundary[nests[each_nest] > upper_boundary]
return nests

def update_nests(fit_func, lower_boundary, upper_boundary, nests, best_nest, fitness, step_coefficient):
    lower_boundary = np.array(lower_boundary)
    upper_boundary = np.array(upper_boundary)
    n, m = nests.shape
    steps = levy_flight(n, m, 1.5)
    new_nests = nests.copy()
    for each_nest in range(n):
        step_size = step_coefficient * steps[each_nest] * (nests[each_nest] - best_nest)
        step_direction = np.random.rand(m)
        new_nests[each_nest] += step_size * step_direction
        new_nests[each_nest][new_nests[each_nest] < lower_boundary] = lower_boundary[new_nests[each_nest] < lower_boundary]
        new_nests[each_nest][new_nests[each_nest] > upper_boundary] = upper_boundary[new_nests[each_nest] > upper_boundary]
    new_fitness = calc_fitness(fit_func, new_nests)
    nests[new_fitness > fitness] = new_nests[new_fitness > fitness]
return nests

def generate_nests(n, m, lower_boundary, upper_boundary):
    lower_boundary = np.array(lower_boundary)
    upper_boundary = np.array(upper_boundary)
    nests = np.empty((n, m))
    for each_nest in range(n):
        nests[each_nest] = lower_boundary + np.array([np.random.rand() for _ in range(m)]) * (upper_boundary - lower_boundary)
return nests

def cuckoo_search(n, m, fit_func, lower_boundary, upper_boundary, iter_num = 100,pa = 0.25, beta = 1.5, step_size = 0.1):
nests = generate_nests(n, m, lower_boundary, upper_boundary)
    fitness = calc_fitness(fit_func, nests)
    best_nest_index = np.argmax(fitness)
    best_fitness = fitness[best_nest_index]
    best_nest = nests[best_nest_index].copy()
    for i in range(iter_num):
        nests = update_nests(fit_func, lower_boundary, upper_boundary, nests, best_nest, fitness, step_size)
        nests = abandon_nests(nests, lower_boundary, upper_boundary, pa)
        fitness = calc_fitness(fit_func, nests)
        max_nest_index = np.argmax(fitness)
        max_fitness = fitness[max_nest_index]
        max_nest = nests[max_nest_index] 
        if (max_fitness > best_fitness):
            best_nest = max_nest.copy()
            best_fitness = max_fitness
return (best_nest, best_fitness)

if __name__=='__main__':
    best_nest, best_fitness = cuckoo_search(25, 2, fit_func, [-3, -3], [3, 3], step_size = 0.4)
    print('最大值为:%.5f, 在(%.5f, %.5f)处取到!'%(best_fitness, best_nest[0], best_nest[1]))