烟花算法 python

烟花算法是一种基于自然界烟花爆炸的行为模拟的优化算法，主要用于解决函数优化问题。下面是一个简单的 Python 实现：

import random
import math

def fitness_func(x):
    # 定义适应度函数
    return math.sin(10 * math.pi * x) / (2 * x) + (x - 1) ** 4

def init_fireworks(n, dim, ub, lb):
    # 初始化火花，n 表示火花数量，dim 表示每个火花的维度，ub 和 lb 分别表示每个维度的上下界
    fireworks = []
    for i in range(n):
        firework = []
        for j in range(dim):
            firework.append(random.uniform(lb, ub))
        fireworks.append(firework)
    return fireworks

def explode(firework, a, b, A, m):
    # 爆炸操作，a 和 b 分别为两个常数，A 为火花的亮度，m 为火花的维度
    spark = []
    for i in range(m):
        s = firework[i] + A * (b - a)
        if s > ub:
            s = ub
        elif s < lb:
            s = lb
        spark.append(s)
    return spark

def run(n, dim, ub, lb, max_iter):
    # 烟花算法主程序，n 表示火花数量，dim 表示每个火花的维度，ub 和 lb 分别表示每个维度的上下界，max_iter 表示最大迭代次数
    fireworks = init_fireworks(n, dim, ub, lb)
    best_fitness = float('inf')
    for i in range(max_iter):
        for j in range(n):
            A = fitness_func(fireworks[j])
            for k in range(5):
                a = random.randint(0, n - 1)
                while a == j:
                    a = random.randint(0, n - 1)
                B = fitness_func(fireworks[a])
                if B > A:
                    A = B
            spark = explode(fireworks[j], random.uniform(0, 1), random.uniform(0, 1), A, dim)
            new_fitness = fitness_func(spark)
            if new_fitness > A:
                fireworks[j] = spark
            if new_fitness < best_fitness:
                best_fitness = new_fitness
                best_solution = spark
        print("Iteration {}: Best Fitness = {}".format(i, best_fitness))
    return best_solution, best_fitness

其中 `fitness_func` 函数是需要优化的目标函数，`init_fireworks` 函数用于初始化火花，`explode` 函数是烟花爆炸操作，`run` 函数是烟花算法的主程序。在 `run` 函数中，首先初始化火花，然后循环进行迭代，对每个火花进行爆炸操作，计算新的适应度值，更新火花的位置，最后输出迭代次数和最优解的适应度值。