python3实现单目标粒子群算法


Posted in Python onNovember 14, 2019

本文实例为大家分享了python3单目标粒子群算法的具体代码,供大家参考,具体内容如下

关于PSO的基本知识......就说一下算法流程

1) 初始化粒子群;

    随机设置各粒子的位置和速度,默认粒子的初始位置为粒子最优位置,并根据所有粒子最优位置,选取群体最优位置。

2) 判断是否达到迭代次数;

    若没有达到,则跳转到步骤3)。否则,直接输出结果。

3) 更新所有粒子的位置和速度;

4) 计算各粒子的适应度值。

     将粒子当前位置的适应度值与粒子最优位置的适应度值进行比较,决定是否更新粒子最优位置;将所有粒子最优位置的适应度值与群体最优位置的适应度值进行比较,决定是否更新群体最优位置。然后,跳转到步骤2)。

直接扔代码......(PS:1.参数动态调节;2.例子是二维的)

首先,是一些准备工作...

# Import libs
import numpy as np
import random as rd
import matplotlib.pyplot as plt
 
# Constant definition
MIN_POS = [-5, -5]         # Minimum position of the particle
MAX_POS = [5, 5]          # Maximum position of the particle
MIN_SPD = [-0.5, -0.5]        # Minimum speed of the particle
MAX_SPD = [1, 1]          # Maximum speed of the particle
C1_MIN = 0
C1_MAX = 1.5
C2_MIN = 0
C2_MAX = 1.5
W_MAX = 1.4
W_MIN = 0

然后是PSO类

# Class definition
class PSO():
 """
  PSO class
 """
 
 def __init__(self,iters=100,pcount=50,pdim=2,mode='min'):
  """
   PSO initialization
   ------------------
  """
 
  self.w = None         # Inertia factor
  self.c1 = None        # Learning factor
  self.c2 = None        # Learning factor
 
  self.iters = iters       # Number of iterations
  self.pcount = pcount       # Number of particles
  self.pdim = pdim        # Particle dimension
  self.gbpos = np.array([0.0]*pdim)    # Group optimal position
  
  self.mode = mode        # The mode of PSO
 
  self.cur_pos = np.zeros((pcount, pdim))  # Current position of the particle
  self.cur_spd = np.zeros((pcount, pdim))  # Current speed of the particle
  self.bpos = np.zeros((pcount, pdim))   # The optimal position of the particle
 
  self.trace = []        # Record the function value of the optimal solution
  
 
 def init_particles(self):
  """
   init_particles function
   -----------------------
  """
 
  # Generating particle swarm
  for i in range(self.pcount):
   for j in range(self.pdim):
    self.cur_pos[i,j] = rd.uniform(MIN_POS[j], MAX_POS[j])
    self.cur_spd[i,j] = rd.uniform(MIN_SPD[j], MAX_SPD[j])
    self.bpos[i,j] = self.cur_pos[i,j]
 
  # Initial group optimal position
  for i in range(self.pcount):
   if self.mode == 'min':
    if self.fitness(self.cur_pos[i]) < self.fitness(self.gbpos):
     gbpos = self.cur_pos[i]
   elif self.mode == 'max':
    if self.fitness(self.cur_pos[i]) > self.fitness(self.gbpos):
     gbpos = self.cur_pos[i]
 
 def fitness(self, x):
  """
   fitness function
   ----------------
   Parameter:
    x : 
  """
  
  # Objective function
  fitval = 5*np.cos(x[0]*x[1])+x[0]*x[1]+x[1]**3 # min
  # Retyrn value
  return fitval
 
 def adaptive(self, t, p, c1, c2, w):
  """
  """
 
  #w = 0.95 #0.9-1.2
  if t == 0:
   c1 = 0
   c2 = 0
   w = 0.95
  else:
   if self.mode == 'min':
    # c1
    if self.fitness(self.cur_pos[p]) > self.fitness(self.bpos[p]):
     c1 = C1_MIN + (t/self.iters)*C1_MAX + np.random.uniform(0,0.1)
    elif self.fitness(self.cur_pos[p]) <= self.fitness(self.bpos[p]):
     c1 = c1
    # c2 
    if self.fitness(self.bpos[p]) > self.fitness(self.gbpos):
     c2 = C2_MIN + (t/self.iters)*C2_MAX + np.random.uniform(0,0.1)
    elif self.fitness(self.bpos[p]) <= self.fitness(self.gbpos):
     c2 = c2
    # w
    #c1 = C1_MAX - (C1_MAX-C1_MIN)*(t/self.iters)
    #c2 = C2_MIN + (C2_MAX-C2_MIN)*(t/self.iters)
    w = W_MAX - (W_MAX-W_MIN)*(t/self.iters)
   elif self.mode == 'max':
    pass
 
  return c1, c2, w
 
 def update(self, t):
  """
   update function
   ---------------
    Note that :
     1. Update particle position
     2. Update particle speed
     3. Update particle optimal position
     4. Update group optimal position
  """
 
  # Part1 : Traverse the particle swarm
  for i in range(self.pcount):
   
   # Dynamic parameters
   self.c1, self.c2, self.w = self.adaptive(t,i,self.c1,self.c2,self.w)
   
   # Calculate the speed after particle iteration
   # Update particle speed
   self.cur_spd[i] = self.w*self.cur_spd[i] \
        +self.c1*rd.uniform(0,1)*(self.bpos[i]-self.cur_pos[i])\
        +self.c2*rd.uniform(0,1)*(self.gbpos - self.cur_pos[i])
   for n in range(self.pdim):
    if self.cur_spd[i,n] > MAX_SPD[n]:
     self.cur_spd[i,n] = MAX_SPD[n]
    elif self.cur_spd[i,n] < MIN_SPD[n]:
     self.cur_spd[i,n] = MIN_SPD[n]
 
   # Calculate the position after particle iteration
   # Update particle position 
   self.cur_pos[i] = self.cur_pos[i] + self.cur_spd[i]
   for n in range(self.pdim):
    if self.cur_pos[i,n] > MAX_POS[n]:
     self.cur_pos[i,n] = MAX_POS[n]
    elif self.cur_pos[i,n] < MIN_POS[n]:
     self.cur_pos[i,n] = MIN_POS[n]
    
  # Part2 : Update particle optimal position
  for k in range(self.pcount):
   if self.mode == 'min':
    if self.fitness(self.cur_pos[k]) < self.fitness(self.bpos[k]):
     self.bpos[k] = self.cur_pos[k]
   elif self.mode == 'max':
    if self.fitness(self.cur_pos[k]) > self.fitness(self.bpos[k]):
     self.bpos[k] = self.cur_pos[k]
 
  # Part3 : Update group optimal position
  for k in range(self.pcount):
   if self.mode == 'min':
    if self.fitness(self.bpos[k]) < self.fitness(self.gbpos):
     self.gbpos = self.bpos[k]
   elif self.mode == 'max':
    if self.fitness(self.bpos[k]) > self.fitness(self.gbpos):
     self.gbpos = self.bpos[k]
 
 def run(self):
  """
   run function
   -------------
  """
 
  # Initialize the particle swarm
  self.init_particles()
 
  # Iteration
  for t in range(self.iters):
   # Update all particle information
   self.update(t)
   #
   self.trace.append(self.fitness(self.gbpos))

然后是main...

def main():
 """
  main function
 """
 
 for i in range(1):
  
  pso = PSO(iters=100,pcount=50,pdim=2, mode='min')
  pso.run()
   
  #
  print('='*40)
  print('= Optimal solution:')
  print('= x=', pso.gbpos[0])
  print('= y=', pso.gbpos[1])
  print('= Function value:')
  print('= f(x,y)=', pso.fitness(pso.gbpos))
  #print(pso.w)
  print('='*40)
  
  #
  plt.plot(pso.trace, 'r')
  title = 'MIN: ' + str(pso.fitness(pso.gbpos))
  plt.title(title)
  plt.xlabel("Number of iterations")
  plt.ylabel("Function values")
  plt.show()
 #
 input('= Press any key to exit...')
 print('='*40)
 exit() 
 
 
if __name__ == "__main__":
 
 main()

最后是计算结果,完美结束!!!

python3实现单目标粒子群算法

python3实现单目标粒子群算法

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持三水点靠木。

Python 相关文章推荐
在Python中使用poplib模块收取邮件的教程
Apr 29 Python
Python编程中运用闭包时所需要注意的一些地方
May 02 Python
详解Python中的条件判断语句
May 14 Python
Python处理json字符串转化为字典的简单实现
Jul 07 Python
详解python开发环境搭建
Dec 16 Python
Python 中PyQt5 点击主窗口弹出另一个窗口的实现方法
Jul 04 Python
浅析python 动态库m.so.1.0错误问题
May 09 Python
Pyinstaller加密打包应用的示例代码
Jun 11 Python
Python Excel vlookup函数实现过程解析
Jun 22 Python
详解Python 循环嵌套
Jul 09 Python
Python获取百度热搜的完整代码
Apr 07 Python
pytorch 如何使用batch训练lstm网络
May 28 Python
python socket 聊天室实例代码详解
Nov 14 #Python
python中dict()的高级用法实现
Nov 13 #Python
python实现的多任务版udp聊天器功能案例
Nov 13 #Python
利用python实现PSO算法优化二元函数
Nov 13 #Python
使用python制作一个解压缩软件
Nov 13 #Python
Python 脚本实现淘宝准点秒杀功能
Nov 13 #Python
基于python实现把图片转换成素描
Nov 13 #Python
You might like
PHP 第二节 数据类型之转换
2012/04/28 PHP
PHP 正则表达式常用函数
2014/08/17 PHP
php中限制ip段访问、禁止ip提交表单的代码分享
2014/08/22 PHP
PHP分页初探 一个最简单的PHP分页代码的简单实现
2016/06/21 PHP
删除PHP数组中的重复元素的实现代码
2017/04/10 PHP
关于php unset对json_encode的影响详解
2018/11/14 PHP
浅谈Javascript嵌套函数及闭包
2010/11/09 Javascript
jQuery 鼠标经过(hover)事件的延时处理示例
2014/04/14 Javascript
浅谈类似于(function(){}).call()的js语句
2015/03/30 Javascript
JavaScript中字符串分割函数split用法实例
2015/04/07 Javascript
JavaScript动态数量的文件上传控件
2016/11/18 Javascript
node.js 和HTML5开发本地桌面应用程序
2016/12/13 Javascript
简单实现Vue的observer和watcher
2016/12/21 Javascript
用vue快速开发app的脚手架工具
2018/06/11 Javascript
微信小程序实现折叠展开效果
2018/07/19 Javascript
js使用formData实现批量上传
2020/03/27 Javascript
详解vue2.0模拟后台json数据
2019/05/16 Javascript
Antd的Table组件嵌套Table以及选择框联动操作
2020/10/24 Javascript
[46:04]Liquid vs VP Supermajor决赛 BO 第四场 6.10
2018/07/05 DOTA
用Python输出一个杨辉三角的例子
2014/06/13 Python
python实现决策树ID3算法的示例代码
2018/05/30 Python
python中cPickle类使用方法详解
2018/08/27 Python
Python学习笔记之Zip和Enumerate用法实例分析
2019/08/14 Python
python 多维高斯分布数据生成方式
2019/12/09 Python
python GUI库图形界面开发之PyQt5信号与槽的高级使用技巧装饰器信号与槽详细使用方法与实例
2020/03/06 Python
python实现npy格式文件转换为txt文件操作
2020/07/01 Python
Pytorch1.5.1版本安装的方法步骤
2020/12/31 Python
彻底解决pip下载pytorch慢的问题方法
2021/03/01 Python
trivago美国:全球最大的酒店价格比较网站
2018/01/18 全球购物
加拿大的标志性百货公司:Hudson’s Bay(哈得逊湾)
2019/09/03 全球购物
寻找迷宫的一条出路,o通路;X:障碍
2016/07/10 面试题
办公室驾驶员岗位职责
2013/11/15 职场文书
给全校老师的建议书
2014/03/13 职场文书
销售经理岗位职责
2014/03/16 职场文书
给校长的建议书范文
2015/09/14 职场文书
SQL实现LeetCode(177.第N高薪水)
2021/08/04 MySQL