灰狼算法 python类

灰狼优化算法（Grey Wolf Optimizer，简称GWO）是一种模拟自然生态中狼群狩猎行为的优化算法。在Python中实现灰狼算法，通常会创建一个类来封装算法的核心逻辑，包括初始化狼的位置、计算食物源距离、更新狼的位置以及寻找最佳解等步骤。

以下是简单的灰狼优化算法类的一个概述：

class GWO:
    def __init__(self, n_wolves, n_iterations, search_space):
        self.n_wolves = n_wolves  # 狼的数量
        self.n_iterations = n_iterations  # 迭代次数
        self.search_space = search_space  # 搜索空间范围
        self.wolves = self.initialize_wolves()  # 初始化狼的位置

    def initialize_wolves(self):
        # 初始化狼位置，随机生成在搜索空间范围内
        return [self.random_position() for _ in range(self.n_wolves)]

    def alpha_beta_delta(self, best_global, wolves):
        # 计算阿尔法（Alpha）、贝塔（Beta）和德尔塔（Delta）狼的位置
        alpha = max(wolves, key=lambda x: x.value)
        beta = sorted(wolves, key=lambda x: x.value, reverse=True)[1]
        delta = sorted(wolves, key=lambda x: x.value, reverse=True)[2:]
        return alpha, beta, delta

    def update_positions(self, alpha, beta, delta):
        # 更新狼的位置，参考狼群领袖的位置
        new_positions = []
        for wolf in wolves:
            a = 2 - self.current_iteration / self.n_iterations
            A1, A2 = 2 * a * random.random(), 2 * a * (random.random() < 0.5) - a
            X_alpha, Y_alpha = alpha.position, alpha.value
            X_beta, Y_beta = beta.position, beta.value
            D_alpha = abs(X_alpha - wolf.position)
            D_beta = abs(X_beta - wolf.position)

            r1 = random.random()
            r2 = random.random()

            X_new = X_alpha - A1 * D_alpha + A2 * (Y_alpha - Y_beta) * D_alpha if r1 < D_alpha else X_alpha
            Y_new = Y_alpha - A1 * D_alpha + A2 * (Y_alpha - Y_beta) * D_alpha if r1 < D_alpha else Y_alpha

            # 同理计算beta和delta的影响
            # ...

            new_positions.append((X_new, Y_new))
        return new_positions

    def iterate(self):
        for _ in range(self.n_iterations):
            self.current_iteration += 1
            self.update_positions(*self.alpha_beta_delta(self.best_global, self.wolves))
            self.update_best_wolf(self.wolves)

    def update_best_wolf(self, wolves):
        # 更新当前找到的最佳解
        self.best_global = max(wolves, key=lambda x: x.value)

# 使用示例
gwo = GWO(n_wolves=10, n_iterations=100, search_space=(-10, 10))
gwo.iterate()