python实现PSO算法优化二元函数

python实现PSO算法优化二元函数

import numpy as np  
import random   
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

#----------------------PSO参数设置---------------------------------  
class PSO():  
   
    def __init__(self,pN,dim,max_iter):  #初始化类  设置粒子数量  位置信息维度  最大迭代次数 
        #self.w = 0.8 
        self.ws = 0.9
        self.we = 0.4
        self.c1 = 1.49445     
        self.c2 = 1.49445     
        self.r1= 0.6  
        self.r2= 0.3  
        self.pN = pN                #粒子数量  
        self.dim = dim              #搜索维度  
        self.max_iter = max_iter    #迭代次数  
        self.X = np.zeros((self.pN,self.dim))       #所有粒子的位置（还要确定取值范围）  
        self.Xmax = 5  
        self.Xmin = -5
        self.V = np.zeros((self.pN,self.dim))       #所有粒子的速度（还要确定取值范围）
        self.Vmax = 1 
        self.Vmin = -1
        self.pbest = np.zeros((self.pN,self.dim))   #个体经历的最佳位置 
        self.gbest = np.zeros((1,self.dim))         #全局最佳位置
        self.p_fit = np.zeros(self.pN)              #每个个体的历史最佳适应值  
        self.fit = 0             #全局最佳适应值  
          

#---------------------目标函数Sphere函数-----------------------------  
    def function(self,x):  
        y = np.sin(10*np.pi*x)/x
        return y

    def Holder_table(self,x,y):     
        z = -np.abs(np.sin(x) * np.cos(y) * np.exp(np.abs(1 - np.sqrt(x**2 + y**2)/np.pi)))
        return z
    
    def fuck(self,x,y):
        z = x**2 + y**2 - 10*np.cos(2*np.pi*x) - 10*np.cos(2*np.pi*y) + 20
        return z

    
#---------------------初始化种群----------------------------------  
    def init_Population(self):
        for i in range(self.pN):                                #遍历所有粒子
            
            for j in range(self.dim):                           #每一个粒子的纬度
                self.X[i][j] = random.uniform(-5,5)             #给每一个粒子的位置赋一个初始随机值（在一定范围内）
                self.V[i][j] = random.uniform(-1,1)             #给每一个粒子的速度给一个初始随机值（在一定范围内）
            
            self.pbest[i] = self.X[i]                            #把当前粒子位置作为这个粒子的最优位置
            tmp = self.fuck(self.X[i][0],self.X[i][1])           #计算这个粒子的适应度值
            self.p_fit[i] = tmp                                  #当前粒子的适应度值作为个体最优值
            
            if(tmp > self.fit):                                  #与当前全局最优值做比较并选取更佳的全局最优值
                self.fit = tmp  
                self.gbest = self.X[i]  

                
#---------------------更新粒子位置----------------------------------  
    def iterator(self):  
        fitness = []  
        for t in range(self.max_iter):
            w =  self.ws - (self.ws - self.we) * (t / self.max_iter)
            for i in range(self.pN):  
                
                #更新速度
                self.V[i]  = w*self.V[i] + self.c1*self.r1*(self.pbest[i] - self.X[i]) + self.c2*self.r2*(self.gbest - self.X[i])
                if self.V[i][0] > self.Vmax:
                    self.V[i][0] = self.Vmax
                elif self.V[i][0] < self.Vmin:
                    self.V[i][0] = self.Vmin
                
                if self.V[i][1] > self.Vmax:
                    self.V[i][1] = self.Vmax
                elif self.V[i][1] < self.Vmin:
                    self.V[i][1] = self.Vmin
                
                #更新位置
                self.X[i] = self.X[i] + self.V[i]
                if self.X[i][0] > self.Xmax:
                    self.X[i][0] = self.Xmax
                elif self.X[i][0] < self.Xmin:
                    self.X[i][0] = self.Xmin
                
                if self.X[i][1] > self.Xmax:
                    self.X[i][1] = self.Xmax
                elif self.X[i][1] < self.Xmin:
                    self.X[i][1] = self.Xmin
            
            for i in range(self.pN):         #更新gbest\pbest  
                
                temp = self.fuck(self.X[i][0],self.X[i][1])  
                
                if(temp > self.p_fit[i]):      #更新个体最优  
                    self.pbest[i] = self.X[i]
                    self.p_fit[i] = temp 
               
                if(temp > self.fit):           #更新全局最优  
                    self.gbest = self.X[i]  
                    self.fit = temp  
              
            fitness.append(self.fit)  
            print('最优值为：',self.fit)#输出最优值 
            z1 = self.fit
            print('最优位置为：',self.X[i][0],self.X[i][1])
            x1 = self.X[i][0]
            y1 = self.X[i][1]
        return fitness, z1, x1,y1

#----------------------程序执行-----------------------  
my_pso = PSO(pN=100,dim=2,max_iter=200)  
my_pso.init_Population()  
fitness,z1,x1,y1 = my_pso.iterator()

plt.figure(1)  
plt.title("Figure1")  
plt.xlabel("iterators", size=14)  
plt.ylabel("fitness", size=14)  
t = np.array([t for t in range(0,200)])  
fitness = np.array(fitness)  
plt.plot(t,fitness, color='b',linewidth=3) 
plt.show() 

fig = plt.figure(figsize=(15,10))
ax = Axes3D(fig)
X = np.arange(-5,5,0.1)
Y = np.arange(-5,5,0.1)
X,Y = np.meshgrid(X,Y)
def f(x,y):
    return (x**2 + y**2 - 10*np.cos(2*np.pi*x) - 10*np.cos(2*np.pi*y) + 20)
ax.plot_surface(X,Y,f(X,Y),rstride=1,cstride=1,cmap= plt.get_cmap('rainbow'))
ax.scatter(x1, y1, z1,s=400,c='k',marker = '*')
plt.show()

效果图如下