精华内容
下载资源
问答
  • 论文研究-基于Markov机制转换模型的我国股市周期波动状态研究.pdf, 运用Markov机制转换模型,研究我国股市在不同状态之间的周期转换.研究结果表明, 四状态异方差马尔科夫...
  • 基于模糊理论和矩阵转换思想,分别建立了在顾客需求及需求权重明确和不明确两种条件下如何将顾客需求转换为工程特征的转换模型,以及将工程特征转换为顾客需求的转换模型
  • 论文研究-基于机制转换混合Copula模型的我国股市间极值相依性.pdf, 通过构建机制转换混合 Copula 模型, 考察了沪、深股市与港、台股市间的尾部相依特征, 研究发现:它们...
  • 该文采用自回归条件异方差(GARCH)模型和Markov机制转换模型研究房价波动过程。首先依据4个中国城市的数据对2类模型分别进行回归,然后根据回归结果计算房价波动率和房价下行概率,以此衡量房价的波动风险。结果...
  • 风险溢价动态特性的机制转换现象-基于SHIBOR市场的期限结构研究,杨宝臣,苏云鹏,针对SHIBOR利率动态特性中存在的机制转换及波动聚集现象,分别将机制转换和GARCH效应引入CIR模型,构建了带制度转换的CIR模型...
  • 随机转换机制下的具有免疫和非线性发生率的 SIRS 传染病模型的动态行为,胡俊娜,李智明,在本文中, 随机转换机制下的具有免疫和非线性发生率的 SIRS 传染病模型的动态行为被研究. 通过构造合适的随机李雅普诺夫函数...
  • 我们校准马尔可夫机制转换 (MRS) 模型以表示 EEX 市场的每日现货价格。 我们的实证研究表明,(i) 具有转移尖峰机制分布的模型导致更现实的电力现货价格模型,并且 (ii) 在基本机制中引入异方差导致比 MRS 模型更好的...
  • 预先锁定模型,来进行多线程重新启动机制,将所有的更新循环检测进行多线程调度,多线程更新服务使用未来侦听器机制,在完成调度后,根据模型状态,如果模型重新重新将消息转化为如果模型死亡将消息转换为...
  • 尽管模型驱动开发(MDD) 代表软件工程的发展方向,但是目前MDD 还缺乏一套完整的转换规则描述 方法和相应的实现机制,难以实现模型的自动转换。为此定义了一个平台独立模型到平台相关模型转换框 架,采用UML 活动...
  • 通过定义一个清晰的基于规则的模型转换框架,提出了一种基于有限状态机的模型转换方法,用有限状态机技术解决转换规则的实现问题,并定义了适合规则实现机制的形式表示法,然后结合UML模型到SQL模型转换的典型场景,...
  • Java虚拟机:类加载机制与双亲委派模型

    万次阅读 多人点赞 2019-05-15 11:51:07
    类加载机制,就是虚拟机把类的数据从class文件加载到内存,并对数据进行校检,转换解析和初始化,最终形成可以被虚拟机直接使用的Java类型的过程。 JVM的类加载机制,规定一个类有且只有一个类加载器对它进行加载。...

    一、类加载机制:

    .java文件中的代码在编译后,就会生成JVM能够识别的二进制字节流class文件,class文件中描述的各种信息,都需要加载到虚拟机中才能被运行和使用。

    类加载机制,就是虚拟机把类的数据从class文件加载到内存,并对数据进行校检,转换解析和初始化,最终形成可以被虚拟机直接使用的Java类型的过程。

    类从加载到虚拟机内存开始,到卸载出内存结束,整个生命周期包括七个阶段,如下图(每个过程作用见文章第四部分):

     

    二、类加载器:

    生命周期的第一阶段,即加载阶段需要由类加载器来完成的,类加载器根据一个类的全限定名读取类的二进制字节流到JVM中,然后生成对应的java.lang.Class对象实例,

    在虚拟机默认提供了3种类加载器,启动类加载器(Bootstrap ClassLoader)、扩展类加载器(Extension ClassLoader)、应用类加载器(Application ClassLoader),如果有必要还可以加入自己定义的类加载器。

    (1)启动类加载器(Bootstrap ClassLoader):负责加载 在<JAVA_HOME>\lib目录 和 被-Xbootclasspath参数所指定的路径中的类库 

    (2)扩展类加载器(Extension ClassLoader):负责加载 <JAVA_HOME>\lib\ext目录 和 被java.ext.dirs系统变量所指定的路径中的所有类库

    (3)应用程序类加载器(Application ClassLoader):负责加载用户类路径classPath所指定的类库,如果应用程序中没有自定义过自己的类加载器,一般情况下这个就是程序中默认的类加载器。

    (4)自定义加载器(CustomClassLoader):属于应用程序根据自身需要自定义的ClassLoader,如tomcat、jboss都会根据j2ee规范自行实现。

    任意一个类在JVM中的唯一性,是由加载它的类加载器和类的全限定名一共同确定的。因此,比较两个类是否“相等”的前提是这两个类是由同一个类加载器加载的,否则,即使两个类来源于同一个Class文件,被同一个虚拟机加载,只要加载他们的类加载器不同,那这两个类就必定不相等。JVM的类加载机制,规定一个类有且只有一个类加载器对它进行加载。而如何保证这个只有一个类加载器对它进行加载呢?则是由双亲委派模型来实现的。

     

    三、双亲委派模型:

    双亲委派模型要求除了顶层的启动类加载器外,其余类加载器都应该有自己的父类加载器。(类加载器之间的父子关系不是以继承的关系实现,而是使用组合关系来复用父加载器的代码)

    1、双亲委派模型的工作原理:

    如果一个类加载器收到了类加载的请求,他首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去完成,每一个层级的类加载器都是如此,因此所有请求最终都会被传到最顶层的启动类加载器中,只有当父类加载器反馈自己无法完成这个加载请求时,子加载器才会尝试自己去加载。

    因此,加载过程可以看成自底向上检查类是否已经加载,然后自顶向下加载类。

    2、双亲委派模型的优点:

    (1)使用双亲委派模型来组织类加载器之间的关系,Java类随着它的类加载器一起具备了一种带有优先级的层次关系。

    (2)避免类的重复加载,当父类加载器已经加载了该类时,子类加载器就没必要再加载一次。

    (3)解决各个类加载器的基础类的统一问题,越基础的类由越上层的加载器进行加载。避免Java核心API中的类被随意替换,规避风险,防止核心API库被随意篡改。

    例如类java.lang.Object,它存在在rt.jar中,无论哪一个类加载器要加载这个类,最终都是委派给处于模型最顶端的Bootstrap ClassLoader进行加载,因此Object类在程序的各种类加载器环境中都是同一个类。相反,如果没有双亲委派模型而是由各个类加载器自行加载的话,如果用户编写了一个java.lang.Object的同名类并放在ClassPath中,那系统中将会出现多个不同的Object类,程序将混乱。因此,如果开发者尝试编写一个与rt.jar类库中重名的Java类,可以正常编译,但是永远无法被加载运行。

     

    四、类加载生命周期:

    1、加载阶段:

    这阶段的虚拟机需要完成三件事情:

    (1)通过一个类的全限定名来获取定义此类的二进制字节流。

    (2)将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。

    (3)在内存中生成一个代表这个类的java.lang.Class对象,作为方法区这个类的各种数据的访问入口。

    2、验证阶段:

    这阶段是为了确保class文件的字节流包含的信息符合当前虚拟机的要求,不会危害虚拟机自身的安全。分为4个校检动作:

    (1)文件格式验证:验证字节流是否符合class文件格式的规范,并且能被当前版本的虚拟机处理,通过该阶段后,字节流会进入内存的方法区中进行储存。

    (2)元数据验证:对字节码描述的信息进行语言分析,对类的元数据信息进行语义校验,确保其描述的信息符合java语言规范要求。

    (3)字节码验证:通过数据流和控制流分析,确定程序语义是合法的、符合逻辑的。这个阶段对类的方法进行校验分析,保证类的方法在运行时不会做出危害虚拟机安全的事件。

    (4)符号引用验证:对类自身以外的信息(常量池中各种符号引用)的信息进行校检,确保解析动作能正常执行(该动作发生在解析阶段中)

    3、准备阶段:

    正式为类变量分配内存空间并设置数据类型零值。这个阶段进行内存分配的仅包括类变量(static修饰),不包括实例变量,实例变量会在对象实例化时随对象一起分配在java堆。

    public static int value= 123 ; //变量value在准备阶段过后的初始值是0,不是123.
    public static final int value = 123 ; //特殊情况:会生成ConstantValue属性,在准备阶段初始值是123.

    final、static、static final修饰的字段赋值的区别:

    (1)static修饰的字段在准备阶段被初始化为0或null等默认值,然后在初始化阶段(触发类构造器<clinit>)才会被赋予代码中设定的值,如果没有设定值,那么它的值就为默认值。

    (2)static final修饰的字段在Javac时生成ConstantValue属性,在类加载的准备阶段根据ConstantValue的值为该字段赋值,它没有默认值,必须显式地赋值,否则Javac时会报错。可以理解为在编译期即把结果放入了常量池中。

    (3)final修饰的字段在运行时被初始化(可以直接赋值,也可以在实例构造器中<init>()赋值),一旦赋值便不可更改。

    4、解析阶段:

    将常量池的符号引用替换为直接引用的过程。解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄、和调用限定符7类符号引用。

    对同一符号引用进行多次解析请求是很常见的事情,除invokedynamic指令以外,虚拟机可以对第一次解析的结果进行缓存,从而避免解析动作重复进行。invokedynamic对应的引用称为“动态调用限定符”,必须等到程序实际运行到这条指定的时候,解析动作才能进行。因此,当碰到由前面的invokedynamic指令触发过的解析的符号引用时,并不意味着这个解析结果对其他的invokedynamic指令也同样生效。

      (1)符号引用:符号引用是以一组符号来描述所引用的目标,符号可以是任何字面量,只要使用时无歧义定位到目标即可。符号引用与虚拟机的内存布局无关,引用的目标并不一定已经加载到内存中。各种虚拟机实现的内存布局可以不相同,但是他们能接受的符号引用必须都是一致的,符号引用的字面量形式明确地定义在java虚拟机规范的calss文件格式中。

      (2)直接引用:直接引用是可以直接定位到目标的指针、相对偏移量或是一个能间接定位目标的句柄。直接引用是与虚拟机的内存布局相关的,同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同。如果有了直接引用,那引用的目标必定已经在内存中存在。

    5、初始化:

    初始化阶段才真正执行类中定义的java代码。执行类构造器<clinit>()方法的过程,并按程序的设置去初始类变量和其他资源。

    5.1、类的主动引用:

    在初始化阶段,有且只有5种场景必须立即对类进行“初始化”,称为主动引用:

        (1)遇到new、getstatic、putstatic、invokestatic这4条指定时。对应的场景是:使用new关键字实例化对象的时候,读取或设置一个类的静态字段(被final修饰、已经在编译期把结果放入常量池的静态字段除外),以及调用一个类的静态方法的时候。

        (2)使用java.lang.reflect包的方法对类进行发射调用的时候。

        (3)当初始化一个类的时候,如果发现其父类还没进行初始化,则必须对父类进行初始化。(与接口的区别:接口在初始化时,并不要求其父接口全部都完成了初始化,只有在真正使用到父接口的时候,才会初始化)

        (4)当虚拟机启动时,用户指定的要执行的主类(包含main方法的类)。

        (5)java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄,并且这个句柄所对应的类没有进行过初始化,则需要触发其初始化。

    5.2、类的被动引用:

    除了主动引用,其他引用类的方式都不会触发初始化,称为被动引用:

        (1)对于静态字段,只有直接定义这个字段的类才会被初始化,通过其子类来引用父类中定义的静态字段,只会触发其父类的初始化而不会触发子类的初始化。

    //父类  
    public class SuperClass {  
        //静态变量value  
        public static int value =123456;  
        //静态块,父类初始化时会调用  
        static{  
            System.out.println("父类初始化!");  
        }  
    }  
      
    //子类  
    public class SubClass extends SuperClass{  
        //静态块,子类初始化时会调用  
        static{  
            System.out.println("子类初始化!");  
        }  
    }  
      
    //主类、测试类  
    public class InitTest {  
        public static void main(String[] args){  
            System.out.println(SubClass.value);  //输出结果:父类初始化! 123456
        }  
    }

        (2)通过数组定义来引用类,不会触发此类的初始化。

    //父类  
    public class SuperClass {  
        //静态变量value  
        public static int value = 123456;  
        //静态块,父类初始化时会调用  
        static{  
            System.out.println("父类初始化!");  
        }  
    }  
      
    //主类、测试类  
    public class InitTest {  
        public static void main(String[] args){  
            SuperClass[] test = new SuperClass[10]; //输出结果:没有任何输出结果
        }  
    }

        (3)常量在编译阶段会存入调用类的常量池中,本质上并没有直接引用到定义常量的类,因此不会触发定义常量的类的初始化。

    //定义常量的类  
    public class ConstClass {  
        static{  
            System.out.println("常量类初始化!");  
        }  
          
        public static final String HELLOWORLD = "hello world!";  
    }  
      
    //主类、测试类  
    public class InitTest {  
        public static void main(String[] args){  
          System.out.println(ConstClass.HELLOWORLD);  //输出结果:hello world
        }  
    }  

    5.3、<clinit>()方法的特点: 

       (1)<clinit>()方法是有编译器自动收集类中的所有类变量的赋值动作和静态语句块中的语句合并产生的,收集的顺序是由语句在源文件中出现的顺序决定的。静态语句块中只能访问到定义在静态语句块之前的变量,定义在它之后的变量,在前面的静态语句块中可以赋值,但是不可以访问。

    public class Test {
    	
    	static{
    		i=0; //给变量赋值可以正常编译通过
    		System.out.println(i); //编译器会提示非法向前引用
    	}
    	static int i=1;
    }

        (2)<clinit>()方法与实例构造器<init>()方法不同,它不需要显示调用父类构造器,虚拟机会保证子类的<clinit>()方法执行之前,父类的<clinit>()方法已经执行完毕,所以父类中定义的静态语句块要优先于子类的变量赋值操作,虚拟机中第一个被执行的<clinit>()方法的类是java.lang.Object。

        (3)<clinit>()方法对于类或接口并不是必需的,如果一个类中没有静态语句块,也就没有对变量的赋值操作,那么编译器可以不为这个类生成<clinit>()方法。

        (4)接口中不能使用静态语句块,仍然有变量初始化操作,因此仍然会生成<clinit>()方法,与类不同的是,执行接口中的<clinit>()方法不需要先执行父接口的<clinit>()方法。只有父接口中定义的变量被使用是,才需要初始化父接口,同时,接口实现类在初始化时也不会执行接口的<clinit>()方法。

        (5)<clinit>()方法在多线程环境中被正确的加锁、同步,多个线程同时去初始化一个类,只会有一个线程执行<clinit>()方法,其他线程则需要阻塞等待,直到活动线程执行<clinit>()方法完毕,活动线程执行完毕后,其他线程唤醒后被不会再次进入<clinit>()方法,因为同一个类加载器下,一个类型只会被初始化一次。

    展开全文
  • 当前由于缺乏完整的转换规则描述和相应的实现机制,难以实现灵活、自动的模型转换。采用基于本体的方法来建立模型元素之间的映射关系,并结合本体描述语言给出了模型元素和转换规则在本体库中的描述方法,实现了在两...
  • 数据库设计工具Power Designer采用模型驱动机制,通过包括需求模型、业务流程模型、概念数据模型、物理数据模型、面向对象模型、多模型报告的多模型建立和转换,为软件开发实现全程建模提供了一种切实可行的软件开发...
  • 类加载机制:虚拟机把描述类的数据从class文件加载到内存,并对数据进行校验、转换解析和初始化,最终形成可以被虚拟机直接使用的Java类型。 类加载时机:类的生命周期是从类被加载到虚拟机内存中,到卸载内存...

      类加载机制:虚拟机把描述类的数据从class文件加载到内存,并对数据进行校验、转换解析和初始化,最终形成可以被虚拟机直接使用的Java类型。


      类加载时机:类的生命周期是从类被加载到虚拟机内存中,到卸载内存为止。

      类的生命周期:加载 loading ---> 连接(验证 verification 准备 preparation 解析 resolution) ---> 初始化 initialization ---> 使用 using --- > 卸载 unloading

      类加载过程
          加载
              1.从Class文件获取二进制字节流
              2.将字节流中的静态结构转化为方法区的运行时的动态结构
              3.在内存中生成代表该Class的java.lang.Class对象,作为方法区该类的访问入口。
          连接
              验证:验证Class文件的字节流中包含的信息是否符合JVM的要求,并确保不会危害JVM自身的安全。
              准备:为静态变量分配内存并赋初始值
              解析:将常量池内的符号引用转换为直接引用
          初始化

              调用类的clinit()方法,为静态变量赋予实际的值,执行静态代码块

      双亲委派模型过程:某个特定的类加载器在接到加载类的请求时,首先将加载任务委托父类加载器,依次递归,如果父类加载器可以完成类加载任务,就成功返回;只有父类加载器无法完成此加载任务时,才自己去加载。

      双亲委派模型的好处:在于Java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如类java.lang.Object,它存在在rt.jar中,无论哪一个类加载器要加载这个类,最终都是委派给处于模型最顶端的Bootstrap ClassLoader进行加载,因此Object类在程序的各种类加载器环境中都是同一个类。相反,如果没有双亲委派模型而是由各个类加载器自行加载的话,如果用户编写了一个java.lang.Object的同名类并放在ClassPath中,那系统中将会出现多个不同的Object类,程序将混乱。因此,如果开发者尝试编写一个与rt.jar类库中重名的Java类,
    可以正常编译,但是永远无法被加载运行。

     

    虚拟机只有在两个类的类名相同且加载该类的加载器均相同的情况下才判定这是一个类。若不采用双亲委派机制,同一个类有可能被多个类加载器加载,这样该类会被识别为两个不同的类,相互赋值时会有问题。

    双亲委派机制能保证多加载器加载某个类时,最终都是由一个加载器加载,确保最终加载结果相同。

    转载于:https://www.cnblogs.com/hetaoyuan/p/11401799.html

    展开全文
  • 虚拟机把描述类的数据从class文件加载到内存,并对数据进行校验、转换解析和初始化,最终形成可以被虚拟机直接使用的java类型,这就是类加载机制。 类生命周期: 双亲委派模型 先介绍三种类加载器 启动类加载器...

    类加载机制
    虚拟机把描述类的数据从class文件加载到内存,并对数据进行校验、转换解析和初始化,最终形成可以被虚拟机直接使用的java类型,这就是类加载机制。
    类生命周期:
    在这里插入图片描述
    双亲委派模型
    先介绍三种类加载器
    启动类加载器(Bootstrap ClassLoader),是虚拟机自身的一部分,用来加载JAVA_HOME/lib/目录中的,或者被-Xbootclasspath参数所指定的路径中并且被虚拟机识别的类库。
    扩展类加载器:
    应用程序类加载器:
    在这里插入图片描述
    双亲委派模型的工作过程:
    一个类加载器收到了类加载的请求,不会自己加载这个类,会将加载请求委派给自己的父类加载器完成,每一层请求都是如此,因此所有的加载请求都会传送到启动类加载器,只有当父加载器不能处理加载请求时,子加载器才会自己尝试自己加载。

    展开全文
  • 上节我们基于U-Net模型设计并实现了在医学细胞分割上的应用(ISBI 挑战数据集),并给出了模型的详细代码解释,在上个博客中,我们为了快速训练U-Net模型对其进行了缩减,将庞大的U-Net的转换为很小&的结构,...

    1.摘要

    上节我们基于U-Net模型设计并实现了在医学细胞分割上的应用(ISBI 挑战数据集),并给出了模型的详细代码解释,在上个博客中,我们为了快速训练U-Net模型对其进行了缩减,将庞大的U-Net的转换为很小&的结构,导致其准确率才达到75%左右。为了进一步提高U-Net模型在细胞分割上的准确率,本文将主要研究两个方面:一是基于U-Net的原始模型结构进行改进,引入卷积注意力机制模块(CBAM)和Focal Tversky损失函数;二是引入深监督方法(DEEP SUPERVISION)及多尺度输入作为U-Net模型的原始输入,该模型被命名为DAMU-Net。为了进一步验证该模型的性能,我们同样在ISBI 挑战数据集上进行实验,并给出相应的实验结果。

    2.相关技术概述

    2.1 Focal Tversky损失函数

    医学影像中存在很多的数据不平衡现象,使用不平衡数据进行训练会导致严重偏向高精度但低召回率(sensitivity)的预测,这是我们不希望的,特别是在医学应用中,假阴性比假阳性多更难容忍。而Tversky广义损失函数可以有效解决了三维全卷积深神经网络训练中数据不平衡的问题,在精度和召回率之间找到更好的平衡。与Focal loss相似,Focal Tversky Loss着重于通过通过调整超参数α和β,我们可以控制假阳性和假阴性之间的权衡。较大的β会使召回的准确性高于精确度(通过更加强调假阴性)。其公式如下:

    preview

    2.2  深监督方法

      所谓深监督(Deep Supervision),就是在深度神经网络的某些中间隐藏层加了一个辅助的分类器作为一种网络分支来对主干网络进行监督的技巧,用来解决深度神经网络训练梯度消失和收敛速度过慢等问题。 深监督作为一个训练trick在2014年就已经通过DSN(Deeply-Supervised Nets)提出来了.

     通常而言,增加神经网络的深度可以一定程度上提高网络的表征能力,但随着深度加深,会逐渐出现神经网络难以训练的情况,其中就包括像梯度消失和梯度爆炸等现象。为了更好的训练深度网络,人们尝试给神经网络的某些层添加一些辅助的分支分类器来解决这个问题。这种辅助的分支分类器能够起到一种判断隐藏层特征图质量好坏的作用。其结构如下:

    其中各个模块含义如下:

     可以看到,图中在第四个卷积块之后添加了一个监督分类器作为分支。Conv4输出的特征图除了随着主网络进入Conv5之外,也作为输入进入了分支分类器。往往分支与主网络一起训练。

    3.模型实现

    为了在精确性和召回性之间实现进一步的平衡,本文设计实现一种基于卷积注意力机制的U-Net模型, 该体 系结构基于流行的UNet,并将输入图像的多尺寸特征张量作为输入,以便更好的提取局部特征。其模型结构如图所示:

    为了进一步细化模型实验,我们将分三个步骤实现上述最终模型。

    3.1 基于卷积注意力机制的U-Net模型

    该模型只是单纯的将注意力机制引入U-Net模型中,目的是将输入图像的低级特征映射中识别相关的空间信息,并将其传播到解码阶段,以达到真正地提取出积极有效的特征。其具体代码实现可以查看上篇博客https://haosen.blog.csdn.net/article/details/117755633。在该博客中有模型的具体结构图及代码实现。
     

    3.2 基于卷积注意力机制和深监督的U-Net模型

    其具体代码实现可以查看上篇博客https://haosen.blog.csdn.net/article/details/117756027

    3.3 模型代码实现

    def attn_reg(opt,input_size, lossfxn):
        
        img_input = Input(shape=input_size, name='input_scale1')
        scale_img_2 = AveragePooling2D(pool_size=(2, 2), name='input_scale2')(img_input)
        scale_img_3 = AveragePooling2D(pool_size=(2, 2), name='input_scale3')(scale_img_2)
        scale_img_4 = AveragePooling2D(pool_size=(2, 2), name='input_scale4')(scale_img_3)
    
        conv1 = UnetConv2D(img_input, 32, is_batchnorm=True, name='conv1')
        pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
        
        input2 = Conv2D(64, (3, 3), padding='same', activation='relu', name='conv_scale2')(scale_img_2)
        input2 = concatenate([input2, pool1], axis=3)
        conv2 = UnetConv2D(input2, 64, is_batchnorm=True, name='conv2')
        pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
        
        input3 = Conv2D(128, (3, 3), padding='same', activation='relu', name='conv_scale3')(scale_img_3)
        input3 = concatenate([input3, pool2], axis=3)
        conv3 = UnetConv2D(input3, 128, is_batchnorm=True, name='conv3')
        pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
        
        input4 = Conv2D(256, (3, 3), padding='same', activation='relu', name='conv_scale4')(scale_img_4)
        input4 = concatenate([input4, pool3], axis=3)
        conv4 = UnetConv2D(input4, 64, is_batchnorm=True, name='conv4')
        pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
            
        center = UnetConv2D(pool4, 512, is_batchnorm=True, name='center')
        
        g1 = UnetGatingSignal(center, is_batchnorm=True, name='g1')
        attn1 = AttnGatingBlock(conv4, g1, 128, '_1')
        up1 = concatenate([Conv2DTranspose(32, (3,3), strides=(2,2), padding='same', activation='relu', kernel_initializer=kinit)(center), attn1], name='up1')
    
        g2 = UnetGatingSignal(up1, is_batchnorm=True, name='g2')
        attn2 = AttnGatingBlock(conv3, g2, 64, '_2')
        up2 = concatenate([Conv2DTranspose(64, (3,3), strides=(2,2), padding='same', activation='relu', kernel_initializer=kinit)(up1), attn2], name='up2')
    
        g3 = UnetGatingSignal(up1, is_batchnorm=True, name='g3')
        attn3 = AttnGatingBlock(conv2, g3, 32, '_3')
        up3 = concatenate([Conv2DTranspose(32, (3,3), strides=(2,2), padding='same', activation='relu', kernel_initializer=kinit)(up2), attn3], name='up3')
    
        up4 = concatenate([Conv2DTranspose(32, (3,3), strides=(2,2), padding='same', activation='relu', kernel_initializer=kinit)(up3), conv1], name='up4')
        
        conv6 = UnetConv2D(up1, 256, is_batchnorm=True, name='conv6')
        conv7 = UnetConv2D(up2, 128, is_batchnorm=True, name='conv7')
        conv8 = UnetConv2D(up3, 64, is_batchnorm=True, name='conv8')
        conv9 = UnetConv2D(up4, 32, is_batchnorm=True, name='conv9')
    
        out6 = Conv2D(1, (1, 1), activation='sigmoid', name='pred1')(conv6)
        out7 = Conv2D(1, (1, 1), activation='sigmoid', name='pred2')(conv7)
        out8 = Conv2D(1, (1, 1), activation='sigmoid', name='pred3')(conv8)
        out9 = Conv2D(1, (1, 1), activation='sigmoid', name='final')(conv9)
    
        model = Model(inputs=[img_input], outputs=[out6, out7, out8, out9])
     
        loss = {'pred1':lossfxn,
                'pred2':lossfxn,
                'pred3':lossfxn,
                'final': losses.tversky_loss}
        
        loss_weights = {'pred1':1,
                        'pred2':1,
                        'pred3':1,
                        'final':1}
        model.compile(optimizer=opt, loss=loss, loss_weights=loss_weights,
                      metrics=[losses.dsc])
        model.summary()
    
        from keras.utils.vis_utils import plot_model
        plot_model(model, to_file='model1.png', show_shapes=True)
        return model
    

    模型参数结构图(点击观看) 

    4. 实验结果

    模型

      DES

    U-Net

    0.878

    ATT-U-Net

    DATT-U-Net

    DAMU-Net

     

    还有一些结果正在用CPU运行,太慢了.....

     

     

    展开全文
  • 而JVM把Class文件中的类描述数据从文件加载到内存,并对数据进行校验、转换解析、初始化,使这些数据最终成为可以被JVM直接使用的Java类型,这个过程叫做JVM的类加载机制。 2、在JDK1.8以及之前,类加载器大概分为...
  • 虚拟机把描述类的数据从Class文件加载到内存,并对数据进行校验、转换解析和初始化,最终形成可以被虚拟机直接使用的Java类,这就是虚拟机的类加载机制。 在Java语言里面,类型加载、连接和初始化过程都是在程序...
  • 一、Java类加载机制 1.概述 Class文件由类装载器装载后,在JVM中将形成一份描述Class结构的元信息对象,通过该元信息对象可以获知Class的结构信息:如构造函数,属性和方法等,Java允许用户借由这个Class相关的...
  • 分词,分词的目的就是将字符串转换成单词组成的列表。目前有很多现成的分词工具可以直接使用,也可以直接按照空格进行分词(不推荐,因为分词不是很准确) 建立词典,将单词组成的列表编程单词id组成的列表,这里会...
  • 序列模型和注意力机制 Seq2Seq 模型 Seq2Seq(Sequence-to-Sequence)模型能够应用于机器翻译、语音识别等各种序列到序列的转换问题。一个 Seq2Seq 模型包含编码器(Encoder)和解码器(Decoder)两部分,它们通常...
  • 序列模型中的注意力机制

    万次阅读 2017-07-15 23:43:48
    现在很多研究的NLP问题都可以转换成一个Sequence to Sequence模型来解决,比如说机器翻译,智能问答,语音识别等。 Sequence to Sequence模型由一个encoder和一个decoder组成,encoder完成编码工作,将不同的输入...
  • java虚拟机把描述类的数据从Class文件加载到内存,并对数据进行校验、转换解析和初始化,最终形成可以被虚拟机直接使用的java类型,这就是虚拟机的类加载机制。 上面这段是《深入理解java虚拟机》中对类加载的...
  • 简要介绍社会困境的涵义,详细阐述博弈决策的理性选择理论、认知转换理论和生物进化理论,并且从认知控制、社会认知以及奖励预期3个过程揭示博弈决策的神经机制.未来研究应力求突破先前理论模型的不足,深入考察个体...
  • 针对现有行人仿真模型在行为特性表示不全面和建筑物空间结构表达、空间单元状态的动态存储及转换、仿真过程及结果可视化等方面存在的缺陷,提出了基于双层协作机制的双向行人流仿真模型.通过对南京地铁新街口站换乘...
  • 将 “.Java” 的类文件 转换成 “.class” 的字节码文件 。 然后JVM负责执行 “.class” 文件。 2.类加载过程? 5 个阶段:载入、验证、准备、解析和初始化 这 5 个阶段一般是顺序发生的,但在动态绑定的情况下...
  • 从.class文件加载到内存,并对数据进行校验、转换解析和初始化,最终形成可被虚拟机直接使用的Java类型的过程就是运行期,也就是标题所说的类加载过程。 (红色框代表的就是类加载过程) 具体过程 『加载』...
  • 一、虚拟机类加载机制 虚拟机把描述类的数据从class文件加载到内存,并对数据进行校验、转换解析和初始化,最终形成可以被虚拟机直接使用的Java类型。 二、类的生命周期  类的生命周期是从类被加载到虚拟机的...
  • 研究了社会化协作与小农生产方式两种状态转换机制 ,明确了交易收益等于通过交易节约的自给自足生产所需额外投入的资源 ,交易支出等于交易成本 ,建立了一个 Stackelberg...

空空如也

空空如也

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

机制转换模型