FA萤火虫算法求解二元四峰函数的简单例子（python代码）

        这个代码是应付智能优化的课的， 代码有些地方有些重复啰嗦，请大家担待，可视化都是自己搞得，好多for循环打印，有些地方完全可以构造函数，大家有需要可以自己改一下

import random
import numpy as np
import matplotlib.pyplot as plt
import time
# 目标函数
def f(x, y):
    return np.exp(-(x-4)**2-(y-4)**2) + np.exp(-(x+4)**2-(y-4)**2) + 2*np.exp(-x**2-(y+4)**2) + 2*np.exp(-x**2-y**2)
    # return (3 * (1 - x) ** 2 * np.exp(-(x ** 2) - (y + 1) ** 2)
    #  - 10 * (x / 5 - x ** 3 - y ** 5) * np.exp(-x ** 2 - y ** 2)
    #  - 1 / 3 * np.exp(-(x + 1) ** 2 - y ** 2))

# 萤火虫算法
def firefly_algorithm(N, alpha, beta, gamma, lb_x, ub_x, lb_y, ub_y, max_iter):
    # N：萤火虫数量
    # alpha：步长的扰动因子
    # beta：吸引力
    # gamma：固定光吸收系数
    # lb_x：x搜索空间下限
    # ub_x：x搜索空间上限
    # lb_y：y搜索空间下限
    # ub_y：y搜索空间上限
    # max_iter：最大迭代次数

    # 初始化萤火虫位置和亮度
    best_y_history = []
    X = np.zeros((N, 2))
    X[:, 0] = np.random.uniform(lb_x, ub_x, size=N)#生成随机向量位置x
    X[:, 1] = np.random.uniform(lb_y, ub_y, size=N)#生成随机向量位置y
    I = np.zeros(N)  #初始化亮度数组
    for i in range(N):
        I[i] = f(X[i, 0], X[i, 1])
    for p1 in range(N):
        o1 = np.linspace(lb_x, ub_x, 100)
        o2 = np.linspace(lb_y, ub_y, 100)
        o1, o2 = np.meshgrid(o1, o2)
        z = f(o1, o2)
        plt.contour(o1, o2, z)
        plt.scatter(X[p1, 0], X[p1, 1], color='r', s=5)
    plt.show()
    # 迭代优化
    for t in range(max_iter):
        # 更新每只萤火虫位置和亮度
        for i in range(N):
            for j in range(N):
                if I[j] > I[i]:
                    r = np.sqrt(np.sum((X[i] - X[j]) ** 2))#计算萤火虫之间的距离r
                    X[i] =  X[i]+(beta * np.exp(-gamma * r ** 2))* (X[j] - X[i]) + alpha * np.random.randn(2)
                    X[i, 0] = np.clip(X[i, 0], lb_x, ub_x) #锁定X取值的上下界，越界就直接赋边界值
                    X[i, 1] = np.clip(X[i, 1], lb_y, ub_y) #锁定Y取值的上下界，越界就直接赋边界值
                    I[i] = f(X[i, 0], X[i, 1]) #计算光强度
                    #print(X[i, 0], X[i, 1])
        best_y_history.append(I[  np.argmax(I)]) # 将当前迭代的最优值保存到列表中
        print("第", t+1, "次迭代")
        #显示每次迭代的过程
        plt.cla()
        for p1 in range(N):
            print("x坐标：",X[p1,0],"y坐标：",X[p1,1],"光强度：",f(X[p1,0],X[p1,1]))
            o1 = np.linspace(lb_x, ub_x, 100)

            o2 = np.linspace(lb_y, ub_y, 100)
            o1, o2 = np.meshgrid(o1, o2)
            z = f(o1, o2)
            plt.contour(o1, o2, z)  # 制作等高线图
            plt.scatter(X[p1,0], X[p1,1], color='r', s=20) # 将所有的点映射到等高线图中，一共有N个点
        # 重绘图形
        plt.draw()
        plt.pause(0.005)  # 暂停1秒

     # 生成最后保存的位置
    for p1 in range(N):
        o1 = np.linspace(lb_x, ub_x, 100)
        o2 = np.linspace(lb_y, ub_y, 100)
        o1, o2 = np.meshgrid(o1, o2)
        z = f(o1, o2)
        plt.contour(o1, o2, z)
        plt.scatter(X[p1, 0], X[p1, 1], color='r', s=5)
    plt.show()
    # 返回最优解和最优值找到最小值用np.argmin（），最大值用np.argmax（）
    best_idx = np.argmax(I)
    best_x = X[best_idx]#保存最优位置
    best_y = I[best_idx]#保存最优解
    worst_idx = np.argmin(I)#保存最差解
    worst_y = I[worst_idx]
    return best_x, best_y,best_y_history,worst_y,I

# 调用萤火虫算法求解f(x,y)的最大值
N = 60  # 萤火虫数量
alpha = 0.5 # 步长系数
beta = 0.97 # 初始吸引度
gamma = 0.8 # 光吸收系数
lb_x = -6.0
ub_x = 6.0
lb_y = -6.0
ub_y = 6.0
max_iter = 100# 最大迭代次数
start_time = time.time()
# 运行算法
best_x, best_y,best_y_history,worst_y,Last_I = firefly_algorithm(N, alpha, beta, gamma, lb_x, ub_x, lb_y, ub_y, max_iter)
print('最优解坐标：', best_x)
print("最优解：%.9f"%best_y)
print("最差解：%.9f"%worst_y )
print("平均解：%.9f"%np.mean(Last_I))
end_time = time.time()
# 计算算法运行时间
elapsed_time = end_time - start_time
print('算法运行时间：', elapsed_time)

# 可视化迭代次数和适应度值
plt.plot(best_y_history)
plt.title('Best Fitness per Iteration')
plt.xlabel('Iteration')
plt.ylabel('Fitness')
plt.show()

# 可视化结果
x = np.linspace(lb_x, ub_x, 100)
y = np.linspace(lb_y, ub_y, 100)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)

# 可视化函数和最优适应值的点
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.8)
ax.scatter(best_x[0], best_x[1], best_y, color='red', marker='o', s=100)
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('f(x,y)')
plt.show()

输出：