精华内容
下载资源
问答
  • 离散二进制粒子群算法 离散二进制粒子群算法分析 --入党程序 DOI:10.13232/j.ki.jnju.xx.05.002 第卷 第期 年月 南京大学学报自然科学 离散二进制粒子群算法分析 刘建华杨荣华孙水华 福建工程学院计算机与信息科学系...
  • 二进制粒子群算法

    2019-03-30 09:28:46
    %------初始化种群的个体------------%------先计算各个粒子的适应度,并初始化Pi和Pg----------------------
  • 基于二进制粒子群算法的配电网故障区间定位,周睿,蔡中勤,针对配电网中FTU上传的故障信息可能有畸变的问题,本文提出将二进制粒子群算法应用于配电网故障区间定位问题,以期一方面解决故障
  • 粒子群算法(Particle Swarm Optimization,PSO)主要用优化计算实值的连续性问题,而离散二进制粒子群算法(Binary Particle Swarm Optimization,BPSO)则用来优化离散空间问题,它扩展了PSO算法的应用,现已广泛...
  • 针对二进制粒子群算法易陷入局部最优的缺点,文中提出了一种基于次优活跃点的二进制粒子群改进算法,引入全局次优极值对粒子速度更新的影响.在具体应用中,算法参数设置的好坏直接影响算法的优化性能.文中在改进...
  • [Matlab]离散二进制粒子群算法(BPSO )解决背包问题什么是离散二进制粒子群算法(BPSO )描述离散二进制粒子群算法(BPSO )步骤背包问题描述解决思路函数设计targetPackage.mpsoForBackpack.m图像 什么是离散...

    什么是离散二进制粒子群算法(BPSO )

    文章参考: 【PSO】离散粒子群算法(DPSO)和离散二进制粒子群算法(BPSO )

    描述

    离散二进制粒子群算法(Discrete Binary Particle Swarm Optimization Algorithm, BPSO)最初由J.Kennedy和R.C.Eberhart在1997年设计;
    PSO主要优化连续实值问题,BPSO主要优化离散空间约束问题;
    BPSO是在离散粒子群算法基础上,约定位置向量、速度向量均由0、1值构成;
    BPSO有很强全局搜索能力,但不能收敛于全局最优值,且随着算法迭代搜索随机性越来越强,缺乏后期的局部搜索能力;

    离散二进制粒子群算法(BPSO )步骤

    初始化粒子位置:按一定策略,生成二进制编码;
    速度更新公式:速度 x 惯性权重 + (个体最优位置 - 当前位置)x 学习因子1 x 随机数 + (全局最优位置 - 当前位置)x 学习因子2 x 随机数。

    位置更新公式:概率映射方式,采用sigmoid函数将速度映射到 [0, 1] 区间作为概率,这个概率就是粒子下一步取值为1的概率;

    位置变化的绝对概率:当前位置为0变化为1,当前为1变化为0,这二者被称为绝对变化;概率表示为:

    背包问题

    描述

    有N件物品和一个容量为W的背包。第i件物品的体积是volume[i],价值是value[i]。求解将哪些物品装入背包可使价值总和最大同时又不能超过背包的总容积。

    其中:

    • N = 10;
    • W= 300;
    • volume=[95 75 23 73 50 22 6 57 89 98];
    • value=[89 59 19 43 100 72 44 16 7 64];

    解决思路

    对于这个实际问题时,首先要解决的问题是编码:对每个物品,我们只有拿取或者不拿两种选择,不能选择装入某物品的一部分,也不能装入同一物品多次,也就是说这是一个离散优化问题,种群中的个体采用二进制编码,用0表示不选择该件物品,1表示选择该件物品。

    函数设计

    targetPackage.m

    function fitness = targetPackage(x,indNum)
        
        volume=[95 75 23 73 50 22 6 57 89 98];        %物品体积
        value=[89 59 19 43 100 72 44 16 7 64];          %物品价值
        Weight=300;  %背包重量
        a = zeros(indNum,1);
        for i=1:indNum
            a(i,1) = volume*x(:,i);
        end
        %超过总重量的个体的适应度值都视为0
        k = find(volume*x<Weight);
        fitness=zeros(indNum,1);
        for j=1:size(k,2)
            fitness(k(j),1) = value*x(:,k(j));
        end   
    end
    

    其中 indNum 表示输入的个体数量

    psoForBackpack.m

    clc
    clear
    
    % 初始化种群
    % IndN = 50; 
    narvs = 10;
    n = 100; 
    x_ub = 3;
    x_lb = -3;
    
    vmax = 1.2; %粒子的最大速度
    w = 0.9;  % 惯性权重
    c1 = 2;  % 每个粒子的个体学习因子,也称为个体加速常数
    c2 = 2;  % 每个粒子的社会学习因子,也称为社会加速常数
    
    %初始种群
    x = randsrc(n,narvs,[0,1;0.5,0.5]);
    
    v = -vmax + 2*vmax .* rand(n,narvs);
    
    %计算种群适应度
    fitness = targetPackage(x',n);
    pbest = x;   % 初始化这n个粒子迄今为止找到的最佳位置(是一个n*narvs的向量)
    ind = find(fitness == max(fitness), 1);  % 找到适应度最大的那个粒子的下标
    gbest = x(ind,:);  % 定义所有粒子迄今为止找到的最佳位置(是一个1*narvs的向量)
    
    K=100;  %迭代次数
    fitnessbest=zeros(K,1); %保存每一代的函数值
    best=0;
    bestOne = zeros(1,10);
    
    for t = 1:K    
        for i = 1:n
            v(i,:) = w*v(i,:) + c1*rand(1)*(pbest(i,:) - x(i,:)) + c2*rand(1)*(gbest - x(i,:));
            % 判断速度是否超过限制了(还可以取模)
            for j = 1:narvs
                if v(i,j) < -vmax
                    v(i,j) = -vmax;
                elseif v(i,j) > vmax
                    v(i,j) = vmax;
                end
            end
            %sigmoid函数将例子的速度映射到0-1之间
            vs(i,:)=1./(1+exp(-v(i,:))); 
            for j = 1:narvs
                if rand < vs(i,j)
                    x(i,j) = 1;
                else
                    x(i,j) = 0;
                end
            end
            
            fit = targetPackage(x(i,:)',1);  % 重新计算第i个粒子的适应度
            if fit > targetPackage(pbest(i,:)',1)   % 如果第i个粒子的适应度大于这个粒子迄今为止找到的最佳位置对应的适应度
                pbest(i,:) = x(i,:);   % 那就更新第i个粒子迄今为止找到的最佳位置
            end
            if  fit > targetPackage(gbest',1)  % 如果第i个粒子的适应度大于所有的粒子迄今为止找到的最佳位置对应的适应度
                gbest = pbest(i,:);   % 那就更新所有粒子迄今为止找到的最佳位置
            end
        end
        h = targetPackage(gbest',1);    
        if h>best         
            best = h;  
            bestOne = gbest; 
        end
        fitnessbest(t,1)=best;
    end
    bestOne
    plot(1:K,fitnessbest,'-');
    grid on;
    grid minor;
    

    图像

    在这里插入图片描述

    展开全文
  • 为更高效地完成频谱分配,对二进制粒子群算法的速度和位置更新策略在离散域作了全新诠释,提出了二进制离散速度的概念,并以其作为决定位置参数变或不变的异或因子,更好地平衡了算法的开发性能与探索性能。...
  • 仿真结果表明,与HS-Tree、Boolean Algebra方法、遗传算法等算法相比,离散二进制粒子群算法搜索效率更高,可节约1 / 3 ~ 1 / 2的搜索时间,并且可以避免当问题规模较大时出现内存溢出问题。
  • 为此,研究了一种全新的基于栅格法的机器人路径规划二进制粒子群算法。首先用栅格法描述机器人工作环境,在此基础上,将机器人路径表示为粒子位置的二进制编码,并以路径长度为适应值,产生初始种群后,再对粒子位置...
  • 建立了多目标多约束的独立微网系统优化运行数学模型,以经济运行成本...将二进制粒子群算法与混沌优化算法相结合求解模型。典型微网模型仿真结果验证了所提算法与模型的正确性,采用所提方法可确保微网的优化经济运行。
  • 1. 什么是离散粒子群算法? 普通粒子群算法(Particle Swarm Optimization Algorithm,PSO)的粒子初始位置、更新速度都是连续函数,与之对应,位置和速度更新均为离散值的算法是离散PSO算法(Discrete Particle ...

     

    1. 什么是离散粒子群算法?

    普通粒子群算法(Particle Swarm Optimization Algorithm,PSO)的粒子初始位置、更新速度都是连续函数,与之对应,位置和速度更新均为离散值的算法是离散PSO算法(Discrete Particle Swarm Optimization Algorithm, DPSO);

    一般就是在跟新粒子位置后,对粒子进行离散点处理;

    比如:你的粒子的离散点是0到9的整数。那么对每个粒子更新位置后,比如是在(0,1)范围内的随机数。那么就(0,0.1)范围令其值为0;(0.1,0.2)范围令其值为1;............(0.9.1)范围令其值为9。当然初始位置值也需要这样处理。参考

    2. 什么是离散二进制粒子群算法?

    离散二进制粒子群算法(Discrete Binary Particle Swarm Optimization Algorithm, BPSO)最初由J.Kennedy和R.C.Eberhart在1997年设计;

    PSO主要优化连续实值问题,BPSO主要优化离散空间约束问题;

    BPSO是在离散粒子群算法基础上,约定位置向量、速度向量均由0、1值构成;

    BPSO有很强全局搜索能力,但不能收敛于全局最优值,且随着算法迭代搜索随机性越来越强,缺乏后期的局部搜索能力;

    3. 离散二进制粒子群算法步骤

    初始化粒子位置:按一定策略,生成二进制编码;

    速度更新公式:速度 x 惯性权重 + (个体最优位置 - 当前位置)x 学习因子1 x 随机数 + (全局最优位置 - 当前位置)x 学习因子2 x 随机数

    位置更新公式:概率映射方式,采用sigmoid函数将速度映射到 [0, 1] 区间作为概率,这个概率就是粒子下一步取值为1的概率;

    位置变化的绝对概率:当前位置为0变化为1,当前为1变化为0,这二者被称为绝对变化;概率表示为:

    其中S(Vid)表示粒子轨迹当前为1的概率,则1- S(Vid) 表示当前为0的概率;如果当前为1,则改变的概率为1- S(Vid) ,如果当前为0,则改变概率为 S(Vid)。结合(2)式可以得到如下方程:

    图形表示为

    其中,最大改变概率不超过0.25;

    随后更严谨的分析加入了前后时间的影响,位置改变概率变为:

    公式(8)也就是第8代位置改变的概率,与两代的速度有关;

    即,最大改变概率不超过0.5

    4. 实验步骤

    参考:离散二进制粒子群算法分析

    第一步:确定测试的基准函数;

    第二步:测试某个粒子的平均速度迭代变化,某个粒子取1的平均概率迭代变化;某个粒子改变概率迭代变化;某个粒子到最优粒子距离的迭代变化;

    第三步:提出改进的粒子群算法,改进点为概率函数;按照第二步进行实验;

    第四步:提出改进的基于遗传算法的二进制PSO算法;进行显著性分析,测试最小平均适应度值和标准方差;

     

    参考文献

    刘建华, 杨荣华, 孙水华. 离散二进制粒子群算法分析[J]. 南京大学学报(自然科学), 2011, 47(5):504-514.

     

     

     

    展开全文
  • 希望懂这方面知识的能帮一下我,具体分析希望能QQ或者微信聊,我在做一个二进制粒子群算法和加入变异算子的改良二进制粒子群算法以及决策树分类,特征提取相关结果比较分类正确率,原理我都懂,就是细节和代码那方面...
  • 讲述 离散二进制原理 ,以背包问题具体讲解离散二进制粒子群。代码语言:python、MATLAB。

    算法原理

    粒子群算法原理 见链接
    粒子群算法求解无约束优化问题 源码实现
    粒子群算法求解带约束优化问题 源码实现

    离散粒子群
          基本的粒子群算法是在连续域中搜索函数极值的有力工具,在此之后,提出了离散二进制粒子群,将离散问题空间映射到连续粒子运动空间,并适当修改粒子群算法来求解,在计算上仍保留经典粒子群算法速度-位置更新运算法则,粒子在状态空间的取值和变化只限于0和1两个值,而速度的每一维Vij代表位置每一位xij的取值为1的可能性,,因此在连续粒子群中的vij更新公式仍保持不变,但是Pbest和Gbest只在【0,1】的取值,其位置更新等式为:

          式中:r是0-1之间的随机数。

          爱学习,爱玉酱。下面开始讲解算例。

    背包问题

          背包问题。有N件物品和一个容量为V的背包。第i件物品的体积是c(i),价值是w(i)。求解将哪些物品放入背包可使物品的体积总和不超过背包的容量,且价值总和最大。假设物品数量为10,背包的容量为300。每件物品的体积为[95,75,23, 73,50, 22,6,57,89, 98], 价值为[89, 59,19, 43,100,72,44,16,7, 64]。

    python求解

    import numpy as np
    import matplotlib.pyplot as plt
    from tqdm import tqdm#进度条设置
    import matplotlib.pyplot as plt
    import matplotlib; matplotlib.use('TkAgg')
    from pylab import *
    mpl.rcParams['font.sans-serif'] = ['SimHei']  # 指定默认字体
    mpl.rcParams['axes.unicode_minus'] = False  # 解决保存图像是负号'-'显示为方块的问题
    
    class BackPack(object):
        def __init__(self):
            self.Weight = [95,75,23,73,50,22,6,57,89,98]  # 物品体积
            self.Value = [89, 59, 19, 43, 100, 72, 44, 16, 7, 64]  # 物品价值
            self.N = 100  # 群体粒子个数
            self.D = len(self.Weight)  # 粒子维数
            self.T = 100  # 最大迭代次数
            self.c1 = 1.5  # 学习因子1
            self.c2 = 1.5  # 学习因子2
            self.w = 1  # 惯性因子,一般取1
            self.V_max = 10  # 速度最大值
            self.V_min = -10  # 速度最小值
            self.Weight_max = 300  # 背包容量
            self.afa = 10  # 惩罚系数
            self.G=100 #迭代次数
    
        #初始化种群
        def init_x(self):
            """
            :return: 随机生成的种群(二维list)
            """
            X = np.random.choice([0, 1], size=(self.N, self.D))
            return X
        #初始化速度
        def init_v(self):
            """
            :return: 速度
            """
            V = np.random.random(size=(self.N, self.D))  ##10维
            return V
    
    
        # 适应度值
        def fitness_func(self,X):
            """
            :param X: 种群
            :return:
            """
            """计算粒子的的适应度值,也就是目标函数值,X 的维度是 size * 10 """
            size = np.shape(X)[0] #种群个数
            result = np.zeros((size, 1))
            for i in range(size):  # 遍历每一个粒子
                fit = sum(X[i] * self.Value)  # 物品价值
                TotalSize = sum(X[i] * self.Weight)  # 物品重量
                if TotalSize <= self.Weight_max:  # 如果小于限制重量
                    fit = fit
                    result[i] = fit
                else:
                    #fit = fit - self.afa * (TotalSize - self.Weight_max)  # 对fit进行惩罚
                    fit=0
                    result[i] = fit
            return result  # 我们要求result越大
    
        # 速度更新公式
        def velocity_update(self,V, X, pbest, gbest):
            """
            根据速度更新公式更新每个粒子的速度
             种群size=100
            :param V: 粒子当前的速度矩阵,size*10 的矩阵
            :param X: 粒子当前的位置矩阵,size*10 的矩阵
            :param pbest: 每个粒子历史最优位置,size*10 的矩阵
            :param gbest: 种群历史最优位置,1*10 的矩阵
            """
            r1 = np.random.random((self.N, 1)) #(粒子个数,1)
            r2 = np.random.random((self.N, 1))
            V = self.w * V + self.c1 * r1 * (pbest - X) + self.c2 * r2 * (gbest - X)  # 直接对照公式写就好了
            # 防止越界处理
            V[V < self.V_min] = np.random.random() * (self.V_max - self.V_min) + self.V_min
            V[V > self.V_max] = np.random.random() * (self.V_max - self.V_min) +self.V_min
            return V
    
        # 位置更新公式
        def position_update(self,X, V):
            """
            根据公式更新粒子的位置
            :param X: 粒子当前的位置矩阵,维度是 size*10
            :param V: 粒子当前的速度举着,维度是 size*10
            return  更新后的种群
          """
    
            for i in range(self.N):  # 遍历每一个粒子
                # 修改速度为sigmoid形式
    
                V[i, :] = 1. / (1 + np.exp(-np.array(V[i, :])))
                for j in range(self.D):  # 遍历粒子中的每一个元素
                    rand = np.random.random()  # 生成 0-1之间的随机数
                    if V[i, j] > rand:
                        X[i, j] = 1
                    else:
                        X[i, j] = 0
                #对当前个体进行限制,放在超重
                while np.sum(X[i]*self.Weight)>self.Weight_max:#如果当前粒子超重
                    X[i]=np.random.choice([0, 1], size=(1, self.D))
            return X
    
        def update_pbest(self,X, fitness, pbest, pbestfitness, m):
            """
            更新个体最优
            :param X: 当前种群
            :param fitness: 当前每个粒子的适应度
            :param pbest: 更新前的个体最优解
            :param pbestfitness: 更新前的个体最优适应度
            :param m: 粒子数量
            :return: 更新后的个体最优解、个体最优适应度
            """
    
            for i in range(m):
                if fitness[i] > pbestfitness[i]:
                    pbest[i] = X[i]
                    pbestfitness[i] = fitness[i]
            return pbest, pbestfitness
    
        def update_gbest(self,pbest, pbestfitness, gbest, gbestfitness, m):
            """
            更新全局最优解
            :param pbest: 粒子群
            :param pbestfitness: 个体适应度(个体最优)
            :param gbest: 全局最优解
            :param gbestfitness: 全局最优解
            :param m: 粒子数量
            :return: gbest全局最优,g对应的全局最优解
            """
            for i in range(m):
                if pbestfitness[i] > gbestfitness:
                    gbest = pbest[i]
                    gbestfitness = pbestfitness[i]
            return gbest, gbestfitness
    
    
        def main(self):
            fitneess_value_list = []  # 记录每次迭代过程中的种群适应度值变化
            x = self.init_x()  # 初始化x
            v = self.init_v()  # 初始化v
            # 计算种群各个粒子的初始适应度值
            p_fitness = self.fitness_func(x)
            # 计算种群的初始最优适应度值
            g_fitness = p_fitness.max()
            # 讲添加到记录中
            fitneess_value_list.append(g_fitness)
            # 初始的个体最优位置和种群最优位置
            pbest = x
            gbest = x[p_fitness.argmax()]  #
    
            # 接下来就是不断迭代了
            for i in tqdm(range(self.G)):
                pbest=pbest.copy()#必须加,不然会被篡改值,造成结果错
                p_fitness= p_fitness.copy()#必须加,不然会被篡改值,造成结果错
                gbest=gbest.copy()#必须加,不然会被篡改值,造成结果错
                g_fitness=g_fitness.copy()#必须加,不然会被篡改值,造成结果错
                v = self.velocity_update(v, x, pbest, gbest)  # 更新速度
                x = self.position_update(x, v)  # 更新位置
                p_fitness2 = self.fitness_func(x)  # 计算子代各个粒子的适应度
    
                # 更新每个粒子的历史最优位置
                pbest, p_fitness=self.update_pbest(x, p_fitness2, pbest, p_fitness, self.N)
    
                #更新群体的最优位置
                gbest, g_fitness=self.update_gbest(pbest, p_fitness, gbest, g_fitness, self.N)
    
                # 记录最优迭代结果
                fitneess_value_list.append(g_fitness)
    
            print("最优适应度是:%.5f" % fitneess_value_list[-1])
            print("最优解是", gbest)
            print('最优解对应的体积',np.sum(gbest*self.Weight))
            print('最优解对应的价值',np.sum(gbest*self.Value))
    
            plt.plot(fitneess_value_list,label='迭代曲线')
            plt.xlabel('迭代次数')
            plt.ylabel('适应度')
            plt.legend()
            plt.show()
    
    if __name__=='__main__':
        pso = BackPack()
        pso.main()
    

    MATLAB求解

    %%%%%%%%%%%%%%%%%离散粒子群算法解决0-1背包问题%%%%%%%%%%%%%%%%%%
    %%%%%%%%%%%%%%%%%%%%%%%%初始化%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    clear all;              %清除所有变量
    close all;              %清图
    clc;                    %清屏
    N=100;                  %群体粒子个数
    D=10;                   %粒子维数
    c1=1.5;                 %学习因子1
    c2=1.5;                 %学习因子2
    Wmax=0.8;               %惯性权重最大值
    Wmin=0.4;               %惯性权重最小值
    Vmax=10;                %速度最大值
    Vmin=-10;               %速度最小值
    V = 300;                             %背包容量
    C = [95,75,23,73,50,22,6,57,89,98];  %物品体积
    W = [89,59,19,43,100,72,44,16,7,64]; %物品价值
    afa = 2;                             %惩罚函数系数
    %%%%%%%%%%%%%%%%初始化种群个体(限定位置和速度)%%%%%%%%%%%%%%%%
    x=randint(N,D);        %随机获得二进制编码的初始种群
    v=rand(N,D) * (Vmax-Vmin)+Vmin;
    %%%%%%%%%%%%%%%%%%初始化个体最优位置和最优值%%%%%%%%%%%%%%%%%%%
    p=x;
    pbest=ones(N,1);
    for i=1:N
        pbest(i)= func(x(i,:),C,W,V,afa);
    end
    %%%%%%%%%%%%%%%%%%%初始化全局最优位置和最优值%%%%%%%%%%%%%%%%%%
    g=ones(1,D);
    gbest=-10000;
    for i=1:N
        if(pbest(i)>gbest)
            g=p(i,:);
            gbest=pbest(i);
        end
    end
    gb=ones(1,T);
    %%%%%%%%%%%按照公式依次迭代直到满足精度或者迭代次数%%%%%%%%%%%%%
    while 1>0 %无限迭代
        for j=1:N
            %%%%%%%%%%%%%%更新个体最优位置和最优值%%%%%%%%%%%%%%%%%
            if (func4(x(j,:),C,W,V,afa)>pbest(j))
                p(j,:)=x(j,:);
                pbest(j)=func(x(j,:),C,W,V,afa);
            end
            %%%%%%%%%%%%%%%%更新全局最优位置和最优值%%%%%%%%%%%%%%%
            if(pbest(j)>gbest)
                g=p(j,:);
                gbest=pbest(j);
            end
            %%%%%%%%%%%%%%%%计算动态惯性权重值%%%%%%%%%%%%%%%%%%%%
            w=Wmax-(Wmax-Wmin)*i/T;
            %%%%%%%%%%%%%%%%%跟新位置和速度值%%%%%%%%%%%%%%%%%%%%%
            v(j,:)=w*v(j,:)+c1*rand*(p(j,:)-x(j,:))...
                +c2*rand*(g-x(j,:));
            %%%%%%%%%%%%%%%%%%%%边界条件处理%%%%%%%%%%%%%%%%%%%%%%
            for ii=1:D
                if (v(j,ii)>Vmax)  |  (v(j,ii)< Vmin)
                    v(j,ii)=rand * (Vmax-Vmin)+Vmin;
                end
            end
            vx(j,:)=1./(1+exp(-v(j,:)));
            for jj=1:D
                if vx(j,jj)>rand
                    x(j,jj)=1;
                else
                    x(j,jj)=0;
                end
            end
        end
        %%%%%%%%%%%%%%%%%%%%记录历代全局最优值%%%%%%%%%%%%%%%%%%%%%
        gb(i)=gbest;
        if g.*C<=300 %如果满足条件 退出
            break
    
    
    end
    g;                       %最优个体
    figure
    plot(gb)
    xlabel('迭代次数');
    ylabel('适应度值');
    title('适应度进化曲线')
    
    
    %%%%%%%%%%%%%%%%%%适应度函数%%%%%%%%%%%%%%%%%
    function result = func(f,C,W,V,afa)
    fit = sum(f.*W);
    TotalSize = sum(f.*C);
    if TotalSize <= V
        fit = fit;
    else
        fit = fit - afa * (TotalSize - V);
    end
    result = fit;
    
    

    在这里插入图片描述
    作者:电气 余登武

    展开全文
  • 本文对于在保证系统安全的前提下进行可中断负荷的优化调度,基于二进制粒子群优化算法(BPSO)分时段优化调度特性不同的多个可中断负荷,以满足系统各时段削减容量的需求,同时满足可中断负荷的运行约束条件,并使供电公司...
  • 假设被检测的某个矢量信号外的其他信号已知,将离散二进制粒子群优化算法(DBPSO,DiscreteBinaryParticleSwarmOptimization)应用到MIMO(Multiple-InputMultiple-Output)系统中对信号进行检测,能够较好地解决检测技术在...
  • 针对任务分配问题,本文提出了一种改进的二进制粒子群优化算法(MBPSO),该算法采用了不同的传递函数和新的带有变异的位置更新程序,从而获得了最佳的解决方案。 MBPSO中的每个粒子都经过编码,以表示用于任务分配...
  • 通过将二进制粒子算法引入认知决策引擎来解决传统算法在收敛精度和速度方面的缺陷
  • 针对无线传感器网络LEACH...首先在成簇过程中使簇的个数最优,然后应用二进制粒子群算法在每个簇中选择最优簇头。仿真证明,二进制粒子群优化的LEACH协议较原始LEACH协议有效降低了总的能量消耗,延长了网络的生命期。
  • 针对目前分布式数据库数据分配方法法存在寻求最优分配方案和运行效率等问题的不足,在基于改进的遗传算法的数据分配方法基础上,引入二进制粒子群算法,提出了一种基于二进制粒子群与遗传算法的数据分配方法,既具有...
  • 针对解形式为二进制编码形式的问题的粒子群优化算法matlab源码
  • 原始的二元粒子群算法(BPSO)有一些缺点,使得算法不能很好地收敛。 为了解决这些缺点,引入了新的 BPSO(NBPSO)。 休耕论文中提供的结果显示了 NBPSO 的优越性。 [1]。 M.Rostami Shahrbabak 和 H.Nezamabadi-...
  • 针对传统二进制粒子群优化(BPSO)算法未充分利用粒子位置的历史信息辅助迭代寻优,从而影响算法寻优效率的进一步提高的问题,提出一种改进的带经验因子的BPSO算法。该算法通过引入反映粒子位置历史信息的经验因子来...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 134
精华内容 53
关键字:

二进制粒子群算法