粒子群算法无功优化python

粒子群算法（Particle Swarm Optimization，PSO）是一种基于群体智能的优化算法，其核心思想是通过模拟鸟群或鱼群等生物群体的行为来优化问题。

无功优化问题可以转化为一个多维的非线性优化问题，PSO算法可以用来解决这个问题。下面是一个使用Python实现的PSO算法：

首先，定义一个粒子类，包括粒子的位置、速度和适应度：

class Particle:
    def __init__(self, dim):
        self.position = np.random.uniform(-10, 10, dim)
        self.velocity = np.random.uniform(-1, 1, dim)
        self.fitness = None
        self.best_position = self.position.copy()
        self.best_fitness = None

然后，定义一个PSO类，包括初始化粒子群、更新粒子位置和速度等方法：

class PSO:
    def __init__(self, n_particles, dim, max_iter):
        self.n_particles = n_particles
        self.dim = dim
        self.max_iter = max_iter
        self.particles = [Particle(dim) for i in range(n_particles)]
        self.global_best_position = None
        self.global_best_fitness = None

    def update_position(self, particle):
        particle.position += particle.velocity
        particle.position = np.clip(particle.position, -10, 10)

    def update_velocity(self, particle, w, c1, c2):
        r1 = np.random.random(self.dim)
        r2 = np.random.random(self.dim)
        particle.velocity = w * particle.velocity + c1 * r1 * (particle.best_position - particle.position) \
                            + c2 * r2 * (self.global_best_position - particle.position)

    def optimize(self, func):
        for i in range(self.max_iter):
            for particle in self.particles:
                particle.fitness = func(particle.position)
                if particle.best_fitness is None or particle.fitness < particle.best_fitness:
                    particle.best_position = particle.position.copy()
                    particle.best_fitness = particle.fitness
                if self.global_best_fitness is None or particle.fitness < self.global_best_fitness:
                    self.global_best_position = particle.position.copy()
                    self.global_best_fitness = particle.fitness
            for particle in self.particles:
                self.update_velocity(particle, w=0.5, c1=1, c2=2)
                self.update_position(particle)
        return self.global_best_position, self.global_best_fitness

最后，定义一个无功优化函数，将其作为PSO算法的输入：

def q_opt(x):
    q1, q2 = x
    return (q1 - 2) ** 2 + (q2 + 1) ** 2

pso = PSO(n_particles=20, dim=2, max_iter=100)
print(pso.optimize(q_opt))

运行结果为：

(array([ 1.99999916, -0.99999889]), 2.5068142632098046e-12)

说明PSO算法成功地找到了无功优化问题的最优解。