精华内容
下载资源
问答
  • 使用matlab编程,分为个.m文件编写,包括支配关系选择,全局领导者选择,删除多于的非劣解,创建...套用算法只需要改动Mycost函数与主函数中粒子的取值与维度,即主函数中问题定义处与MOPSO设置处,其余不需要改动
  • 数学建模源码集锦-基于粒子群算法多目标搜索算法应用实例
  • 目标优化算法——多目标粒子群算法实战分享

    万次阅读 多人点赞 2019-03-09 12:34:24
    版权声明:本文为博主原创文章,未经博主允许不得转载。 运筹学优化领域,目标优化...PPT下载地址:《多目标粒子群算法分享 - CSDN博主dkjkls》。 ...

    版权声明:本文为博主原创文章,未经博主允许不得转载。

    运筹学优化领域,多目标优化算法,多目标自适应粒子群优化算法;并简要介绍了开源多目标优化算法框架jMetal。
    基本的粒子群优化算法可参照博主的一篇文章粒子群算法实战分享-附原版动画PPT(技术分享也可以文艺范?)

    PPT下载地址:《多目标粒子群算法分享 - CSDN博主dkjkls》

    参考文献:
    杨俊杰. 基于MOPSO和集对分析决策方法的流域梯级联合优化调度[D]. 华中科技大学, 2007.

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述


    --------------------------文档信息--------------------------
    版权声明:本文为博主原创文章,未经博主允许不得转载
    署名(BY) :dkjkls(dkj卡洛斯)
    文章出处:http://blog.csdn.net/dkjkls

    展开全文
  • (python源码,详细注解 )多目标粒子群算法 mopso

    万次阅读 多人点赞 2018-04-07 18:51:34
    1 本代码功能用多目标粒子群算法(mopso)寻找pareto最优解集2 算法介绍2.1 简单步骤:(1)初始化群体粒子群的位置和速度,计算适应值(2)根据pareto支配原则,计算得到Archive 集(存放当前的非劣解)(3)计算pbest(4)...

    1 本代码功能

    用多目标粒子群算法(mopso)寻找pareto最优解集

    2 算法介绍

    2.1 简单步骤:

    (1)初始化群体粒子群的位置和速度,计算适应值

    (2)根据pareto支配原则,计算得到Archive 集(存放当前的非劣解)

    (3)计算pbest

    (4)计算Archive集中的拥挤度

    (5)在Archive集选择gbest

    (6)更新粒子的速度、位置、适应值

    (7)更新Archive集(还要注意防止溢出)

    (8)满足结束条件,则结束;否则,转到第(3)步继续循环。

    2.2 算法的详解可参考如下博客:

    2.2.1 对多目标粒子群算法MOPSO的理解,https://blog.csdn.net/ture_2010/article/details/18180183

    2.2.2 MOPSO算法学习总结,https://blog.csdn.net/sbcypress/article/details/50727907

    2.2.3 Handling multiple objectives with particle swarm optimization

    3 简单图示

    为了便于图示观察,本源码使用一组简单的测试函数:输入坐标为2维(input_x1,input_x2),输出适应值为2维(fitness_y1,fitness_y2)。如下图所示,经过10轮迭代后,pareto边界已见轮廓,红 色点代表pareto最优解集。

    4 代码如下

    4.1 main.py


    #encoding: utf-8
    import numpy as np
    from mopso import *
    
    def main():
    	w = 0.8 #惯性因子
    	c1 = 0.1 #局部速度因子
    	c2 = 0.1 #全局速度因子
    	particals = 100 #粒子群的数量
    	cycle_ = 30 #迭代次数
    	mesh_div = 10 #网格等分数量
    	thresh = 300 #外部存档阀值
    	min_ = np.array([0,0]) #粒子坐标的最小值
    	max_ = np.array([10,10]) #粒子坐标的最大值
    	mopso_ = Mopso(particals,w,c1,c2,max_,min_,thresh,mesh_div) #粒子群实例化
    	pareto_in,pareto_fitness = mopso_.done(cycle_) #经过cycle_轮迭代后,pareto边界粒子
    	np.savetxt("./img_txt/pareto_in.txt",pareto_in)#保存pareto边界粒子的坐标
    	np.savetxt("./img_txt/pareto_fitness.txt",pareto_fitness) #打印pareto边界粒子的适应值
    	print "\n","pareto边界的坐标保存于:/img_txt/pareto_in.txt"
    	print "pareto边界的适应值保存于:/img_txt/pareto_fitness.txt"
    	print "\n","迭代结束,over"
    
    if __name__ == "__main__":
    	main()
    

    4.2 mopso.py

    #encoding: utf-8
    import numpy as np
    from fitness_funs import *
    import init
    import update
    import plot
    class Mopso:
    	def __init__(self,particals,w,c1,c2,max_,min_,thresh,mesh_div=10):
    		self.w,self.c1,self.c2 = w,c1,c2
    		self.mesh_div = mesh_div
    		self.particals = particals
    		self.thresh = thresh
    		self.max_ = max_
    		self.min_ = min_
    		self.max_v = (max_-min_)*0.05  #速度下限
    		self.min_v = (max_-min_)*0.05*(-1) #速度上限
    		self.plot_ = plot.Plot_pareto()
    	def evaluation_fitness(self): 
    		#计算适应值
    		fitness_curr = []
    		for i in range((self.in_).shape[0]):
    			fitness_curr.append(fitness_(self.in_[i]))
    		self.fitness_ = np.array(fitness_curr) #适应值
    	def initialize(self):
    		#初始化粒子坐标
    		self.in_ = init.init_designparams(self.particals,self.min_,self.max_)
    		#初始化粒子速度
    		self.v_ = init.init_v(self.particals,self.min_v,self.max_v)
    		#计算适应值
    		self.evaluation_fitness()
    		#初始化个体最优
    		self.in_p,self.fitness_p = init.init_pbest(self.in_,self.fitness_)
    		#初始化外部存档
    		self.archive_in,self.archive_fitness = init.init_archive(self.in_,self.fitness_)
    		#初始化全局最优
    		self.in_g,self.fitness_g = init.init_gbest(self.archive_in,self.archive_fitness,self.mesh_div,self.min_,self.max_,self.particals)
    	def update_(self):
    		#更新粒子坐标、粒子速度、适应值、个体最优、外部存档、全局最优
    		self.v_ = update.update_v(self.v_,self.min_v,self.max_v,self.in_,self.in_p,self.in_g,self.w,self.c1,self.c2)
    		self.in_ = update.update_in(self.in_,self.v_,self.min_,self.max_)
    		self.evaluation_fitness()
    		self.in_p,self.fitness_p = update.update_pbest(self.in_,self.fitness_,self.in_p,self.fitness_p)
    		self.archive_in,self.archive_fitness = update.update_archive(self.in_,self.fitness_,self.archive_in,self.archive_fitness,self.thresh,self.mesh_div,self.min_,self.max_,self.particals)
    		self.in_g,self.fitness_g = update.update_gbest(self.archive_in,self.archive_fitness,self.mesh_div,self.min_,self.max_,self.particals)
    	def done(self,cycle_):
    		self.initialize()
    		self.plot_.show(self.in_,self.fitness_,self.archive_in,self.archive_fitness,-1)
    		for i in range(cycle_):
    			self.update_()
    			self.plot_.show(self.in_,self.fitness_,self.archive_in,self.archive_fitness,i)
    		return self.archive_in,self.archive_fitness

    4.3 init.py

    #encoding: utf-8
    import random
    import numpy as np
    import archiving
    import pareto
    def init_designparams(particals,in_min,in_max):
    	in_dim = len(in_max) 	#输入参数的维度
    	in_temp = np.zeros((particals,in_dim))
    	for i in range(particals):
    		for j in range(in_dim):
    			in_temp[i,j] = random.uniform(0,1)*(in_max[j]-in_min[j])+in_min[j]	
    	return in_temp
    def init_v(particals,v_max,v_min):
    	v_dim = len(v_max) 	#输入参数的维度
    	v_ = np.zeros((particals,v_dim))
    	for i in range(particals):
    		for j in range(v_dim):
    			v_[i,j] = random.uniform(0,1)*(v_max[j]-v_min[j])+v_min[j]
    	return v_
    def init_pbest(in_,fitness_):
    	return in_,fitness_
    def init_archive(in_,fitness_):
    	pareto_c = pareto.Pareto_(in_,fitness_)
    	curr_archiving_in,curr_archiving_fit = pareto_c.pareto()
    	return curr_archiving_in,curr_archiving_fit
    def init_gbest(curr_archiving_in,curr_archiving_fit,mesh_div,min_,max_,particals):
    	get_g = archiving.get_gbest(curr_archiving_in,curr_archiving_fit,mesh_div,min_,max_,particals)
    	return get_g.get_gbest()
    	

    4.4 update.py

    #encoding: utf-8
    import numpy as np
    import random
    import pareto
    import archiving
    def update_v(v_,v_min,v_max,in_,in_pbest,in_gbest,w,c1,c2):
    	#更新速度值
    	v_temp = w*v_ + c1*(in_pbest-in_) + c2*(in_gbest-in_)
    	#如果粒子的新速度大于最大值,则置为最大值;小于最小值,则置为最小值
    	for i in range(v_temp.shape[0]):
    		for j in range(v_temp.shape[1]):
    			if v_temp[i,j]<v_min[j]:
    				v_temp[i,j] = v_min[j]
    			if v_temp[i,j]>v_max[j]:
    				v_temp[i,j] = v_max[j]
    	return v_temp
    def update_in(in_,v_,in_min,in_max):
    	#更新位置参数
    	in_temp = in_ + v_
    	#大于最大值,则置为最大值;小于最小值,则置为最小值
    	for i in range(in_temp.shape[0]):
    		for j in range(in_temp.shape[1]):
    			if in_temp[i,j]<in_min[j]:
    				in_temp[i,j] = in_min[j]
    			if in_temp[i,j]>in_max[j]:
    				in_temp[i,j] = in_max[j]
    	return in_temp
    def compare_pbest(in_indiv,pbest_indiv):
    	num_greater = 0
    	num_less = 0
    	for i in range(len(in_indiv)):
    		if in_indiv[i] > pbest_indiv[i]:
    			num_greater = num_greater +1
    		if in_indiv[i] < pbest_indiv[i]:
    			num_less = num_less +1
    	#如果当前粒子支配历史pbest,则更新,返回True
    	if (num_greater>0 and num_less==0):
    		return True
    	#如果历史pbest支配当前粒子,则不更新,返回False
    	elif (num_greater==0 and num_less>0):
    		return False
    	else:
    		#如果互不支配,则按照概率决定是否更新
    		random_ = random.uniform(0.0,1.0)
    		if random_ > 0.5:
    			return True
    		else:
    			return False
    def update_pbest(in_,fitness_,in_pbest,out_pbest):
    	for i in range(out_pbest.shape[0]):
    		#通过比较历史pbest和当前粒子适应值,决定是否需要更新pbest的值。
    		if compare_pbest(fitness_[i],out_pbest[i]):
    			out_pbest[i] = fitness_[i]
    			in_pbest[i] = in_[i]
    	return in_pbest,out_pbest
    def update_archive(in_,fitness_,archive_in,archive_fitness,thresh,mesh_div,min_,max_,particals):
    	#首先,计算当前粒子群的pareto边界,将边界粒子加入到存档archiving中
    	pareto_1 = pareto.Pareto_(in_,fitness_)
    	curr_in,curr_fit = pareto_1.pareto()
    	#其次,在存档中根据支配关系进行第二轮筛选,将非边界粒子去除
    	in_new = np.concatenate((archive_in,curr_in),axis=0)
    	fitness_new = np.concatenate((archive_fitness,curr_fit),axis=0)
    	pareto_2 = pareto.Pareto_(in_new,fitness_new)
    	curr_archiving_in,curr_archiving_fit = pareto_2.pareto()
    	#最后,判断存档数量是否超过了存档阀值。如果超过了阀值,则清除掉一部分(拥挤度高的粒子被清除的概率更大)
    	if((curr_archiving_in).shape[0] > thresh):
    		clear_ = archiving.clear_archiving(curr_archiving_in,curr_archiving_fit,mesh_div,min_,max_,particals)
    		curr_archiving_in,curr_archiving_fit = clear_.clear_(thresh)
    	return curr_archiving_in,curr_archiving_fit
    def update_gbest(archiving_in,archiving_fit,mesh_div,min_,max_,particals):
    	get_g = archiving.get_gbest(archiving_in,archiving_fit,mesh_div,min_,max_,particals)
    	return get_g.get_gbest()

    4.5 archiving.py

    #encoding: utf-8
    import numpy as np
    import random
    
    class mesh_crowd(object): 
    	def __init__(self,curr_archiving_in,curr_archiving_fit,mesh_div,min_,max_,particals):
    		self.curr_archiving_in = curr_archiving_in #当前存档中所有粒子的坐标
    		self.curr_archiving_fit = curr_archiving_fit #当前存档中所有粒子的坐标
    		self.mesh_div = mesh_div #等分因子,默认值为10等分
    		
    		
    		
    		self.num_ = self.curr_archiving_in.shape[0] #cundangzhong######粒子数量
    		
    		self.particals = particals  ########
    		
    		self.id_archiving = np.zeros((self.num_)) #各个粒子的id编号,检索位与curr_archiving的检索位为相对应
    		self.crowd_archiving = np.zeros((self.num_)) #拥挤度矩阵,用于记录当前粒子所在网格的总粒子数,检索位与curr_archiving的检索为相对应
    		self.probability_archiving = np.zeros((self.num_)) #各个粒子被选为gbest的概率,检索位与curr_archiving的检索位为相对应
    		self.gbest_in = np.zeros((self.particals,self.curr_archiving_in.shape[1])) #初始化gbest矩阵_坐标
    		self.gbest_fit = np.zeros((self.particals,self.curr_archiving_fit.shape[1])) #初始化gbest矩阵_适应值
    		self.min_ = min_
    		self.max_ = max_
    
    	def cal_mesh_id(self,in_):
    		#计算网格编号id
    		#首先,将每个维度按照等分因子进行等分离散化,获取粒子在各维度上的编号。按照10进制将每一个维度编号等比相加(如过用户自定义了mesh_div_num的值,则按照自定义),计算出值
    		id_ = 0
    		for i in range(self.curr_archiving_in.shape[1]):
    			id_dim = int((in_[i]-self.min_[i])*self.num_/(self.max_[i]-self.min_[i]))
    			id_ = id_ + id_dim*(self.mesh_div**i)
    		return id_
    
    	def divide_archiving(self):
    		#进行网格划分,为每个粒子定义网格编号
    		for i in range(self.num_):
    			self.id_archiving[i] = self.cal_mesh_id(self.curr_archiving_in[i])
    
    	def get_crowd(self):
    		index_ = (np.linspace(0,self.num_-1,self.num_)).tolist()  #定义一个数组存放粒子集的索引号,用于辅助计算
    		index_ = map(int, index_)
    		while(len(index_) > 0):
    			index_same = [index_[0]] #存放本次子循环中与index[0]粒子具有相同网格id所有检索位
    			for i in range(1,len(index_)):
    				if self.id_archiving[index_[0]] == self.id_archiving[index_[i]]:
    					index_same.append(index_[i])
    			number_ = len(index_same) #本轮网格中的总粒子数
    			for i in index_same: #更新本轮网格id下的所有粒子的拥挤度
    				self.crowd_archiving[i] = number_
    				index_.remove(i) #删除本轮网格所包含的粒子对应的索引号,避免重复计算
    
    class get_gbest(mesh_crowd):
    	def __init__(self,curr_archiving_in,curr_archiving_fit,mesh_div_num,min_,max_,particals):
    		super(get_gbest,self).__init__(curr_archiving_in,curr_archiving_fit,mesh_div_num,min_,max_,particals)
    		self.divide_archiving()
    		self.get_crowd()
    
    	def get_probability(self):
    		for i in range(self.num_):
    			self.probability_archiving = 10.0/(self.crowd_archiving**3)
    		self.probability_archiving = self.probability_archiving/np.sum(self.probability_archiving) #所有粒子的被选概率的总和为1
    
    	def get_gbest_index(self):
    		random_pro = random.uniform(0.0,1.0) #生成一个0到1之间的随机数
    		for i in range(self.num_): 
    			if random_pro <= np.sum(self.probability_archiving[0:i+1]):
    				return i #返回检索值
    
    	def get_gbest(self):
    		self.get_probability()
    		for i in range(self.particals):
    			gbest_index = self.get_gbest_index()
    			self.gbest_in[i] = self.curr_archiving_in[gbest_index] #gbest矩阵_坐标
    			self.gbest_fit[i] = self.curr_archiving_fit[gbest_index] #gbest矩阵_适应值
    		return self.gbest_in,self.gbest_fit
    
    class clear_archiving(mesh_crowd):
    	def __init__(self,curr_archiving_in,curr_archiving_fit,mesh_div_num,min_,max_,particals):
    		super(get_gbest,self).__init__(curr_archiving_in,curr_archiving_fit,mesh_div_num,min_,max_)
    		self.divide_archiving()
    		self.get_crowd()
    
    	def get_probability(self):
    		for i in range(self.num_):
    			self.probability_archiving = self.crowd_archiving**2
    
    	def get_clear_index(self): #按概率清除粒子,拥挤度高的粒子被清除的概率越高
    		len_clear = (self.curr_archiving_in).shape[0] - self.thresh #需要清除掉的粒子数量
    		clear_index = []
    		while(len(clear_index)<len_clear):
    			random_pro = random.uniform(0.0,np.sum(self.probability_archiving)) #生成一个0到1之间的随机数
    			for i in range(self.num_): 
    				if random_pro <= np.sum(self.probability_archiving[0:i+1]):
    					if i not in clear_index:
    						clear_index.append(i) #记录检索值
    		return clear_index
    
    	def clear_(self,thresh):
    		self.thresh = thresh
    		self.archiving_size = archiving_size
    		self.get_probability()
    		clear_index = get_clear_index()
    		self.curr_archiving_in = np.delete(self.curr_archiving_in[gbest_index],clear_index,axis=0) #初始化gbest矩阵_坐标
    		self.curr_archiving_fit = np.delete(self.curr_archiving_fit[gbest_index],clear_index,axis=0) #初始化gbest矩阵_适应值
    		return self.curr_archiving_in,self.curr_archiving_fit
    4.6 pareto.py
    #encoding: utf-8
    import numpy as np
    
    def compare_ (fitness_curr,fitness_ref):
    #判断fitness_curr是否可以被fitness_ref完全支配
    	for i in range(len(fitness_curr)):
    		if fitness_curr[i] < fitness_ref[i]:
    			return True
    	return False
    def judge_(fitness_curr,fitness_data,cursor):
    #当前粒子的适应值fitness_curr与数据集fitness_data进行比较,判断是否为非劣解
    	for i in range(len(fitness_data)):
    		if i == cursor:
    			continue
    		#如果数据集中存在一个粒子可以完全支配当前解,则证明当前解为劣解,返回False
    		if compare_(fitness_curr,fitness_data[i]) == False:
    			return False
    	return True
    
    class Pareto_:
    	def __init__(self,in_data,fitness_data):
    		self.in_data = in_data  #粒子群坐标信息
    		self.fitness_data = fitness_data #粒子群适应值信息
    		self.cursor = -1 #初始化游标位置
    		self.len_ = in_data.shape[0] #粒子群的数量
    		self.bad_num = 0 #非优解的个数
    	def next(self):
    		#将游标的位置前移一步,并返回所在检索位的粒子坐标、粒子适应值
    		self.cursor = self.cursor+1
    		return self.in_data[self.cursor],self.fitness_data[self.cursor]
    	def hasNext(self):
    		#判断是否已经检查完了所有粒子
    		return self.len_ > self.cursor + 1 + self.bad_num
    	def remove(self):
    		#将非优解从数据集删除,避免反复与其进行比较。
    		self.fitness_data = np.delete(self.fitness_data,self.cursor,axis=0)
    		self.in_data = np.delete(self.in_data,self.cursor,axis=0)
    		#游标回退一步
    		self.cursor = self.cursor-1
    		#非优解个数,加1
    		self.bad_num = self.bad_num + 1
    	def pareto(self):
    		while(self.hasNext()):
    			#获取当前位置的粒子信息
    			in_curr,fitness_curr = self.next()
    			#判断当前粒子是否pareto最优
    			if judge_(fitness_curr,self.fitness_data,self.cursor) == False :
    				self.remove()
    		return self.in_data,self.fitness_data

    4.7 fitness_funs.py

    #encoding: utf-8
    import numpy as np
    #为了便于图示观察,试验测试函数为二维输入、二维输出
    #适应值函数:实际使用时请根据具体应用背景自定义
    def fitness_(in_):
        degree_45 = ((in_[0]-in_[1])**2/2)**0.5
        degree_135 = ((in_[0]+in_[1])**2/2)**0.5
        fit_1 = 1-np.exp(-(degree_45)**2/0.5)*np.exp(-(degree_135-np.sqrt(200))**2/250)
        fit_2 = 1-np.exp(-(degree_45)**2/5)*np.exp(-(degree_135)**2/350)
        return [fit_1,fit_2]

    4.8 plot.py

    #encoding: utf-8
    import numpy as np
    import os
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D
    import fitness_funs as fit
    class Plot_pareto:
    	def __init__(self):
    		#绘制测试函数的曲面,(x1,x2)表示两位度的输入,(y1,y2)表示两位的适应值,
    		self.x1 = np.linspace(0,10,100)
    		self.x2 = np.linspace(0,10,100)
    		self.x1,self.x2 = np.meshgrid(self.x1,self.x2)
    		self.m,self.n = np.shape(self.x1)
    		self.y1,self.y2 = np.zeros((self.m,self.n)),np.zeros((self.m,self.n))
    		for i in range(self.m):
    			for j in  range(self.n):
    				[self.y1[i,j],self.y2[i,j]] = fit.fitness_([self.x1[i,j],self.x2[i,j]])
    		if os.path.exists('./img_txt') == False:
    			os.makedirs('./img_txt')
    			print '创建文件夹img_txt:保存粒子群每一次迭代的图片' 
    	def show(self,in_,fitness_,archive_in,archive_fitness,i):
    		#共3个子图,第1、2/子图绘制输入坐标与适应值关系,第3图展示pareto边界的形成过程
    		fig = plt.figure(13,figsize = (17,5))
    
    		ax1 = fig.add_subplot(131, projection='3d')
    		ax1.set_xlabel('input_x1')
    		ax1.set_ylabel('input_x2')
    		ax1.set_zlabel('fitness_y1')
    		ax1.plot_surface(self.x1,self.x2,self.y1,alpha = 0.6)
    		ax1.scatter(in_[:,0],in_[:,1],fitness_[:,0],s=20, c='blue', marker=".")
    		ax1.scatter(archive_in[:,0],archive_in[:,1],archive_fitness[:,0],s=50, c='red', marker=".")
    		ax2 = fig.add_subplot(132, projection='3d')
    		ax2.set_xlabel('input_x1')
    		ax2.set_ylabel('input_x2')
    		ax2.set_zlabel('fitness_y2')
    		ax2.plot_surface(self.x1,self.x2,self.y2,alpha = 0.6)
    		ax2.scatter(in_[:,0],in_[:,1],fitness_[:,1],s=20, c='blue', marker=".")
    		ax2.scatter(archive_in[:,0],archive_in[:,1],archive_fitness[:,1],s=50, c='red', marker=".")
    		ax3 = fig.add_subplot(133)
    		ax3.set_xlim((0,1))
    		ax3.set_ylim((0,1))
    		ax3.set_xlabel('fitness_y1')
    		ax3.set_ylabel('fitness_y2')
    		ax3.scatter(fitness_[:,0],fitness_[:,1],s=10, c='blue', marker=".")
    		ax3.scatter(archive_fitness[:,0],archive_fitness[:,1],s=30, c='red', marker=".",alpha = 1.0)
    		#plt.show()
    		plt.savefig('./img_txt/第'+str(i+1)+'次迭代.png')
    		print '第'+str(i+1)+'次迭代的图片保存于 img_txt 文件夹'
    		plt.close()
    

    版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/m0_38097087/article/details/79818348

    展开全文
  • 粒子群算法是智能优化算法中的一个重要的组成部分,本代码是其在多目标领域一个重要的应用。看了此代码对多目标优化是及其重要的!
  • 企业对产品进行创新改进,带来装配线上装配任务的变化,从而造成已平衡装配线的失衡。针对上述变化给企业混流装配线带来的影响进行了...结合具体实例的验证表明,该改进多目标粒子群算法能有效地解决混装线再平衡问题。
  • 多目标优化粒子群算法MATLAB

    热门讨论 2010-04-22 13:05:52
    多目标粒子群算法是一种十分有效的目标寻优算法,关键是gbest和pbest的更新机制问题,希望能给大家带来帮助。
  • 多目标粒子群算法matlab源代码.txt

    热门讨论 2013-05-07 20:42:43
    多目标粒子群算法的matlab源代码,并附带有ZDT1等相关检验函数。
  • 本文实例为大家分享了python3单目标粒子群算法的具体代码,供大家参考,具体内容如下 关于PSO的基本知识……就说一下算法流程 1) 初始化粒子群;  随机设置各粒子的位置和速度,默认粒子的初始位置为粒子最优位置...
  • 粒子群算法求解约束多目标优化万能matlab代码

    千次下载 热门讨论 2013-07-02 16:10:16
    粒子群算法 约束多目标 优化 matlab代码
  • 针对元件可靠性为区间值的系统可靠性优化问题, 提出一种区间多目标粒子群优化方法. 首先, 建立问题的区间目标优化模型; 然后, 利用粒子群算法优化该模型, 定义一种不精确Pareto 支配关系, 并给出编码、约束处理、...
  • 粒子群算法MATLAB实例

    2021-04-07 12:28:31
    end end % 便利整个种群,求整个种群最佳的适应度和位置 %% 粒子群迭代 % 更新速度并对速度进行边界处理 % 更新位置并对位置进行边界处理 % 计算新种群各个个体位置的适应度 % 新适应度与个体历史最佳适应度做比较 ...
    %% 清空环境
    clc;clear all;close all;
    %% 设置种群参数
    %   需要自行配置
    sizepop = 500;                    % 初始种群个数
    dim = 30;                          % 空间维数
    ger =700;                       % 最大迭代次数     
    xlimit_max = 600*ones(dim,1);    % 设置位置参数限制(矩阵的形式可以多维)
    xlimit_min = -600*ones(dim,1);
    vlimit_max = 1*ones(dim,1);       % 设置速度限制
    vlimit_min = -1*ones(dim,1);
    c_1 = 0.8;                        % 惯性权重
    c_2 = 0.5;                        % 自我学习因子
    c_3 = 0.5;                        % 群体学习因子 
    

    %% 生成初始种群
    % 首先随机生成初始种群位置
    % 然后随机生成初始种群速度
    % 然后初始化个体历史最佳位置,以及个体历史最佳适应度
    % 然后初始化群体历史最佳位置,以及群体历史最佳适应度

    for i=1:dim
        for j=1:sizepop
            pop_x(i,j) = xlimit_min(i)+(xlimit_max(i) - xlimit_min(i))*rand;
            pop_v(i,j) = vlimit_min(i)+(vlimit_max(i) - vlimit_min(i))*rand;  % 初始种群的速度
        end
    end 
    gbest = pop_x;                                % 每个个体的历史最佳位置
    fitness_gbest = fun(pop_x);                   % 每个个体的历史最佳适应度
    zbest = pop_x(:,1);                           % 种群的历史最佳位置
    fitness_zbest = fitness_gbest(1);             % 种群的历史最佳适应度
    
    for j=1:sizepop
        if fitness_gbest(j) < fitness_zbest       % 如果求最小值,则为<; 如果求最大值,则为>; 
            zbest = pop_x(:,j);
            fitness_zbest=fitness_gbest(j);
        end
    end   % 便利整个种群,求整个种群最佳的适应度和位置
    

    %% 粒子群迭代
    % 更新速度并对速度进行边界处理
    % 更新位置并对位置进行边界处理
    % 计算新种群各个个体位置的适应度
    % 新适应度与个体历史最佳适应度做比较
    % 个体历史最佳适应度与种群历史最佳适应度做比较
    % 再次循环或结束

    
    iter = 1;                        %迭代次数
    record = zeros(ger, 1);          % 记录器
    while iter <= ger
        for j=1:sizepop  % 对每个个体依次处理
            %    更新速度并对速度进行边界处理 
            pop_v(:,j)= c_1 * pop_v(:,j) + c_2*rand*(gbest(:,j)-pop_x(:,j))+c_3*rand*(zbest-pop_x(:,j));% 速度更新
    
            for i=1:dim
                if  pop_v(i,j) > vlimit_max(i)
                    pop_v(i,j) = vlimit_max(i);
                end
                if  pop_v(i,j) < vlimit_min(i)
                    pop_v(i,j) = vlimit_min(i);
                end
            end
            
            %    更新位置并对位置进行边界处理
            pop_x(:,j) = pop_x(:,j) + pop_v(:,j);% 位置更新
            for i=1:dim
                if  pop_x(i,j) > xlimit_max(i)
                    pop_x(i,j) = xlimit_max(i);
                end
                if  pop_x(i,j) < xlimit_min(i)
                    pop_x(i,j) = xlimit_min(i);
                end
            end
    
      
            %    计算新种群各个个体位置的适应度
    
            fitness_pop(j) = fun(pop_x(:,j));                      % 当前个体的适应度
    
            
            %    新适应度与个体历史最佳适应度做比较
            if fitness_pop(j) < fitness_gbest(j)       % 如果求最小值,则为<; 如果求最大值,则为>; 
                gbest(:,j) = pop_x(:,j);               % 更新个体历史最佳位置            
                fitness_gbest(j) = fitness_pop(j);     % 更新个体历史最佳适应度
            end   
            
            %    个体历史最佳适应度与种群历史最佳适应度做比较
            if fitness_gbest(j) < fitness_zbest        % 如果求最小值,则为<; 如果求最大值,则为>; 
                zbest = gbest(:,j);                    % 更新群体历史最佳位置  
                fitness_zbest=fitness_gbest(j);        % 更新群体历史最佳适应度  
            end    
        end
        
        record(iter) = fitness_zbest;%最优值记录
        
        iter = iter+1;
    
    end
    

    %% 迭代结果输出

    plot(record);title('收敛过程')
    disp(['最优值:',num2str(fitness_zbest)]);
    disp('变量取值:');
    disp(zbest);
    

    %% 目标函数
    % 下列函数是一个多峰值的函数,在0向量处取得全局最小值0

    function result = fun(X)
        result = sum(X.^2)/4000 - prod(cos(X./((1:1:30).^0.5)')) + 1;
    end
    
    
    
    展开全文
  • MATLAB 粒子群算法,例题与常用模版

    万次阅读 多人点赞 2018-09-06 18:09:18
    MATLAB 粒子群算法 本文学习自:Particle Swarm Optimization in MATLAB - Yarpiz Video Tutorial 与《精通MATLAB智能算法》 1. 简介: Particle Swarm Optimization ,粒子群优化算法,常用来找到方程...

    本文学习自:Particle Swarm Optimization in MATLAB - Yarpiz Video Tutorial 与《精通MATLAB智能算法》

    1. 简介:

    Particle Swarm Optimization ,粒子群优化算法,常用来找到方程的最优解。

    2. 算法概述:

    每次搜寻都会根据自身经验(自身历史搜寻的最优地点)和种群交流(种群历史搜寻的最优地点)调整自身搜寻方向速度

    3. 算法优势:

    • 相较于传统算法计算速度非常快,全局搜索能力也很强;
    • PSO对于种群大小不十分敏感,所以初始种群往往设为500-1000,不同初值速度影响也不大;
    • 粒子群算法适用于连续函数极值问题,对于非线性、多峰问题均有较强的全局搜索能力。

    4. 算法基本原理

    一个形象的例子:

    A与B两个小粒子初始时在河的两侧,他们想要找到河最深处。如果A某时刻所在位置的深度比B的浅,A就会像B的方向走,反之亦然。 当A到达Global Minimum(全局最小值)时,B会一直向着A前进,直到在optimum solution(全剧最优解)处汇合。
    在这里插入图片描述

    4.1 概述

    从上面的示例中我们得到两个准则,也可以说是每个粒子的必要特性:

    1. Communication : 彼此互相通知
    2. Learning : 不停地学习以达最优解

    数量众多的粒子通过相互的交流与学习,全部粒子最终将汇聚到一点,即问题的解。粒子间相互交流与学习的过程用数学或计算机语言描述为迭代

    迭代的意义在于不断寻找更优的值,从理论上来说,如果我们掌握了一种可以不停寻找到更优解答的方法,通过不停的迭代,我们就能够找到最优的答案

    Learning the concept of better is the main problem that an optimizer should solve. Then an optimizer learns the concept of better, it is able to solve any kind of optimuzation.Because the solution of optimization problem is to find the best one . So if we know what is the better, we actually can discover the concept of best.

    4.2 粒子的基本信息

    回顾粒子群算法概述:
    每次搜寻都会根据自身经验(自身历史搜寻的最优地点)和种群交流(种群历史搜寻的最优地点)调整自身搜寻方向和速度

    我们首先聚焦与粒子本身,或许全部粒子研究起来很复杂,但单个粒子的属性是很简单的。

    首先,每个粒子包含两个基本信息,Position(位置) & Velocity(速度)。
    在粒子群算法的每次迭代中,每个粒子的位置和速度都会更新。

    • 我们用Xi(t)\vec {X_i(t)}记录位置
    • Vi(t)\vec { V_i (t)}记录方向与速度
      在这里插入图片描述
    4.3 粒子的个体极值与全局极值

    回顾粒子群算法概述:
    每次搜寻都会根据自身经验(自身历史搜寻的最优地点)种群交流(种群历史搜寻的最优地点)调整自身搜寻方向和速度。

    仅有上述位置与速度两个信息还不够,我们之前提到过,每一个粒子是会学习的。 每个粒子还拥有下面两个信息(每个信息都是一个向量):

    • 每一个粒子有它自己的记忆,会记住自己的best position , best experience,即个体极值 (personal best), 标记为Pi(t)\vec { P_i (t)}

    • 当前时刻全局的最优解,即全局极值(Common best experience among the members),标记为 gi(t)\vec { g_i (t)}

      总结:PSO初始化为一群随机粒子,然后通过迭代找到最优解。在每一次迭代过程中,粒子通过跟踪两个极值来更新自己,一个是粒子本身所找到的最优解,这个解称为个体极值Pi(t)\vec { P_i (t)};另一个极值是整个种群目前找到的最优解,这个极值是全局极值 gi(t)\vec { g_i (t)}

    在这里插入图片描述

    4.4 找到新位置

    根据平行四边形法则,已知个体极值与整体极值,有了新时刻的速度Vi(t+1)\vec {V_i}(t+1) ,会得到新的位置Xi(t+1)\vec {X_i}(t+1)

    在这里插入图片描述

    状态转移方程:

    vij(t+1)=wvij(t)+c1r1(pij(t)xij(t))+c2r2(gj(t)xij(t))(4-1)\vec {v_{ij}}(t+1) = w\vec{v_{i j}} (t) + c_1r_1(p_{ij} (t) - \vec{x_{ij}}(t))+c_2r_2(g_j(t)-\vec{x_{ij}}(t)) \tag{4-1}

    xij(t+1)=xij(t)+vij(t+1)(4-2)\vec {x_{ij}}(t+1) = \vec{x_{ij}}(t)+\vec{v_{ij}}(t+1) \tag{4-2}

    其中,c1,c2c_1,c_2为学习因子,也称加速常数(acceleration constant);

    r1,r2r_1,r_2,[0,1]范围内的均匀随机数。

    式(1)右边由三部分组成:

    • 第一部分为“惯性(inertia)”或“动量(MOMENTUM)”部分,反映了粒子的运动习惯,代表粒子有维持自己先前速度的趋势。
    • 第二部分为“认知(cognition)”部分,反映了粒子对自身历史经验的记忆,代表粒子由向自身历史最佳位置逼近的趋势。
    • 第三部分为“社会(social)”部分,反映了粒子间协同合作与知识共享的群体历史经验,代表粒子有向群体或领域历史最佳位置逼近的趋势。

    5. 算法的运行参数

    PSO算法一个最大的优点是不需要调节太多的参数,但是算法中少数几个参数却直接影响着算法的性能和收敛性。

    基本粒子群算法有下述7个运行参数需要提前设定:

    1. rr:粒子群算法的种子数,对粒子群算法中种子数值可以随机生成也可以固定位一个初始的数值,要求能涵盖目标函数的范围内。
    2. mm:粒子群群体大小,即群体中所含个体的数量,一般取为20~40。在变两年比较多的时候可以取100以上较大的数。
    3. maxdmax_d:一般为最大迭代次数以最小误差的要求满足的。粒子群算法的最大迭代次数,也是终止条件数。
    4. r1,r2r_1,r_2:两个在[0,1]之间变化的加速度权重系数随机产生。
    5. c1,c2c_1,c_2:加速常数,取随机2左右的值。
    6. ww:惯性权重产生的。
    7. vk,xkv_k,x_k:一个粒子的速度和位移数值,用粒子群算法迭代出每一组的数值。

    6. 算法的基本流程

    1. 初始化粒子群,包括群体规模N,每个粒子的位置xix_i和速度viv_i
    2. 计算吗每一个粒子的适应度值Fit[i]Fit[i]
    3. 计算每个粒子,用它的适应度值Fit[i]Fit[i]和个体极值pbest(i)p_{best}(i)比较,如果Fit[i]>pbest(i)Fit[i]>p_{best}(i),则用Fit[i]Fit[i]替换掉pbest(i)p_{best}(i)
    4. 计算每个粒子,用它的适应度值Fit[i]Fit[i]和全局极值gbest(i)g_{best}(i)比较,如果Fit[i]>gbest(i)Fit[i]>g_{best}(i),则用Fit[i]Fit[i]替换掉gbest(i)g_{best}(i)
    5. 根据式(4-1)和式(4-2)更新粒子的位置xix_i和速度viv_i
    6. 如果满足结束条件(误差足够好或到达最大循环次数)退出,否则返回步骤2.

    7. 手动实现PSO

    function[xm,fv] = PSO(fitness,N,c1,c2,w,M,D)
    % c1,c2:学习因子
    % w:惯性权重
    % M:最大迭代次数
    % D:搜索空间维数
    % N:初始化群体个体数目
    
    
    % 初始化种群的个体(可以在这里限定位置和速度的范围)
    format long;
    for i = 1:N
        for j=1:D
            x(i,j) = randn; % 随机初始化位置
            v(i,j) = randn; % 随即初始化速度
        end
    end
    
    
    % 先计算各个粒子的适应度,并初始化pi和pg
    for i=1:N
        p(i) = fitness(x(i,:));
        y(i,:) = x(i,:);
    end 
    pg = x(N,:);  % pg为全局最优
    for i=1:(N-1)
        if(fitness(x(i,:))<fitness(pg))
            pg = x(i,:);
        end
    end
    
    
    % 进入主要循环,按照公式依次迭代,直到满足精度要求
    for t=1:M
        for i=1:N  % 更新速度、位移
            v(i,:)=w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:));
            x(i,:)=x(i,:)+v(i,:);
            if fitness(x(i,:)) < p(i)
                p(i)=fitness(x(i,:));
                y(i,:)=x(i,:);
            end
            if p(i) < fitness(pg)
                pg=y(i,:);
            end
        end
        Pbest(t)=fitness(pg);
    end
    
    
    % 输出结果
    disp('目标函数取最小值时的自变量:')
    xm=pg';
    disp('目标函数的最小值为:')
    fv=fitness(pg);
    
    例1:求解下列函数的最小值:

    f(x)=i=130xi2+xi6f(x) = \sum^{30}_{i=1}x_i^2+x_i-6

    function F=fitness(x)
    F = 0;
    for i = 1:30
        F = F+x(i)^2+x(i)-6;
    end
    

    输入:

    x = zeros(1,30);
    [xm1,fv1] = PSO(@fitness,50,1.5,2.5,0.5,100,30)
    

    后记:拜托 还有人问显示fitness未定义怎么办,找不到输出结果怎么办?? 软件入门都没搞定就不要急于求成好吗?
    补入门知识:把手动实现PSO的代码保存为PSO.m,把function F=fitness(x)和后面4行代码保存为fitness.m。 然后再在命令行输入内容。

    9. 自适应权重法

    function[xm,fv] = PSO_adaptation(fitness,N,c1,c2,wmax,wmin,M,D)
    % c1,c2:学习因子
    % wmax:惯性权重最大值
    % wmin:惯性权重最小值
    % M:最大迭代次数
    % D:搜索空间维数
    % N:初始化群体个体数目
    
    
    % 初始化种群的个体(可以在这里限定位置和速度的范围)
    for i = 1:N
        for j=1:D
            x(i,j) = randn; % 随机初始化位置
            v(i,j) = randn; % 随即初始化速度
        end
    end
    
    
    %先计算各个粒子的适应度,并初始化个体最优解pi和整体最优解pg %
    %初始化pi %
    for i = 1:N
        p(i) = fitness(x(i,:)) ;
        y(i,:) = x(i,:) ;
    end
    %初始化pg %
    pg = x(N,:) ;
    %得到初始的全局最优pg %
    for i = 1:(N-1)
        if fitness(x(i,:)) < fitness(pg)
            pg = x(i,:) ;
        end
    end
     
    %主循环函数,进行迭代,直到达到精度的要求 %
    for t = 1:M
        for j = 1:N
            fv(j) = fitness(x(j,:)) ;
        end
        fvag = sum(fv)/N ;
        fmin = min(fv);
        for i = 1:N    %更新函数,其中v是速度向量,x为位置,i为迭代特征
            if fv(i) <= fvag
                w = wmin+(fv(i)-fmin)*(wmax-wmin)/(fvag-fmin) ;   %依据早熟收敛程度和适应度值进行调整
            else
                w = wmax ;
            end
            v(i,:) = w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:)) ;
            x(i,:) = x(i,:)+v(i,:) ;
            if fitness(x(i,:)) < p(i)
                p(i) = fitness(x(i,:)) ;
                y(i,:) = x(i,:) ;
            end
            if p(i) < fitness(pg)
                pg = y(i,:) ;
            end
        end
         Pbest(t) = fitness(pg) ;
    end
     
    %给出最后的计算结果 %
    xm = pg' ;
    fv = fitness(pg) ;
     
    plot(Pbest)
    xlabel('进化次数') ;
    ylabel('适应度值') ;
    

    例2:用自适应权重法求解函数

    y=((sin(x12+x22))2cos(x12+x22)+1)((1+0.1×(x12+x22))2)0.7\large{y = \frac {((sin(x_1^2+x_2^2))^2-cos(x_1^2+x_2^2)+1)} {((1+0.1\times (x_1^2+x_2^2))^2)-0.7}}

    其中,粒子数为50,学习因子均为2,惯性权重取值[0.6,0.8],迭代步数为100.

    建立目标函数:

    function y = AdaptFunc(x)
        y = ((sin(x(1)^2+x(2)^2))^2-cos(x(1)^2+x(2)^2)+1)/((1+0.1*(x(1)^2+x(2)^2))^2)-0.7;
    end
    

    运行:

    [xm,fv] = PSO_adaptation(@AdaptFunc,50,2,2,0.8,0.6,100,2)
    

    在这里插入图片描述

    10.线性递减权重法

     function [ xm,fv ] = PSO_lin(fitness,N,c1,c2,wmax,wmin,M,D)
    format long ;
    %给定初始化条件
    % fitness:适应度函数
    % N:       初始化种群数目
    % c1:      个体最优化学习因子
    % c2:      整体最优化学习因子
    % wmax:    惯性权重最大值
    % wmin:    惯性权重最小值
    % M:       最大迭代次数      
    % D:       搜索空间的维数
    % xm:      最佳个体
    % fv:      适应度值
     
    %初始化种群个体%
    for i = 1:N
        for j = 1:D
            x(i,j) = randn ;  %随机初始化位置
            v(i,j) = randn ;  %随机初始化速度
        end
    end
     
    %先计算各个粒子的适应度,并初始化个体最优解pi和整体最优解pg %
    %初始化pi %
    for i = 1:N
        p(i) = fitness(x(i,:)) ;
        y(i,:) = x(i,:) ;
    end
    %初始化pg %
    pg = x(N,:) ;
    %得到初始的全局最优pg %
    for i = 1:(N-1)
        if fitness(x(i,:)) < fitness(pg)
            pg = x(i,:) ;
        end
    end
     
    %主循环函数,进行迭代,直到达到精度的要求 %
    for t = 1:M
        for i = 1:N    %更新函数,其中v是速度向量,x为位置,i为迭代特征
            w = wmax-(t-1)*(wmax-wmin)/(M-1)
            v(i,:) = w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:)) ;
            x(i,:) = x(i,:)+v(i,:) ;
            if fitness(x(i,:)) < p(i)
                p(i) = fitness(x(i,:)) ;
                y(i,:) = x(i,:) ;
            end
            if p(i) < fitness(pg)
                pg = y(i,:) ;
            end
        end
        Pbest(t) = fitness(pg) ;
    end
     
    %给出最后的计算结果 %
    xm = pg' ;
    fv = fitness(pg) ;
    

    11. 基于杂交(遗传算法)的算法

     function [ xm,fv ] = PSO_breed(fitness,N,c1,c2,w,bc,bs,M,D)
    format long ;
    %给定初始化条件
    % fitness:适应度函数
    % N:       初始化种群数目
    % c1:      个体最优化学习因子
    % c2:      整体最优化学习因子
    % w:       惯性权重
    % bc:      杂交概率
    % bs:      杂交池的大小比率
    % M:       最大迭代次数      
    % D:       搜索空间的维数
    % xm:      最佳个体
    % fv:      适应度值
     
    %初始化种群个体%
    for i = 1:N
        for j = 1:D
            x(i,j) = randn ;  %随机初始化位置
            v(i,j) = randn ;  %随机初始化速度
        end
    end
     
    %先计算各个粒子的适应度,并初始化个体最优解pi和整体最优解pg %
    %初始化pi %
    for i = 1:N
        p(i) = fitness(x(i,:)) ;
        y(i,:) = x(i,:) ;
    end
    %初始化pg %
    pg = x(N,:) ;
    %得到初始的全局最优pg %
    for i = 1:(N-1)
        if fitness(x(i,:)) < fitness(pg)
            pg = x(i,:) ;
        end
    end
     
    %主循环函数,进行迭代,直到达到精度的要求 %
    for t = 1:M
        for i = 1:N    %更新函数,其中v是速度向量,x为位置,i为迭代特征
            v(i,:) = w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:)) ;
            x(i,:) = x(i,:)+v(i,:) ;
            if fitness(x(i,:)) < p(i)
                p(i) = fitness(x(i,:)) ;
                y(i,:) = x(i,:) ;
            end
            if p(i) < fitness(pg)
                pg = y(i,:) ;
            end
            r1 = rand() ;
            if r1 < bc
                numPool = round(bs*N) ;    %杂交池中随机选取numPool个种群%
                PoolX = x(1:numPool,:) ;   %杂交池中的初始杂交父辈位置%
                PoolVX = v(1:numPool,:) ;  %杂交池中的初始杂交父辈速度%
                for i = 1:numPool
                    seed1 = floor(rand()*(numPool-1))+1 ;   %得到速度和位置的初始种子%
                    seed2 = floor(rand()*(numPool-1))+1 ;
                    pb = rand() ;
                    childxl(i,:) = pb*PoolX(seed1,:)+(1-pb)*PoolX(seed2,:) ;   %子代的速度和位置计算
                    childvl(i,:) = (pb*PoolVX(seed1,:)+pb*PoolVX(seed2,:))*norm(pb*PoolVX(seed1,:))/norm(pb*PoolVX(seed1,:)+pb*PoolVX(seed2,:)) ;
                end
                x(1:numPool,:) = childxl ;
                v(1:numPool,:) = childvl ;
            end
        end
    end
     
    %给出最后的计算结果 %
    xm = pg' ;
    fv = fitness(pg) ;
    

    12. 基于自然选择

     function [xm,fv]=PSO_nature(fitness,N,c1,c2,w,M,D)
    % fitness:待优化的目标函数;
    % N:粒子数目;
    % c1:学习因子1;
    % c2:学习因子2;
    % w:惯性权重;
    % M:最大迭代次数;
    % D:自变量的个数;
    % xm:目标函数取最小值时的自变量值;
    % fv:目标函数的最小值。
    format long;
    for i=1:N
        for j=1:D
            x(i,j)=randn;   %随机初始化位置
            v(i,j)=randn;   %随机初始化速度
        end
    end
    for i=1:N
        p(i)=fitness(x(i,:));
        y(i,:)=x(i,:);
    end
    pg=x(N,:);    %pg为全局最优
    for i=1:(N-1)
        if fitness(x(i,:))
            pg=x(i,:);
        end
    end
    for t=1:M
        for i=1:N   %速度、位移更新
            v(i,:)=w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:));
            x(i,:)=x(i,:)+v(i,:);
            fx(i)=fitness(x(i,:));
            if fx(i)
                p(i)=fx(i);
                y(i,:)=x(i,:);
            end
            if p(i)
                pg=y(i,:);
            end
        end
        [sortf,sortx]=sort(fx);     %将所有的粒子按适应值排序
        exIndex=round((N-1)/2);
        x(sortx((N-exIndex+1):N))=x(sortx(1:exIndex));%将最好的一半粒子的位置替换掉最差的一半
        v(sortx((N-exIndex+1):N))=v(sortx(1:exIndex));%将最好的一半粒子的速度替换掉最差的一半
    end
    xm=pg';
    fv=fitness(pg);
    

    13.基于模拟退火

    function [xm,fv]=PSO_lamda(fitness,N,c1,c2,lamda,M,D)
    % fitness:待优化的目标函数;
    % N:粒子数目;
    % c1:学习因子1;
    % c2:学习因子2;
    % lamda:退火常数;
    % M:最大迭代次数;
    % D:自变量的个数;
    % xm:目标函数取最小值时的自变量值;
    % fv:目标函数的最小值。
    format long;
    for i=1:N
        for j=1:D
            x(i,j)=randn;   %随机初始化位置
            v(i,j)=randn;   %随机初始化速度
        end
    end
    for i=1:N
        p(i)=fitness(x(i,:));
        y(i,:)=x(i,:);
    end
    pg=x(N,:);    %pg为全局最优
    for i=1:(N-1)
        if fitness(x(i,:))
            pg=x(i,:);
        end
    end
    T=-fitness(pg)/log(0.2);    %初始温度
    for t=1:M
        groupFit=fitness(pg);
        for i=1:N           %当前温度下各个pi的适应值
            Tfit(i)=exp(-(p(i)-groupFit)/T);
        end
        SumTfit=sum(Tfit);
        Tfit=Tfit/SumTfit;
        pBet=rand();
        for i=1:N   %用轮盘赌策略确定全局最优的某个替代值
            ComFit(i)=sum(Tfit(1:i));
            if pBet<=ComFit(i)
                pg_plus=x(i,:);
                break;
            end
        end
        C=c1+c2;
       ksi=2/abs(2-C-sqrt(C^2-4*C));  %速度压缩因子
       for i=1:N
           v(i,:)=ksi*(v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg_plus-x(i,:)));
           x(i,:)=x(i,:)+v(i,:);
           if fitness(x(i,:))
               p(i)=fitness(x(i,:));
               y(i,:)=x(i,:);
           end
           if p(i)
               pg=y(i,:);
           end
       end
       T=T*lamda;
       Pbest(t) = fitness(pg) ;
    end   
    xm=pg';
    fv=fitness(pg);
    

    14. MATLAB粒子群工具箱

    添加工具箱的具体步骤就不在这里说了,网上有很多。

    例3:计算如下函数的最小值:

    z=0.4(x2)2+0.3(y4)20.7,x[40,40],y[40,40]z = 0.4*(x-2)^2 + 0.3 * (y-4)^2 -0.7, x\in[-40,40] , y\in[-40,40]

    • 定义待优化的MATLAB代码:

      function z = pso_func(in)
      n = size(in);
      x = in(:,1);
      y = in(:,2);
      nx = n(1);
      for i=1:nx
          temp = 0.4*(x(i)-2)^2+0.3*(y(i)-4)^2-0.7;
          z(i,:) = temp;
      end
      
    • 调用PSO算法的核心函数:pso_Trelea_vectorized

      clear
      clc
      x_range = [-40,40];
      y_range = [-40,40];
      range = [x_range;y_range];
      Max_V = 0.2*(range(:,2)-range(:,1));
      n = 2;
      pso_Trelea_vectorized('pso_func',n,Max_V,range)
      

    执行即可得到答案。

    在PSO算法函数pso_Trelea_vectorized173行中,PSO参数设置如下:

    Pdef = [100 2000 24 2 2 0.9 0.4 1500 1e-25 250 NaN 0 1];
    
    • 100:MATLAB命令窗口进行显示的间隔数
    • 2000:最大迭代次数
    • 24:初始化种子数,种子数越多,越有可能收敛到全局最优值,但算法收敛速度慢
    • 2:算法的加速度参数,分别影响局部最优值和全局最优值,一般不需要修改
    • 0.9和0.4为初始时刻和收敛时刻的加权值,一般不需要修改
    • 1500:迭代次数超过此值时,加权值取其最小
    • 1e-25:算法终止条件之一,当两次迭代中对应的种群最优值小于此阈值时,算法停止
    • 250:算法终止条件之一,取NaN时表示为非约束下的优化问题(即没有附加约束方程)
    • 0:制定采用何种PSO类型,0表示通常的PSO算法
    • 1:说明是否指定种子,0表示随机产生种子,1表示用户自行产生种子
    展开全文
  • 1、基本粒子群算法 假设在一个 D 维的目标搜索空间中,有 N 个粒子组成一个群落,其中第i 个 粒子表示为一个 D 维的向量: $$ X_i=(x_{i1},x_{i2}, \cdots ,x_{iD}), \quad i=1,2, \cdots ,N \quad \text {(1)} $$...
  • A structure MATLAB implementation of MOPSO for Evolutionary Multi-Objective Optimization A structured MATLAB implementation of MOEA/D for Evolutionary Multi-Objective Optimization
  • 粒子群算法-讲解+实例

    千次阅读 2019-07-11 21:44:56
    今天给大家讲解的时粒子群算法,首先先牢记以下的基本公式: 1.简单的来讲,粒子群算法是这个样子,当你在一个全解的范围内,想要去找最优解,可以先派出像四面八方而去的小兵去搜索,他们向四面八方去探索时在坚守...
  • 一、粒子群算法理论粒子群算法来源于鸟类集体活动的规律性,进而利用群体智能建立简化模型。它模拟的是鸟类的觅食行为,将求解问题的空间比作鸟类飞行的时间,每只鸟抽象成没有体积和质量的粒子,来表征一个问题的...
  • MOPSO源代码,双目标,无约束,相对简单,适合初学者学习用
  • 为了进一步增加算法多样性,该算法将差分进化策略引入到多目标粒子群算法中;为了避免粒子飞行速度过快,陷入局部最优解,加入一种速度控制策略。通过无约束的ZDT系列和三个有约束的基准测试函数进行测试,并与其他...
  • 混合粒子群算法将全局粒子群算法与局部粒子群算法结合,其速度更新采用公式: 其中G(k+1)是全局版本的速度更新公式,而L(k+1)是局部版本的速度更新公式,混合粒子群算法采用H(k+1)的公式。 位置更新...
  • 粒子群算法原理

    2020-12-22 13:53:10
    粒子群算法实例计算,必须弄懂!
  • Matlab粒子群算法(PSO)优化程序——经典实例

    万次阅读 多人点赞 2019-03-31 10:29:47
    粒子群算法( Particle Swarm Optimization, PSO)最早是由Eberhart和Kennedy于1995年提出,它的基本概念源于对鸟群觅食行为的研究。鸟群中有个体和群体,个体和群体的信息是可以互通的。个体在随机搜寻食物的过程中...
  • 粒子群算法详解

    万次阅读 多人点赞 2018-08-20 10:38:49
    粒子群算法(particle swarm optimization,PSO)是计算智能领域中的一种生物启发式方法,属于群体智能优化算法的一种,常见的群体智能优化算法主要有如下几类:  (1)蚁群算法(Ant Colony Optimization,简称ACO...
  • 内含5元3目标数据样本,代码可在MATLAB上直接运行查看结果,代价函数可仿照代码中的对输入变量的形式进行更改,欢迎咨询交流
  • 设计出基于密集距离的多目标粒子群优化算法( CMPSO) ,该算法根据密集距离大小按轮盘赌方式为每个粒子从外部档案选取全局最好位置并采用基于密集距离的方法对外部档案进行维护.将算法应用于 3个复杂的测试实例,并与...
  • 将自然界的物种动态模型引入到遗传算法当中,反映出物种的真实进化状态,开发了基于演化设计的遗传算法算法采用自适应策略克服了确定交叉和变异概率值的问题,利用...对接实例表明,算法能有效应用于分子对接问题中。
  • 粒子群算法(PSO)偏应用的简要总结。包括算法的流程和个人对于算法搜索机制、设计思路的理解。
  • 对于粒子群算法的一些理解 &amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;最近做大创开始学习遗传算法,粒子群算法等,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 900
精华内容 360
关键字:

多目标粒子群算法实例