优化算法笔记|粒子群算法理解及Python实现_python模糊矩阵 粒子群初始化

1.粒子群算法概述

粒子群算法 来源于对鸟群捕食模型的修正。
假设在一个n维空间中，有一群鸟（m只）在捕食，食物位于n维空间的某个点上。

假设鸟每次都能够判断离食物更近还是更远了，这样鸟在捕食的过程中会根据自己的经验以及鸟群中的 其他鸟的位置决定自己的速度，根据当前的位置和速度，可得下一刻的位置，这样每只鸟通过向自己和鸟群学习不断更新自己的速度和位置，直到最终获得食物，或者是离食物足够近。

对于某一时刻的第i只鸟，可用两个向量描述，鸟的位置向量Pi =(xi1,xi2,…xin), 鸟的速度 Vi =（Vi1,Vi2，…Vin）(i=1,2,…m)。
更新速度的表达式：

更新位置的表达式：

粒子 i 经过的历史最好位置：

种群经过的历史最好位置：

优点：粒子群算法作为一种优化算法，在解空间，粒子追随最优的粒子进行搜索。
它比蚁群算法、遗传算法等更简单，参数少，无需梯度信息，收敛速度更快。

设想这样一个场景：
一群鸟在随机搜索食物，在这个区域里只有一块食物，所有的鸟都不知道食物在哪，但是他们知道自己当前的位置距离食物还有多远。
那么找到食物的最优策略是什么？
最简单有效的方法是：搜寻目前离食物最近的鸟的周围区域。

2 基本PSO算法流程图

3 粒子群算法的Python实现

import numpy as np
import matplotlib.pyplot as plt
 
 
class PSO(object):
    def __init__(self, population_size, max_steps):
        self.w = 0.6  # 惯性权重
        self.c1 = self.c2 = 2
        self.population_size = population_size  # 粒子群数量
        self.dim = 2  # 搜索空间的维度
        self.max_steps = max_steps  # 迭代次数
        self.x_bound = [-10, 10]  # 解空间范围
        self.x = np.random.uniform(self.x_bound[0], self.x_bound[1],
                                   (self.population_size, self.dim))  # 初始化粒子群位置
        self.v = np.random.rand(self.population_size, self.dim)  # 初始化粒子群速度
        fitness = self.calculate_fitness(self.x)
        self.p = self.x  # 个体的最佳位置
        self.pg = self.x[np.argmin(fitness)]  # 全局最佳位置
        self.individual_best_fitness = fitness  # 个体的最优适应度
        self.global_best_fitness = np.min(fitness)  # 全局最佳适应度
 
    def calculate_fitness(self, x):
        return np.sum(np.square(x), axis=1)
 
    def evolve(self):
        fig = plt.figure()
        for step in range(self.max_steps):
            r1 = np.random.rand(self.population_size, self.dim)
            r2 = np.random.rand(self.population_size, self.dim)
            # 更新速度和权重
            self.v = self.w*self.v+self.c1*r1*(self.p-self.x)+self.c2*r2*(self.pg-self.x)
            self.x = self.v + self.x
            plt.clf()
            plt.scatter(self.x[:, 0], self.x[:, 1], s=30, color='k')
            plt.xlim(self.x_bound[0], self.x_bound[1])
            plt.ylim(self.x_bound[0], self.x_bound[1])
            plt.pause(0.01)
            fitness = self.calculate_fitness(self.x)
            # 需要更新的个体
            update_id = np.greater(self.individual_best_fitness, fitness)
            self.p[update_id] = self.x[update_id]
            self.individual_best_fitness[update_id] = fitness[update_id]
            # 新一代出现了更小的fitness，所以更新全局最优fitness和位置
            if np.min(fitness) < self.global_best_fitness:
                self.pg = self.x[np.argmin(fitness)]
                self.global_best_fitness = np.min(fitness)
            print('best fitness: %.5f, mean fitness: %.5f' % (self.global_best_fitness, np.mean(fitness)))
 
 
pso = PSO(100, 100)
pso.evolve()
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

运行结果：
初始结果：

最后结果：

参考博客：

https://blog.csdn.net/chen_jp/article/details/7947059
https://blog.csdn.net/winycg/article/details/79120154
https://blog.csdn.net/zuochao_2013/article/details/53431767?ref=myread