精华内容
下载资源
问答
  • 智能优化算法原子优化算法 文章目录智能优化算法原子优化算法1.原子优化算法原理2.实验结果3.参考文献4.Matlab代码 摘要:原子优化算法(Atom Search Optimization)是于2019提出的一种基于分子动力学模型的新颖...

    智能优化算法:原子搜索优化算法


    摘要:原子搜索优化算法(Atom Search Optimization)是于2019提出的一种基于分子动力学模型的新颖智能算法.模拟在原子构成的分子系统中,原子因相互间的作用力和系统约束力而产生位移的现象.在一个分子系统中,相邻的原子间存在相互作用力(吸引力和排斥力),且全局最优原子对其他原子存在几何约束作用 .引力促使原子广泛地探索整个搜索空间,斥力使它们能够有效地开发潜在区域 。具有寻优能力强,收敛快的特点。

    1.原子优化算法原理

    假设一个分子系统是由 s个原子构成的d维空间, Xid(t)X_i^d(t))为第ii 个原子在第tt次迭代时的位置,可以表示为:Xid(t)=(Xi,1,Xi,2,...,Xi,d),(i=1,2,...,s;,t=1,2,...,tmaxX_i^d(t) = (X_{i,1},X_{i,2},...,X_{i,d}),(i=1,2,...,s;,t=1,2,...,t_{max},tmaxt_{max}为最大迭代次数,Xbestd(t)X_{best}^d(t))为第t次迭代时全局最优解.

    在这里插入图片描述

    图1.n,F 和h关系图

    原子运动遵循经典力学根据牛顿第二定律,原子的加速度与其质量有关,且由原子间的相互作用力和最优原子对其的几何约束的共同作用产生,所以第i个原子在第t次迭代时加速度如下:
    aid(t)=Fid+Gid(t)mid(t)(1) a_i^d(t) = \frac{F_i^d + G_i^d(t)}{m_i^d(t)}\tag{1}
    式中,Fid(t)F_i^d(t)为第t次迭代时d维空间中作用于第 i个原子的总力,可以看作是适应度函数值较好的k个原子对第i个原子作用力的随机加权之和,表示如下:
    Fid(t)=jKbestrandjFijd(t)(2) F_i^d(t)=\sum_{j\in K_{best}}rand_jF^d_{ij}(t)\tag{2}
    式中,KbestK_{best}为适应度函数值较好的kk个原子的集合,FijdF_{ij}^d为两原子之间的作用势能,可以表示为:
    Fijd=n(t)[2(hij(t))3(hij(t))7](3) F_{ij}^d = -n(t)[2(h_{ij}(t))^3 - (h_{ij}(t))^7]\tag{3}
    式中,n(t)=α(1t1tmax)3e20t/tmaxn(t) = \alpha(1-\frac{t-1}{t_{max}})^3e^{-20t/t_{max}}可以调节引力区域和斥力区域的范围,nn随着迭代次数的增加, nn自适应递减,使得全局搜索和局部开发的范围都逐步缩小至最优值,保证了算法的收敛性;α\alpha为深度加权;hij(t)h_{ij}(t)为两个原子之间的距离,不同的hh值对应着不同的作用力性质 . 如图 1 所示,当h(0.9,1.1)h \in(0.9,1.1)时为斥力,且随着hh值得增大而增大;当h为1.12时,为平衡状态,作用力为0;当h(1.12,1.24)h \in(1.12,1.24)时,为吸引力且随着hh值得增大而增大,h(1.24,2)h \in(1.24,2)时,仍为吸引力但随着hh值得增大而减小至0 ,所以hh可以表示为:
    hij(t)={hmin,rij(t)/σ(t)<hminrij(t)/σ(t),hminrij(t)/σ(t)hmaxhmax,rij(t)/σ(t)>hmax(4) h_{ij}(t) = \begin{cases} h_{min}, r_{ij}(t)/\sigma(t)<h_{min}\\ r_{ij}(t)/\sigma(t),h_{min}\leq r_{ij}(t)/\sigma(t)\leq h_{max}\\ h_{max},r_{ij}(t)/\sigma(t)>h_{max} \end{cases}\tag{4}
    式中,hmin=ε0+ε(t)h_{min}=\varepsilon_0 + \varepsilon(t)hh的下界,ε(t)\varepsilon(t)为漂移因子随着迭代次数的变化而变化,使得算法在全局搜索和局部开发中转换;hmaxh_{max}hh上界;σ(t)=Xij(t),jKbestXij(t)/K(t)2\sigma(t)=||X_{ij}(t),\sum_{j\in K_{best}}X_{ij}(t)/K(t)||_2,是KbestK_{best}集合中的原子与第ii个原子的距离范围.

    在这里插入图片描述

    图2.原子群相互作用示意图(K=5)

    在ASO算法中,为了加强迭代初期的全局探索能力,每个原子需要与较多个适应度较好的邻近原子产生相互作用,而在迭代后期为了增强局部开发促进算法收敛,每个原子需要与较少的适应度较好的邻近原子产生相互作用 . 适应度较好的邻近原子的数量用KK表示,K=s(s2)t/tmaxK = s-(s-2)*\sqrt{t/t_{max}},随着迭代次数自适应减小,既保证了迭代前期算法跳出局部最优进行全局搜索的能力,又保证了算法后期局部开发能力并保证算法的收敛性 .KbestK_{best}为适应度函数值较好的 k 个原子的集合,原子群的作用力如图2所示.

    在分子动力学模型中,几何约束在原子运动中是十分重要的因素.在ASO中,为了简单起见,假设每个原子与最优原子具有共价键,因此每个原子受来自最佳原子的约束力的作用,所以(1)式中的Gid(t)G_i^d(t)为第tt次迭代时dd维空间中全局最优原子对第ii个原子的几何约束作用,表示为:
    Gid(t)=λ(t)(Xbestd(t)Xid(t))(5) G_i^d(t)=\lambda(t)(X_{best}^d(t) - X_i^d(t)) \tag{5}
    式中,λ(t)=βe20t/tmax\lambda(t) = \beta e^{-20t/t_{max}},随着迭代次数做自适应调整;β\beta为乘数权重 .

    (1) 式中mid(t)m_i^d(t)为原子的质量,可表示为:

    mid(t)=Mi(t)/j=1NMj(t)(6) m_i^d(t) = M_i(t)/\sum_{j=1}^NM_j(t) \tag{6}

    ait(t)=Fid(t)/mid(t)+Gid(t)/mid(t)=α(1t1tmax)3e20t/tmaxjKbestrandj[2(hij(t))13(hij(t))7]mi(t)(7) a_i^t(t)=F_i^d(t)/m_i^d(t) + G_i^d(t)/m_i^d(t)=-\alpha(1-\frac{t-1}{t_{max}})^3e^{-20t/t_{max}}\sum_{j\in K_{best}}\frac{randj[2(h_{ij}(t))^13 - (h_{ij}(t))^7]}{m_i(t)} \tag{7}

    加速度使得原子运动速度及位移发生变化,这便是ASO算法的位置更新的核心过程,表示为:
    vid(t+1)=randidvid(t)+aid(t)(8) v_i^d(t+1) = rand_i^dv_i^d(t) + a_i^d(t) \tag{8}

    Xid(t+1)=Xid(t)+vid(t+1)(9) X_i^d(t+1)=X_i^d(t) + v_i^d(t+1)\tag{9}

    算法流程:

    Step1:初始化ASO各参数如种群规模,最大迭代次数等

    Step2:对原子种群进行初始化

    Step3:根据目标函数计算每个个体的适应度函数值,并保留为当前的最优值及最优解;

    Step4:根据公式(7)更新原子运动加速度;

    Step5:根据公式(8)更新原子运动速度;

    Step6:根据公式(9)更新原子个体位置;

    Step7:再次计算种群个体的适应度函数值,根据适应度值的优劣来更新最优解和最优值;

    Step8: 重复步骤4-8 ,直到达到最大迭代次数时终止操作;

    Step9: 输出最优个体位置以及最优适应度值;

    2.实验结果

    在这里插入图片描述

    3.参考文献

    [1]Weiguo Zhao,Liying Wang,Zhenxing Zhang. A novel atom search optimization for dispersion coefficient estimation in groundwater[J]. Future Generation Computer Systems,2019,91.

    [1]肖子雅,刘升.黄金正弦混合原子优化算法[J].微电子学与计算机,2019,36(06):21-25+30.

    4.Matlab代码

    https://mianbaoduo.com/o/bread/YZaXlp9t

    展开全文
  • 02 原子变量 CAS算法

    2020-05-10 21:43:38
    原子变量 CAS算法 JDK 1.5 之后 java.util.concurrent.atomic 包下提供了常用的原子变量。 volatile 保证内存可见性。 CAS (Compare-And-Swap) 算法保证数据的原子性。 CAS 算法是硬件对于并发操作数共享数据的...

    原子变量 CAS算法

    1. JDK 1.5 之后 java.util.concurrent.atomic 包下提供了常用的原子变量。
    • volatile 保证内存可见性。
    • CAS (Compare-And-Swap) 算法保证数据的原子性。
      • CAS 算法是硬件对于并发操作数共享数据的支持。
      • CAS 包含三个操作数:内存值V,预估值A,更新值B。当且仅当 V == A 时,V = B;否则不进行任何操作。
    1. AtomicBooleanAtomicIntegerAtomicLongAtomicReference 的实例各自提供对相应类型单个变量的访问和更新。每个类也为该类型提供适当的实用工具方法。

    2. AtomicIntegerArrayAtomicLongArrayAtomicReferenceArray 类进一步扩展了原子操作,对这些类型的数组提供了支持。这些类在为其数组元素提供 volatile 访问语义方面也引人注目,这对于普通数组来说是不受支持的。

    3. 核心方法:boolean compareAndSet(expectedValue, updateValue)

    4. 示例:

      import java.util.concurrent.atomic.AtomicInteger;
      
      public class TestAtomic {
          public static void main(String[] args) {
              Atomic atomic = new Atomic();
              for (int i = 0; i < 10; i++) {
                  new Thread(atomic).start();
              }
          }
      }
      
      class Atomic implements Runnable{
          // 不能保证数据的原子性
          // private volatile int num = 0;
      
          // 使用原子变量
          private AtomicInteger num = new AtomicInteger();
      
          public int getNum() {
              return num.getAndIncrement();
          }
      
          @Override
          public void run() {
              try {
                  Thread.sleep(200);
              } catch (InterruptedException e) {
              }
              System.out.println(getNum());
          }
      }
      
    展开全文
  • 原子性 CAS算法

    2018-12-13 22:56:00
    一、 i++ 的原子性问题 1、问题的引入: i++ 的实际操作分为三个步骤:读--改--写 实现线程,代码如下: public class AtomicDemo implements Runnable { private int serialNumber = 0; @Override ...

    一、 i++ 的原子性问题

    1、问题的引入:

    i++ 的实际操作分为三个步骤:读--改--写

    实现线程,代码如下:

    public class AtomicDemo implements Runnable
    {
        private int serialNumber = 0;
    
        @Override
        public void run()
        {
            try
            {
                Thread.sleep(400);
            }
            catch (InterruptedException e)
            {}
            System.out.println(Thread.currentThread().getName() + ": " + this.getSerialNumber());
        }
    
        public int getSerialNumber()
        {
            return serialNumber++;
        }
    }

    测试类,代码如下:

    public class AtomicTest
    {
        public static void main(String[] args)
        {
            AtomicDemo atomicDemo = new AtomicDemo();
            for (int i = 0; i < 10; i++)
            {
                new Thread(atomicDemo).start();
            }
        }
    }

    结果如下图所示:

     

    以上的原子性问题可以使用“原子变量”解决;

    二、原子变量

    在JDK1.5 之后,提供了 java.util.concurrent.atomic 包下提供了常用的原子变量;

     AtomicBoolean、AtomicInteger、AtomicIntegerArray、AtomicIntegerFieldUpdater、AtomicLong、AtomicReference 等

    从以上类源码中可以看出:

      (1)变量使用了 Volatile 修饰,保证了内存可见性;

      (2)使用了 CAS(Compare-And-Swap)算法,保证了数据的原子性;

      CAS算法是硬件对于并发操作共享数据的支持;

      CAS 包含了三个操作数:内存值 、预估值 、更新值 ;

        当且仅当内存值等于预估值时,把更新值赋给内存值,否则将不做任何操作;

    class AtomicDemo implements Runnable
    {
        private AtomicInteger serialNumber = new AtomicInteger();
    
        @Override
        public void run()
        {
            try
            {
                Thread.sleep(400);
            }
            catch (InterruptedException e)
            {}
            System.out.println(Thread.currentThread().getName() + ": " + this.getSerialNumber());
        }
    
        public int getSerialNumber()
        {
            return serialNumber.getAndIncrement();
        }
    }

     

    转载于:https://www.cnblogs.com/yufeng218/p/10117033.html

    展开全文
  • 原子变量CAS算法

    2017-09-24 11:31:55
    一、CAS算法  1、CAS (Compare-And-Swap) 是一种硬件对并发的支持,针对多处理器操作而设计的处理器中的一种特殊指令,用于管理对共享数据的并发访问。  2、CAS 是一种无锁的非阻塞算法的实现。  3、CAS ...

    一、CAS算法
      1、CAS (Compare-And-Swap) 是一种硬件对并发的支持,针对多处理器操作而设计的处理器中的一种特殊指令,用于管理对共享数据的并发访问。
      2、CAS 是一种无锁的非阻塞算法的实现。
      3、CAS 包含了3 个操作数:
        3.1、需要读写的内存值V
        3.2、进行比较的值A
        3.3、拟写入的新值B
        3.4、当且仅当V 的值等于A 时,CAS 通过原子方式用新值B 来更新V 的值,否则不会执行任何操作。

    二、原子变量
      1、类的小工具包,支持在单个变量上解除锁的线程安全编程。事实上,此包中的类可将volatile 值、字段和数组元素的概念扩展到那些也提供原子条件更新操作的类。
      2、类AtomicBoolean、AtomicInteger、AtomicLong 和AtomicReference 的实例各自提供对相应类型单个变量的访问和更新。每个类也为该类型提供适当的实用工具方法。
      3、AtomicIntegerArray、AtomicLongArray 和AtomicReferenceArray 类进一步扩展了原子操作,对这些类型的数组提供了支持。这些类在为其数组元素提供volatile 访问语义方面也引人注目,这对于普通数组来说是不受支持的。
      4、核心方法:boolean compareAndSet(expectedValue, updateValue)
      5、java.util.concurrent.atomic 包下提供了一些原子操作的常用类:
      AtomicBoolean 、AtomicInteger 、AtomicLong 、AtomicReference
      AtomicIntegerArray 、AtomicLongArray
      AtomicMarkableReference
      AtomicReferenceArray
      AtomicStampedReference

    看如下代码:

    public class TestAtomic {
        public static void main(String[] args) {
            MyRunnable2 r = new MyRunnable2();
            for(int i=0;i<10;i++){
                new Thread(r).start();
            }
        }
    }
    
    class MyRunnable2 implements Runnable{
        private int serialNumber = 0;
        @Override
        public void run() {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+getAndAdd());
        }
    
        private int getAndAdd(){
            return this.serialNumber++;
        }
    }

    执行结果如下:
    这里写图片描述

    可以看出有时会串数据。

    结果分析:
    i++操作,实际上分为三个步骤“读-改-写”
      int temp = i;
      i = i + 1;
      i = temp;
    原子变量:在 java.util.concurrent.atomic 包下提供了一些原子变量。
      1. volatile 保证内存可见性
      2. CAS(Compare-And-Swap) 算法保证数据变量的原子性
      CAS 算法是硬件对于并发操作的支持
      CAS 包含了三个操作数:
        ①内存值 V
        ②预估值 A
        ③更新值 B
      当且仅当 V == A 时, V = B; 否则,不会执行任何操作。

    与原代码相比代码修改如下:

    class MyRunnable2 implements Runnable{
        private AtomicInteger serialNumber = new AtomicInteger(0);
        @Override
        public void run() {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+getAndAdd());
        }
    
        private int getAndAdd(){
            return serialNumber.getAndIncrement();
        }
    }

    其他地方不变。

    展开全文
  • 原子性与CAS算法

    2020-07-15 18:01:25
    i++问题一个, 原子变量 CAS算法保证数据的原子性 CAS是硬件对于并发操作的支持 cas包括了, 内存值,V 预估值,A 更新值,B 当且仅当V==A时,才会把B的值赋给A,否则将不做什么操作
  • 针对传统的线性化方法难以有效辨识次同步振荡模态的问题,提出一种基于改进生物地理学优化(IBBO)的阻尼正弦原子分解算法。该方法在过完备阻尼正弦原子库的基础上,通过将余弦迁移模型、改进迁移算子以及混沌变异...
  • 原子时尺度算法分析

    2011-11-06 23:35:00
    学习ALGOS算法,文章里详细介绍了ALGOS算法
  • 原子性问题和CAS算法

    2020-07-23 16:34:38
    原子性问题和CAS算法原子性问题原子变量CAS算法举例代码 原子性问题 场景如下:例如i++,实际上分成三个步骤“读-改-写”。 int temp=i; i=i+1; return temp; 由于该操作分成多个步骤,整体不具有原子性。最终导致当...
  • Java JUC3 原子变量与CAS算法3.1 原子变量3.1.1 i++的原子性问题3.1.2 原子变量3.2 CAS算法3.2.1 ABA问题3.2.2 CAS在JAVA中底层的实现3.3 原子性与可见性区别 3 原子变量与CAS算法 3.1 原子变量 3.1.1 i++的原子性...
  • CAS算法原子变量

    2020-03-11 22:47:45
    1、CAS算法 CAS(Compare-And-Swap)是一种硬件对并发的支持,针对多处理器操作而设计的处理器中的一种特殊...当且仅当V的值等于A时,CAS通过原子方式用新值B来更新V的值,否则不会执行任何操作; 模拟CAS算法 /**...
  • 原子变量和CAS算法

    千次阅读 2017-02-10 00:46:07
    然后,使用了CAS(Compare and Swap)算法保证数据变量的原子性。   CAS算法  CAS算法是硬件对于并发操作的支持,其中包含了三个操作数:内存值,预估值和更新值。每当要执行更新操作时,会先在同步方法中...
  • 原子性及CAS算法

    2019-12-22 18:33:13
    java.util.concurrent.atomic 包下提供了一些原子变量 非原子性操作问题: package com.mock; import org.junit.jupiter.api.Test; public class TestAtomic { @Test public void test() throws ...
  • 基于原子搜索优化算法的结构参数识别 摘 要 土木工程结构在服役过程中遭受着环境侵蚀建筑材料老化荷载长期作用和各种 突发性外在因素的耦合作用导致结构抗力衰减和发生损伤累积这给结构的安全性和 耐久性带来巨大...
  • 时频原子分解(TFAD)为非平稳信号提供了灵活的表示形式,但是极高的计算量极大地阻碍了其实际应用。 量子启发式进化算法(QEA)是高效的优化方法,具有强大的搜索能力和快速收敛性。 本文提出了QEA的改进变体在TFAD...
  • 原子变量与CAS算法

    2019-10-04 19:26:40
    上一节讨论了 volatile关键字,volatile关键字修饰的作用是不具有 "原子性" 和 "互斥性的" 例如 i++ 操作 就不是一个原子性的操作,i++ 其实分为3个步骤进行 "读-改-写" int temp = i; i = i + 1; i= temp; 先...
  • 原子变量与 CAS 算法

    2018-06-06 16:19:49
    一、原子变量 /* * 一、i++ 的原子性问题:i++ 的操作实际上分为三个步骤“读-改-写” * int i = 10; * i = i++; //10 * * int temp = i; * i = i + 1; * i = temp; */ 1.2 原子性案例 案例一 ...
  • 上篇博文,我们介绍了多线程之内存可见性Volatile,但是也遗留了一个问题,如何保证变量的”原子性操作(Atomic operations)”?Volatile保证部分类型的原子性上篇博文,我们说Voloatile不能保证原子性,有一点局限:...
  • 原标题:Java并发之原子变量及CAS算法-上篇Java并发之原子变量及CAS算法-上篇 编辑概述本文主要讲在Java并发编程的时候,如果保证变量的原子性,在JDK提供的类中式怎么保证变量原子性的呢?。对应Java中的包是:java...
  • 提出一种原子分解的快速算法,并应用于电能质量扰动信号的分析中。该方法构建相关原子库,并将原子离散的参数连续化,能减少重构信号所需的原子数并使分解结果更准确;针对频率范围较大的谐波、衰减振荡等信号,采用...
  • 原子变量及CAS算法

    2019-11-09 16:03:26
    1.i++和++i问题 @Test public void test1(){ int i = 0,j,k; j = i++;... System.out.println("i="+i+",j="+j+",k="+k);...如上图,以i++操作为例,显然该操作是非原子性的,在底层实际上可分为...
  • 2.原子变量 CAS算法

    2017-08-25 11:36:00
    前面提到,使用volatile无法保证 变量状态的原子性操作,所谓原子性,就是不可再分  如:i++的原子性问题,i++ 的操作实际上分为三个步骤 "读-改-写"  (1)保存i的值(一个临时变量中)  (2)递增i  (3)返回已...
  • Atom Search Optimization(ASO)是一种用于...ASO在数学上模拟和模拟自然界中的原子运动模型,其中原子通过相互作用力相互作用,形成Lennard-Jones势能和由键长潜力产生的约束力。该算法简单易行。包含matlab源代码
  • JUC_2-原子变量 CAS算法

    2019-02-20 13:47:57
    原子变量 CAS算法 一、CAS算法 public static void main(String[] args) { AtomicDemo demo = new AtomicDemo(); for(int i=0;i&lt;=10;i++){ new Thread(demo).start();; } ...
  • 文章目录CAS 无锁算法原子操作类实践非原子性示例CAS 无锁算法模仿AtomicInteger 类完成原子自增操作参考内容 CAS 无锁算法原子操作类实践 非原子性示例 先来看一段未实现原子性的自增统计代码: private ...
  • 原子类的底层正是基于 CAS 算法实现线程安全。 Java 为我们提供了十六个原子类,可以大致分为以下四种: 1. 基本类型 AtomicBoolean原子更新布尔类型,内部使用 int 类型的 value 存储 1 和 0 表示 true 和 false,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,633
精华内容 1,053
关键字:

原子算法