灰狼优化算法 python

灰狼优化算法（Grey Wolf Optimization，GWO）是一种启发式优化算法，灵感来源于灰狼在狩猎过程中的行为。它是一种群体智能算法，通过模拟灰狼的社会行为来进行问题求解。

下面是一个使用Python实现灰狼优化算法的示例代码：

import numpy as np

def objective_function(x):
    # 定义目标函数，这里以一个简单的函数 f(x) = x^2 为例
    return x**2

def grey_wolf_optimizer(obj_func, lb, ub, dim, max_iter, search_agent_count):
    # 初始化灰狼群体的位置
    positions = np.zeros((search_agent_count, dim))
    for i in range(dim):
        positions[:, i] = np.random.uniform(lb[i], ub[i], search_agent_count)
    
    # 迭代优化过程
    for t in range(1, max_iter+1):
        a = 2 - t * (2 / max_iter)  # 计算当前时间步的参数a
        
        # 更新每个灰狼的位置
        for i in range(search_agent_count):
            for j in range(dim):
                r1 = np.random.random()  # 产生[0,1)之间的随机数
                r2 = np.random.random()
                
                A1 = 2 * a * r1 - a  # 计算参数A1
                C1 = 2 * r2  # 计算参数C1
                
                D_alpha = abs(C1 * positions[i, j] - positions[0, j])  # 计算当前位置与alpha狼位置的距离
                X1 = positions[0, j] - A1 * D_alpha  # 更新位置
                
                r1 = np.random.random()
                r2 = np.random.random()
                
                A2 = 2 * a * r1 - a
                C2 = 2 * r2
                
                D_beta = abs(C2 * positions[i, j] - positions[1, j])
                X2 = positions[1, j] - A2 * D_beta
                
                r1 = np.random.random()
                r2 = np.random.random()
                
                A3 = 2 * a * r1 - a
                C3 = 2 * r2
                
                D_delta = abs(C3 * positions[i, j] - positions[2, j])
                X3 = positions[2, j] - A3 * D_delta
                
                positions[i, j] = (X1 + X2 + X3) / 3  # 更新位置
        
        # 边界处理
        positions = np.clip(positions, lb, ub)
        
        # 更新最优解
        fitness = np.array([obj_func(x) for x in positions])
        best_agent_index = np.argmin(fitness)
        best_agent_fitness = fitness[best_agent_index]
        best_agent_position = positions[best_agent_index]
        
        # 输出当前迭代的结果
        print(f"Iteration {t}/{max_iter}: Best fitness = {best_agent_fitness}, Best position = {best_agent_position}")
    
    return best_agent_fitness, best_agent_position

# 设置问题的维度、界限和参数
dim = 1
lb = [-5]
ub = [5]
max_iter = 100
search_agent_count = 10

# 调用灰狼优化算法进行优化
best_fitness, best_position = grey_wolf_optimizer(objective_function, lb, ub, dim, max_iter, search_agent_count)

print("Optimization finished!")
print(f"Best fitness = {best_fitness}, Best position = {best_position}")

可以根据实际问题，自定义目标函数`objective_function`，设置问题的维度`dim`、界限`lb`和`ub`，以及迭代次数`max_iter`和灰狼数量`search_agent_count`。在每次迭代中，根据当前位置和参数，更新灰狼的位置，并通过比较适应度值来更新最优解。最后输出优化结果。

希望对你有帮助！如果有任何问题，请随时提问。