python实现萤火虫算法并且可视化萤火虫移动过程

好的，以下是 python 实现萤火虫算法并可视化萤火虫移动过程的代码：

import random
import math
import matplotlib.pyplot as plt
import numpy as np

# 设置萤火虫算法的参数
num_fireflies = 20  # 萤火虫数量
num_iter = 10  # 迭代次数
alpha = 0.2  # 吸引因子
beta = 1  # 感应因子
gamma = 1  # 收缩因子
delta = 0.97  # 衰减因子
xmin, xmax, ymin, ymax = -5, 5, -5, 5  # 随机生成萤火虫的范围


def init_fireflies(num_fireflies):
    """
    随机初始化萤火虫的位置和亮度（即适应度值）
    """
    fireflies = []
    for i in range(num_fireflies):
        x = xmin + (xmax - xmin) * random.random()
        y = ymin + (ymax - ymin) * random.random()
        intensity = -1  # 初始亮度为-1
        fireflies.append([x, y, intensity])
    return fireflies


def distance(f1, f2):
    """
    计算两个萤火虫之间的距离
    """
    return math.sqrt((f1[0] - f2[0]) ** 2 + (f1[1] - f2[1]) ** 2)


def brightness(f):
    """
    计算萤火虫的亮度（即适应度值）
    """
    return math.exp(-distance(f, [0, 0]) ** 2)


def move(f, brightest):
    """
    根据萤火虫的亮度和距离，更新萤火虫的位置
    """
    r = distance(f, brightest)
    theta = random.uniform(-math.pi, math.pi)
    x = f[0] + beta * math.exp(-gamma * r ** 2) * math.cos(theta) + alpha * (random.random() - 0.5)
    y = f[1] + beta * math.exp(-gamma * r ** 2) * math.sin(theta) + alpha * (random.random() - 0.5)
    x = max(xmin, min(x, xmax))
    y = max(ymin, min(y, ymax))
    intensity = brightness([x, y])
    return [x, y, intensity]


def find_brightest(fireflies):
    """
    找到亮度最大的萤火虫
    """
    brightest = None
    for f in fireflies:
        if brightest is None or f[2] > brightest[2]:
            brightest = f
    return brightest


def main():
    # 初始化萤火虫
    fireflies = init_fireflies(num_fireflies)

    # 记录每次迭代的最优解
    best_scores = []

    # 迭代
    for i in range(num_iter):
        # 找到亮度最大的萤火虫
        brightest = find_brightest(fireflies)

        # 更新萤火虫的位置
        for j in range(num_fireflies):
            fireflies[j] = move(fireflies[j], brightest)

        # 衰减吸引因子
        alpha *= delta

        # 记录最优解
        best_scores.append(brightest[2])

        # 可视化萤火虫移动过程
        plt.clf()
        for f in fireflies:
            plt.scatter(f[0], f[1], c='r')
        plt.scatter(brightest[0], brightest[1], c='b')
        plt.title('Iteration %d' % (i + 1))
        plt.xlim(xmin, xmax)
        plt.ylim(ymin, ymax)
        plt.pause(0.1)

    # 打印最优解
    print('Best solution: (%f, %f)' % (brightest[0], brightest[1]))

    # 绘制最优解的亮度曲线
    plt.clf()
    plt.plot(best_scores)
    plt.title('Brightness of the brightest firefly')
    plt.xlabel('Iteration')
    plt.ylabel('Brightness')
    plt.show()


if __name__ == '__main__':
    main()

运行代码后，会弹出一个窗口，不停地显示萤火虫的移动过程。在每次迭代结束后，会打印当前最优解的位置，以及最优解的亮度曲线。可以根据需要修改萤火虫算法的参数和随机生成萤火虫的范围。