手推粒子群算法，并求最大值（单目标函数和多目标函数）

单目标函数

import random


# 定义适应度函数
def fitness_function(position):
    x = position[0]
    return -(x ** 2 - 4 * x + 4)  # 求反 PSO 以求最大值


class Particle:
    def __init__(self, position):
        self.position = position
        self.velocity = [random.uniform(-1, 1) for _ in range(len(position))]
        self.best_position = position
        self.best_fitness = fitness_function(position)


# 粒子群优化功能
def particle_swarm_optimization(pop_size, num_generations, inertia_weight, cognitive_weight, social_weight, lower_bound,
                                upper_bound):
    particles = [Particle([random.uniform(lower_bound, upper_bound)]) for _ in range(pop_size)]
    global_best_position = particles[0].position
    global_best_fitness = particles[0].best_fitness

    for generation in range(num_generations):
        for particle in particles:
            # 更新粒子速度和位置
            for i in range(len(particle.position)):
                r1 = random.random()
                r2 = random.random()
                cognitive_component = cognitive_weight * r1 * (particle.best_position[i] - particle.position[i])
                social_component = social_weight * r2 * (global_best_position[i] - particle.position[i])
                particle.velocity[i] = inertia_weight * particle.velocity[i] + cognitive_component + social_component
                particle.position[i] += particle.velocity[i]

            # 更新粒子最佳位置和适应度
            fitness = fitness_function(particle.position)
            if fitness > particle.best_fitness:
                particle.best_position = particle.position
                particle.best_fitness = fitness

            # 更新全局最佳位置和适应度
            if fitness > global_best_fitness:
                global_best_position = particle.position
                global_best_fitness = fitness

    return global_best_position, -global_best_fitness


if __name__ == "__main__":
    pop_size = 50
    num_generations = 100
    inertia_weight = 0.7
    cognitive_weight = 1.4
    social_weight = 1.4
    lower_bound = -10
    upper_bound = 10

    best_position, best_fitness = particle_swarm_optimization(pop_size, num_generations, inertia_weight,
                                                              cognitive_weight, social_weight, lower_bound, upper_bound)

    print("Best position:", best_position)
    print("Best fitness:", best_fitness)

多目标函数

import random
import time

import numpy as np


# 多目标函数，我们需要优化的函数，求解该函数的最小值
def objective_function(x):
    return x[0] ** 2 + x[1] ** 2


# 粒子类
class Particle:
    def __init__(self, bounds):
        self.bounds = bounds  # 粒子的位置范围
        # 初始化粒子的位置
        self.position = np.array([random.uniform(bounds[i][0], bounds[i][1]) for i in range(len(bounds))])
        self.velocity = np.array([0.0 for _ in range(len(bounds))])  # 初始化粒子的速度
        self.best_position = self.position.copy()  # 粒子的最佳位置
        self.best_value = float('inf')  # 粒子的最佳值

    def update(self, global_best):
        # 参数设置
        w = 0.5  # 惯性权重
        c1 = 1  # 个体学习因子
        c2 = 2  # 社会学习因子
        v_max = 5  # 最大速度

        # 更新速度
        self.velocity = w * self.velocity + c1 * random.random() * (
                self.best_position - self.position) + c2 * random.random() * (global_best - self.position)

        # 限制速度，防止速度过大
        self.velocity = np.clip(self.velocity, -v_max, v_max)

        # 更新位置
        self.position += self.velocity

        # 确保粒子的位置在范围内
        self.position = np.clip(self.position, [b[0] for b in self.bounds], [b[1] for b in self.bounds])

        # 更新个体最优
        current_value = objective_function(self.position)
        if current_value < self.best_value:
            self.best_position = self.position.copy()
            self.best_value = current_value


# PSO算法
def particle_swarm_optimization(num_particles, bounds, num_iterations):
    particles = [Particle(bounds) for _ in range(num_particles)]  # 初始化粒子群
    global_best = np.array([float('inf'), float('inf')])  # 全局最佳位置
    global_best_value = float('inf')  # 全局最佳值

    for _ in range(num_iterations):
        for particle in particles:
            particle.update(global_best)

            # 更新全局最优
            if particle.best_value < global_best_value:
                global_best = particle.best_position.copy()
                global_best_value = particle.best_value

    return global_best, global_best_value


start_time = time.time()
# 使用示例
bounds = [(-10, 10), (-10, 10)]  # x和y的范围
best_position, best_value = particle_swarm_optimization(1000, bounds, 100)
print(f"最佳位置: {best_position}, 最佳值: {best_value}")
end_time = time.time()
print(f"函数执行时间为: {end_time - start_time} 秒")