精华内容
下载资源
问答
  • 区域的含义及特征
    2019-07-31 15:18:28

    什么是进程?

         概念:进程是操作系统动态执行的基本单元,进程就可以说是运行的一段程序(程序:存储在磁盘的可执行文件,当我们有很多程序同时执行时,就有了一种类似于排队的模式,就比如说我去银行柜台取钱,为了同时进行,我们可以规定让每一个人一次性只能取500块钱,取完之后,下一个人接着取,如此循环,先取完钱就相当于程序执行完了,然后慢的就继续刚刚的排队

           进程是指一个内存中运行中的应用程序。每个进程都有自己独立的一块内存空间,一个应用程序可以同时启动多个进程。比如在Windows系统中,一个运行的abc.exe 就是一个进程事例。

        组成: 进程是一个实体。每一个进程都有它的地址空间,一般情况下,包括文本区域(.text)、数据区域(.data)、堆栈(stack、queue)。文本区域存储处理器执行的代码;数据区域存储变量和进程执行期间使用的动态内部分配的内存;堆栈区域存储着活动区域调用的指令和本地变量。

       结构: 进程是由 程序、数据、进程控制块三部分组成。

       基本状态转换图:

         运行:CPU在执行进程的命令

         就绪:等待CPU执行的进程

         就绪:等待I/O 事件发生

    进程描述符PCB:

         为了描述控制进程的运行,系统中存放进程的管理和控制信息的数据结构称为 进程控制块PCB,他是进程实体的一部分是操作系统中重要的记录性数据结构。是进程管理和控制的最重要的数据结构。

         每一个进程都有一个PCB,在创建进程的时候,建立PCB,伴随进程运行的全过程,直到进程撤销而撤销,PCB记录了操作系统所需的,用于描述进程的当前情况和控制进程运行的全部信息(如打开的文件,挂起的信号、进程状态、地址空间等等)

        在linux中每一个进程都由task_struct数据结构定义。task_struct就是我们常说的PCB。它是对进程控制的唯一手段也是最有效的手段。当我们调用fork()时,系统会为我们产生一个task_struct结构,然后从父进程那里继承一些数据,并把新的进程插入到进程树中,以待进程管理。因此了解task_struct的结构对于我们理解进程调度的关键。

        进程新产生时,必须先分配PCB结构,后生成进程主体。

        进程结束时,先释放主体,然后才会释放PCB结构。

        一个进程大概1.7K。

    什么是线程?

         概念:线程是操作系统动态执行的最小单元,为什么要引入线程,因为比如你取完钱还有比较重要的事情去做,所以你希望快点把钱取出来,然后你就可以让你的朋友过来和你一块排队,这样取钱的速度就会变快,你叫的朋友就可以理解为 多个线程。我们通常把进程作为分配资源的基本,而线程基本不用资源,所以系统对它的调度开销会小一些,能够更高效的提高多个程序同时执行的效率

         线程是进程中的一个执行任务(控制单元),是进程中的一个实体,是被系统独立调度和分派的基本单元,线程自己不拥有系统资源,只拥有一点在运行中必不可少的资源,但是它和同属一个进程的其他线程共享进程所拥有的全部资源。

    一个进程可以同时并发运行多个线程,如上述例子中,我可以叫来很多个我的朋友同时帮我取钱,每一个朋友在排队帮我去取钱的过程都可以理解为一个线程,而这整个取钱过程为进程。

    线程之间的关系:

    一个线程可以创建和撤销另一个线程,同一进程中的多个进程之间可以并发执行。由于线程之间的相互制约,致使线程在运行中呈现间断性,线程也有堵塞、运行、就绪三种状态。

    特点:

          1.轻型实体(线程的实体包括程序、数据和TCB。TCB用于指示被执行指令序列的程序计数器、保留局部变量、少数状态参数和返回地址等的一组寄存器和堆栈)

          2.独立调度和分配的基本单元

          3. 可并发执行

          4. 共享进程资源(所有线程都具有相同的地址空间(进程的地址空间),这意味着,线程可以访问该地址空间的每一个虚地址;此外,还可以访问进程所拥有的已打开文件、定时器、信号量机构等。由于同一个进程间的线程共享内存和文件,所以线程之间互相通信不必调用内核。)

    多进程:操作系统中同时运行的多个程序。

    多线程:在同一个进程中同时运行的多个任务。

     

    进程和线程有什么区别?

     1.进程是资源分配的基本单位,线程是CPU调度,或者说是程序执行的最小单位。

     2.进程有独立的地址空间,启动一个新的进程,系统必须为分配给它独立的地址空间,建立众多的数据表来维护它的代码段、数据段和堆栈段。而运行一个进程中的线程,它们之间共享大部分数据,使用相同的地址空间(堆空间是共享的,栈空间是独立的,线程消耗的资源比较小,相互之间可以影响),当然,线程是拥有自己的局部变量和堆栈。

    3.线程之间的通信比较方便。统一进程下的线程共享数据(比如全局变量,静态变量),通过这些数据来通信不仅快捷而且方便,当然如何处理好这些访问的同步和互斥正是编写多线程的难点。而进程之间的通信只能通过进程通信的方式进行;

    4.线程的执行与进程是有区别的。每个独立的线程有自己的一个程序入口,顺序执行序列和程序的出口,但是线程不能独立执行,必须依附在程序之中由应用程序提供多个线程的并发控制。

    5.一个进程中的多个线程是并发运行的,那么从微观角度上考虑也是有优先顺序的,那么哪个线程执行完全取决于CPU调度器(JVM来调度),程序员是控制不了的。

     

    我们可以把多线程并发性看成是多个线程在瞬间抢夺CPU资源,谁抢到资源谁就运行,这也造就了多线程的随机性。

    多线程是通过提高系统资源的利用率来提高我们的运行效率,多线程之间是资源共享的。

    更多相关内容
  • 区域经济发展战略的含义特征.docx
  • 高中地理第一章区域地理环境与人类活动第一节区域的基本含义区域的主要特征同步练习湘教版必修320180827349
  • 在阐释瓦斯异常区域含义及特点的基础上,综述了国内外针对瓦斯异常区域的探测技术现状,总体上包括接触式探测和非接触式探测两种方式。接触式探测主要通过钻孔施工过程中发生的顶钻、夹钻、吸钻、喷孔等各种物理现象来...
  • 1专题11区域定位与区域地理特征分析1.区域含义。2.不同区域自然环境、人类活动的差异。3.不同发展阶段地理环境对人类生产和生活方式的影响。4.根据区域图判断区域的空间位置。结合区域图,综合分析区域
  • 区域可持续发展的信息特征具有时空性和复杂性的特点。在总结前人区域可持续发展相关研究的基础上,提出区域可持续发展信息特征分类的原则和综合分类方法。依据区域可持续发展的三维系统理论(即区域系统在时间上/...
  • 浅析人力资源开发对区域经济发展的影响对策.docx
  • 在图像处理当中对图像进行预处理,获得感兴趣的区域,可以提高图像处理的速度;...在halcon 中 求Region指定特征值:region_features(Regions : : Features : Value)然后就可以根据获取的特征值选择区域:sele...

    在图像处理当中对图像进行预处理,获得感兴趣的区域,可以提高图像处理的速度;

    当我们想要提取Region时,图像简单处理后,往往存在几个类似的Region,此时,需要根据Region的一些特殊特征,来选择指定的Region。

    在halcon 中 求Region指定特征值:region_features(Regions : : Features : Value)

    然后就可以根据获取的特征值选择区域:select_shape(Regions: SelectedRegions : Features, Operation, Min, Max : )

    图像区域特征众多,对每个特征的理解,是使用前面两个函数的前提。下面表格罗列出的区域特征说明

    Region特征一览:特征英译取值范围

    AreaArea of the object区域的面积,可通过area_center得到

    RowRow index of the center中心点的行坐标,可通过area_center得到

    columnColumn index of the center中心点的列坐标,可通过area_center得到

    widthWidth of the region区域的宽度,参考inner_rectangle1,得到的参数

    heightHeight of the region区域的高度,参考inner_rectangle1,得到的参数

    row1Row index of upper left corner左上角行坐标,参考inner_rectangle1,得到的参数

    column1Column index of upper left corner左上角列坐标,参考inner_rectangle1,得到的参数

    row2Row index of lower right corner右下角行坐标,参考inner_rectangle1,得到的参数

    column2Column index of lower right corner右下角列坐标,参考inner_rectangle1,得到的参数

    circularityCircularity圆度,可通过circularity得到0~1

    compactnessCompactness紧密度,可通过compactness得到0~1

    contlengthTotal length of contour轮廓线总长,可通过contlength得到

    convexityConvexity凸度,最外全部像素点围成的面积与原始面积的比值,可百度查阅凸度概念,可通过convexity得到

    rectangularityRectangularity矩形度,可通过rectangularity得到0~1

    RaMain radius of the equivalent ellipse等效椭圆长轴半径长度,通过elliptic_axis得到

    RbSecondary radius of the equivalent ellipse等效椭圆短轴半径长度,通过elliptic_axis得到

    PhiOrientation of the equivalent ellipse等效椭圆方向,通过elliptic_axis得到

    anisometryAnisometry椭圆离心率,Ra/Rb长轴与短轴的比值

    bulkinessBulkiness椭圆蓬松度π*Ra*Rb/A,A为面积可用area_center获得

    struct_factorStructur Factor椭圆结构系数,Anisometry*Bulkiness-1

    outer_radiusRadius of smallest surrounding circle最小外接圆半径,可用smallest_circle获取圆中心与半径,绘制圆查看效果

    inner_radiusRadius of largest inner circle最大内接圆半径,可用inner_circle,获取参数,绘制圆查看效果

    inner_widthWidth of the largest axis-parallel rectangle that fits  into the region最大轴平行内接矩形宽度,可用inner_rectangle1获取参数,绘制矩形查看效果

    inner_heightHeight of the largest axis-parallel rectangle that fits  into the region最大轴平行内接矩形高度,可用inner_rectangle1获取参数,绘制矩形查看效果

    dist_meanMean distance from the region border to the center区域边界到中心的平均距离,roundness获得

    dist_deviationDeviation of the distance from the region border from  the center区域边界到中心距离的偏差,roundness获得

    roundnessRoundness圆度,与circularity计算方法不同,roundness获得

    num_sidesNumber of polygon sides多边形边数,roundness获得

    connect_numNumber of connection components连通数,connect_and_holes获得

    holes_numNumber of holes区域内洞数,connect_and_holes获得

    area_holesArea of the holes of the object所有洞的面积之和,area_holes获得

    max_diameterMaximum diameter of the region区域最大直径,diameter_region获得

    orientationOrientation of the region区域方向,orientation_region获得

    euler_numberEuler number欧拉数,即连通数和洞数的差,euler_number获得

    rect2_phiOrientation of the smallest surrounding rectangle最小外接矩形的方向,smallest_rectangle2获得

    rect2_len1Half the length of the smallest surrounding rectangle最小外接矩形高一半,smallest_rectangle2获得

    rect2_len2Half the width of the smallest surrounding rectangle最小外接矩形宽一半,smallest_rectangle2获得

    moments_m11Geometric moments of the region几何矩

    moments_m20Geometric moments of the region几何矩

    moments_m02Geometric moments of the region几何矩

    moments_iaGeometric moments of the region几何矩

    moments_ibGeometric moments of the region几何矩

    moments_m11_invarGeometric moments of the region几何矩

    moments_m20_invarGeometric moments of the region几何矩

    moments_m02_invarGeometric moments of the region几何矩

    moments_phi1Geometric moments of the region几何矩

    moments_phi2Geometric moments of the region几何矩

    moments_m21Geometric moments of the region几何矩

    moments_m12Geometric moments of the region几何矩

    moments_m03Geometric moments of the region几何矩

    moments_m30Geometric moments of the region几何矩

    moments_m21_invarGeometric moments of the region几何矩

    moments_m12_invarGeometric moments of the region几何矩

    moments_m03_invarGeometric moments of the region几何矩

    moments_m30_invarGeometric moments of the region几何矩

    moments_i1Geometric moments of the region几何矩

    moments_i2Geometric moments of the region几何矩

    moments_i3Geometric moments of the region几何矩

    moments_i4Geometric moments of the region几何矩

    moments_psi1Geometric moments of the region几何矩

    moments_psi2Geometric moments of the region几何矩

    moments_psi3Geometric moments of the region几何矩

    moments_psi4Geometric moments of the region几何矩

    表格中出现很多类型的几何矩。

    矩是描述图像特征的算子,如今矩技术已广泛应用于图像检索和识别 、图像匹配 、图像重建、数字压缩 、数字水印及运动图像序列分析等领域。

    常见的矩描述子可以分为以下几种:几何矩、正交矩、复数矩和旋转矩 。

    其中几何矩提出的时间最早且形式简单,对它的研究最为充分。

    几何矩对简单图像有一定的描述能力,他虽然在区分度上不如其他三种矩,但与其他几种算子比较起来,他极其的简单,一般只需用一个数字就可表达。

    所以,一般我们是用来做大粒度的区分,用来过滤显然不相关的文档

    图像的几何矩这里先不进行讲解,仅介绍常用的区域特征;

    可以halcon中使用下面代码测试查看表格中37个区域特征的效果(fabrik为其自带图片)

    dev_close_window()

    read_image(Image,'fabrik')

    dev_open_window(0, 0, 512, 512, 'black', hWnd)

    threshold (Image, Regions, 160, 255)

    connection(Regions,con)

    *0.区域属性都可打开特征检测工具查看

    select_shape(con,sel,'area', 'and', 7000, 100000)

    *fill_up(sel,sel)

    *1.面积计算

    *area_center(sel,area,row,col)

    dev_set_draw('margin')

    dev_display(Image)

    dev_display(sel)

    dev_set_color('blue')

    *2.圆度计算

    *circularity(sel,Circularity)

    *3.紧密度计算

    *compactness(sel,Compactness)

    *4.轮廓线总长计算

    *contlength(sel,ContLength)

    *5.矩形度计算

    *rectangularity(sel,Rectangularity)

    *6.等效椭圆方向/长轴/短轴/半径长度计算

    *elliptic_axis(sel, Ra, Rb, Phi)

    *area_center(sel,area,row,col)

    *gen_ellipse(ellip,row,col,Phi,Ra,Rb)

    *7.椭圆离心率/蓬松度/结构系数计算

    *eccentricity(sel,anisometry,bulkiness,struc)

    *8.最小外接圆半径

    *smallest_circle(sel,row,column,radius)

    *gen_circle(circle,row,column,radius)

    *9.最大内接圆半径

    *inner_circle(sel,row,column,radius)

    *gen_circle(circle,row,column,radius)

    *10.最大轴平行内接矩形宽度/高度col1-col,row1-row

    inner_rectangle1(sel,row,col,row1,col1)

    gen_rectangle1(rec,row,col,row1,col1)

    *11.区域边界到中心的平均距离/中心距离偏差/圆度/多边形边数

    *roundness(sel,Distance, Sigma, Roundness, Sides)

    *12.区域的连通数/洞数

    *connect_and_holes(sel,NumConnected, NumHoles)

    *13.区域内所有洞的面积之和

    *area_holes(sel,Area)

    *14.区域最大半径

    *diameter_region(sel,row1,col1,row2,col2,dia)

    *disp_line(hWnd, row1, col1, row2, col2)

    *15.区域角度

    *orientation_region(sel,phi)

    *row:=300+100*sin(phi)

    *column:=300+100*cos(phi)

    *disp_arrow(hWnd, 300, 300, row, column,1)

    *16.欧拉数,即连通数和洞数之差

    *euler_number(sel,num)

    *17.最小外接矩形的方向/一半高/一半宽

    *smallest_rectangle2(sel,row,col,phi,hei,wid)

    *gen_rectangle2(rec,row,col,phi,hei,wid)

    *gen_rectangle1(sel,row,col,row+hei,col+wid)复制代码

    对这些区域特征含义及效果了解后,就可以很方便的进行区域选择操作,如选择下图竖线

    1.jpg (68.99 KB, 下载次数: 2)

    上位机通过halcon中图像区域特征选择指定区域

    2017-6-5 12:26 上传

    dev_close_window()

    read_image(Image,'1.jpg')

    dev_open_window(0, 0, 512, 512, 'black', hWnd)

    rgb1_to_gray(Image,rgb)

    dev_display(rgb)

    threshold (rgb, Regions, 160, 255)

    connection(Regions,con)

    select_shape(con,sel,'rect2_len1','and',25,80)

    select_shape(sel,sel,'column','and',340,380)

    fill_up(sel,fil)

    count_obj(fil,Number)

    smallest_rectangle2(fil,Row, Column, Phi, Length1, Length2)

    gen_rectangle2(rec,Row, Column, Phi, Length1, Length2)

    dev_display(rgb)

    dev_display(rec)复制代码

    图片保存为1.jpg,与工程文件同级目录,得出效果图

    2.JPG (55.5 KB, 下载次数: 0)

    上位机通过halcon中图像区域特征选择指定区域

    2017-6-5 12:28 上传

    select_shape函数的例程可在halcon按F1,打开编程手册,搜索获得

    展开全文
  • YOLOv3学习——特征提取与候选区域

    千次阅读 2022-02-12 19:55:54
    通过连续使用多层卷积和池化等操作,能得到语义含义更加丰富的特征图。在检测问题中,也使用卷积神经网络逐层提取图像特征,通过最终的输出特征图来表征物体位置和类别等信息。 YOLOv3算法使用的骨干网络是Darknet53...

    YOLOv3学习——特征提取


    前言

    卷积神经网络提取特征

    在上一节图像分类的课程中,我们已经学习过了通过卷积神经网络提取图像特征。通过连续使用多层卷积和池化等操作,能得到语义含义更加丰富的特征图。在检测问题中,也使用卷积神经网络逐层提取图像特征,通过最终的输出特征图来表征物体位置和类别等信息。

    YOLOv3算法使用的骨干网络是Darknet53。Darknet53网络的具体结构如 图1 所示,在ImageNet图像分类任务上取得了很好的成绩。在检测任务中,将图中C0后面的平均池化、全连接层和Softmax去掉,保留从输入到C0部分的网络结构,作为检测模型的基础网络结构,也称为骨干网络。YOLOv3模型会在骨干网络的基础上,再添加检测相关的网络模块。



    图1:Darknet53网络结构

    下面的程序是Darknet53骨干网络的实现代码,这里将上图中C0、C1、C2所表示的输出数据取出,并查看它们的形状分别是, C 0 [ 1 , 1024 , 20 , 20 ] C0 [1, 1024, 20, 20] C0[1,1024,20,20] C 1 [ 1 , 512 , 40 , 40 ] C1 [1, 512, 40, 40] C1[1,512,40,40] C 2 [ 1 , 256 , 80 , 80 ] C2 [1, 256, 80, 80] C2[1,256,80,80]

    • 名词解释:特征图的步幅(stride)

    在提取特征的过程中通常会使用步幅大于1的卷积或者池化,导致后面的特征图尺寸越来越小,特征图的步幅等于输入图片尺寸除以特征图尺寸。例如:C0的尺寸是 20 × 20 20\times20 20×20,原图尺寸是 640 × 640 640\times640 640×640,则C0的步幅是 640 20 = 32 \frac{640}{20}=32 20640=32。同理,C1的步幅是16,C2的步幅是8。

    import paddle
    import paddle.nn.functional as F
    import numpy as np
    
    class ConvBNLayer(paddle.nn.Layer):
        def __init__(self, ch_in, ch_out, 
                     kernel_size=3, stride=1, groups=1,
                     padding=0, act="leaky"):
            super(ConvBNLayer, self).__init__()
        
            self.conv = paddle.nn.Conv2D(
                in_channels=ch_in,
                out_channels=ch_out,
                kernel_size=kernel_size,
                stride=stride,
                padding=padding,
                groups=groups,
                weight_attr=paddle.ParamAttr(
                    initializer=paddle.nn.initializer.Normal(0., 0.02)),
                bias_attr=False)
        
            self.batch_norm = paddle.nn.BatchNorm2D(
                num_features=ch_out,
                weight_attr=paddle.ParamAttr(
                    initializer=paddle.nn.initializer.Normal(0., 0.02),
                    regularizer=paddle.regularizer.L2Decay(0.)),
                bias_attr=paddle.ParamAttr(
                    initializer=paddle.nn.initializer.Constant(0.0),
                    regularizer=paddle.regularizer.L2Decay(0.)))
            self.act = act
    
            
        def forward(self, inputs):
            out = self.conv(inputs)
            out = self.batch_norm(out)
            if self.act == 'leaky':
                out = F.leaky_relu(x=out, negative_slope=0.1)
            return out
        
    class DownSample(paddle.nn.Layer):
        # 下采样,图片尺寸减半,具体实现方式是使用stirde=2的卷积
        def __init__(self,
                     ch_in,
                     ch_out,
                     kernel_size=3,
                     stride=2,
                     padding=1):
    
            super(DownSample, self).__init__()
    
            self.conv_bn_layer = ConvBNLayer(
                ch_in=ch_in,
                ch_out=ch_out,
                kernel_size=kernel_size,
                stride=stride,
                padding=padding)
            self.ch_out = ch_out
        def forward(self, inputs):
            out = self.conv_bn_layer(inputs)
            return out
    
    class BasicBlock(paddle.nn.Layer):
        """
        基本残差块的定义,输入x经过两层卷积,然后接第二层卷积的输出和输入x相加
        """
        def __init__(self, ch_in, ch_out):
            super(BasicBlock, self).__init__()
    
            self.conv1 = ConvBNLayer(
                ch_in=ch_in,
                ch_out=ch_out,
                kernel_size=1,
                stride=1,
                padding=0
                )
            self.conv2 = ConvBNLayer(
                ch_in=ch_out,
                ch_out=ch_out*2,
                kernel_size=3,
                stride=1,
                padding=1
                )
        def forward(self, inputs):
            conv1 = self.conv1(inputs)
            conv2 = self.conv2(conv1)
            out = paddle.add(x=inputs, y=conv2)
            return out
    
         
    class LayerWarp(paddle.nn.Layer):
        """
        添加多层残差块,组成Darknet53网络的一个层级
        """
        def __init__(self, ch_in, ch_out, count, is_test=True):
            super(LayerWarp,self).__init__()
    
            self.basicblock0 = BasicBlock(ch_in,
                ch_out)
            self.res_out_list = []
            for i in range(1, count):
                res_out = self.add_sublayer("basic_block_%d" % (i), # 使用add_sublayer添加子层
                    BasicBlock(ch_out*2,
                        ch_out))
                self.res_out_list.append(res_out)
    
        def forward(self,inputs):
            y = self.basicblock0(inputs)
            for basic_block_i in self.res_out_list:
                y = basic_block_i(y)
            return y
    
    # DarkNet 每组残差块的个数,来自DarkNet的网络结构图
    DarkNet_cfg = {53: ([1, 2, 8, 8, 4])}
    
    class DarkNet53_conv_body(paddle.nn.Layer):
        def __init__(self):
            super(DarkNet53_conv_body, self).__init__()
            self.stages = DarkNet_cfg[53]
            self.stages = self.stages[0:5]
    
            # 第一层卷积
            self.conv0 = ConvBNLayer(
                ch_in=3,
                ch_out=32,
                kernel_size=3,
                stride=1,
                padding=1)
    
            # 下采样,使用stride=2的卷积来实现
            self.downsample0 = DownSample(
                ch_in=32,
                ch_out=32 * 2)
    
            # 添加各个层级的实现
            self.darknet53_conv_block_list = []
            self.downsample_list = []
            for i, stage in enumerate(self.stages):
                conv_block = self.add_sublayer(
                    "stage_%d" % (i),
                    LayerWarp(32*(2**(i+1)),
                    32*(2**i),
                    stage))
                self.darknet53_conv_block_list.append(conv_block)
            # 两个层级之间使用DownSample将尺寸减半
            for i in range(len(self.stages) - 1):
                downsample = self.add_sublayer(
                    "stage_%d_downsample" % i,
                    DownSample(ch_in=32*(2**(i+1)),
                        ch_out=32*(2**(i+2))))
                self.downsample_list.append(downsample)
    
        def forward(self,inputs):
            out = self.conv0(inputs)
            #print("conv1:",out.numpy())
            out = self.downsample0(out)
            #print("dy:",out.numpy())
            blocks = []
            for i, conv_block_i in enumerate(self.darknet53_conv_block_list): #依次将各个层级作用在输入上面
                out = conv_block_i(out)
                blocks.append(out)
                if i < len(self.stages) - 1:
                    out = self.downsample_list[i](out)
            return blocks[-1:-4:-1] # 将C0, C1, C2作为返回值
    
    
    # 查看Darknet53网络输出特征图
    import numpy as np
    backbone = DarkNet53_conv_body()
    x = np.random.randn(1, 3, 640, 640).astype('float32')
    x = paddle.to_tensor(x)
    C0, C1, C2 = backbone(x)
    print(C0.shape, C1.shape, C2.shape)
    

    根据输出特征图计算预测框位置和类别

    YOLOv3中对每个预测框计算逻辑如下:

    • 预测框是否包含物体。也可理解为objectness=1的概率是多少,可以用网络输出一个实数 x x x,可以用 S i g m o i d ( x ) Sigmoid(x) Sigmoid(x)表示objectness为正的概率 P o b j P_{obj} Pobj

    • 预测物体位置和形状。物体位置和形状 t x , t y , t w , t h t_x, t_y, t_w, t_h tx,ty,tw,th可以用网络输出4个实数来表示 t x , t y , t w , t h t_x, t_y, t_w, t_h tx,ty,tw,th

    • 预测物体类别。预测图像中物体的具体类别是什么,或者说其属于每个类别的概率分别是多少。总的类别数为C,需要预测物体属于每个类别的概率 ( P 1 , P 2 , . . . , P C ) (P_1, P_2, ..., P_C) (P1,P2,...,PC),可以用网络输出C个实数 ( x 1 , x 2 , . . . , x C ) (x_1, x_2, ..., x_C) (x1,x2,...,xC),对每个实数分别求Sigmoid函数,让 P i = S i g m o i d ( x i ) P_i = Sigmoid(x_i) Pi=Sigmoid(xi),则可以表示出物体属于每个类别的概率。

    对于一个预测框,网络需要输出 ( 5 + C ) (5 + C) (5+C)个实数来表征它是否包含物体、位置和形状尺寸以及属于每个类别的概率。

    由于我们在每个小方块区域都生成了K个预测框,则所有预测框一共需要网络输出的预测值数目是:

    [ K ( 5 + C ) ] × m × n [K(5 + C)] \times m \times n [K(5+C)]×m×n

    还有更重要的一点是网络输出必须要能区分出小方块区域的位置来,不能直接将特征图连接一个输出大小为 [ K ( 5 + C ) ] × m × n [K(5 + C)] \times m \times n [K(5+C)]×m×n的全连接层。

    建立输出特征图与预测框之间的关联

    现在观察特征图,经过多次卷积核池化之后,其步幅stride=32, 640 × 480 640 \times 480 640×480大小的输入图片变成了 20 × 15 20\times15 20×15的特征图;而小方块区域的数目正好是 20 × 15 20\times15 20×15,也就是说可以让特征图上每个像素点分别跟原图上一个小方块区域对应。这也是为什么我们最开始将小方块区域的尺寸设置为32的原因,这样可以巧妙的将小方块区域跟特征图上的像素点对应起来,解决了空间位置的对应关系。



    图2:特征图C0与小方块区域形状对比

    下面需要将像素点 ( i , j ) (i,j) (i,j)与第i行第j列的小方块区域所需要的预测值关联起来,每个小方块区域产生K个预测框,每个预测框需要 ( 5 + C ) (5 + C) (5+C)个实数预测值,则每个像素点相对应的要有 K ( 5 + C ) K(5 + C) K(5+C)个实数。为了解决这一问题,对特征图进行多次卷积,并将最终的输出通道数设置为 K ( 5 + C ) K(5 + C) K(5+C),即可将生成的特征图与每个预测框所需要的预测值巧妙的对应起来。当然,这种对应是为了将骨干网络提取的特征对接输出层来形成Loss。实际中,这几个尺寸可以随着任务数据分布的不同而调整,只要保证特征图输出尺寸(控制卷积核和下采样)和输出层尺寸(控制小方块区域的大小)相同即可。

    骨干网络的输出特征图是C0,下面的程序是对C0进行多次卷积以得到跟预测框相关的特征图P0。

    class YoloDetectionBlock(paddle.nn.Layer):
        # define YOLOv3 detection head
        # 使用多层卷积和BN提取特征
        def __init__(self,ch_in,ch_out,is_test=True):
            super(YoloDetectionBlock, self).__init__()
    
            assert ch_out % 2 == 0, \
                "channel {} cannot be divided by 2".format(ch_out)
    
            self.conv0 = ConvBNLayer(
                ch_in=ch_in,
                ch_out=ch_out,
                kernel_size=1,
                stride=1,
                padding=0)
            self.conv1 = ConvBNLayer(
                ch_in=ch_out,
                ch_out=ch_out*2,
                kernel_size=3,
                stride=1,
                padding=1)
            self.conv2 = ConvBNLayer(
                ch_in=ch_out*2,
                ch_out=ch_out,
                kernel_size=1,
                stride=1,
                padding=0)
            self.conv3 = ConvBNLayer(
                ch_in=ch_out,
                ch_out=ch_out*2,
                kernel_size=3,
                stride=1,
                padding=1)
            self.route = ConvBNLayer(
                ch_in=ch_out*2,
                ch_out=ch_out,
                kernel_size=1,
                stride=1,
                padding=0)
            self.tip = ConvBNLayer(
                ch_in=ch_out,
                ch_out=ch_out*2,
                kernel_size=3,
                stride=1,
                padding=1)
        def forward(self, inputs):
            out = self.conv0(inputs)
            out = self.conv1(out)
            out = self.conv2(out)
            out = self.conv3(out)
            route = self.route(out)
            tip = self.tip(route)
            return route, tip
    
    
    NUM_ANCHORS = 3
    NUM_CLASSES = 7
    num_filters=NUM_ANCHORS * (NUM_CLASSES + 5)
    
    backbone = DarkNet53_conv_body()
    detection = YoloDetectionBlock(ch_in=1024, ch_out=512)
    conv2d_pred = paddle.nn.Conv2D(in_channels=1024, out_channels=num_filters, kernel_size=1)
    
    x = np.random.randn(1, 3, 640, 640).astype('float32')
    x = paddle.to_tensor(x)
    C0, C1, C2 = backbone(x)
    route, tip = detection(C0)
    P0 = conv2d_pred(tip)
    
    print(P0.shape)
    

    如上面的代码所示,可以由特征图C0生成特征图P0,P0的形状是 [ 1 , 36 , 20 , 20 ] [1, 36, 20, 20] [1,36,20,20]。每个小方块区域生成的锚框或者预测框的数量是3,物体类别数目是7,每个区域需要的预测值个数是 3 × ( 5 + 7 ) = 36 3 \times (5 + 7) = 36 3×(5+7)=36,正好等于P0的输出通道数。

    P 0 [ t , 0 : 12 , i , j ] P0[t, 0:12, i, j] P0[t,0:12,i,j]与输入的第t张图片上小方块区域 ( i , j ) (i, j) (i,j)第1个预测框所需要的12个预测值对应, P 0 [ t , 12 : 24 , i , j ] P0[t, 12:24, i, j] P0[t,12:24,i,j]与输入的第t张图片上小方块区域 ( i , j ) (i, j) (i,j)第2个预测框所需要的12个预测值对应, P 0 [ t , 24 : 36 , i , j ] P0[t, 24:36, i, j] P0[t,24:36,i,j]与输入的第t张图片上小方块区域 ( i , j ) (i, j) (i,j)第3个预测框所需要的12个预测值对应。

    P 0 [ t , 0 : 4 , i , j ] P0[t, 0:4, i, j] P0[t,0:4,i,j]与输入的第t张图片上小方块区域 ( i , j ) (i, j) (i,j)第1个预测框的位置对应, P 0 [ t , 4 , i , j ] P0[t, 4, i, j] P0[t,4,i,j]与输入的第t张图片上小方块区域 ( i , j ) (i, j) (i,j)第1个预测框的objectness对应, P 0 [ t , 5 : 12 , i , j ] P0[t, 5:12, i, j] P0[t,5:12,i,j]与输入的第t张图片上小方块区域 ( i , j ) (i, j) (i,j)第1个预测框的类别对应。

    图3 所示,通过这种方式可以巧妙的将网络输出特征图,与每个小方块区域生成的预测框对应起来了。


    图3:特征图P0与候选区域的关联

    计算预测框是否包含物体的概率



    图:特征图P0与候选区域的关联

    根据前面的分析,$P0[t, 4, i, j]$与输入的第t张图片上小方块区域$(i, j)$第1个预测框的objectness对应,$P0[t, 4+12, i, j]$与第2个预测框的objectness对应,...,则可以使用下面的程序将objectness相关的预测取出,并使用`paddle.nn.functional.sigmoid`计算输出概率。
    NUM_ANCHORS = 3
    NUM_CLASSES = 7
    num_filters=NUM_ANCHORS * (NUM_CLASSES + 5)
    
    backbone = DarkNet53_conv_body()
    detection = YoloDetectionBlock(ch_in=1024, ch_out=512)
    conv2d_pred = paddle.nn.Conv2D(in_channels=1024, out_channels=num_filters,  kernel_size=1)
    
    x = np.random.randn(1, 3, 640, 640).astype('float32')
    x = paddle.to_tensor(x)
    C0, C1, C2 = backbone(x)
    route, tip = detection(C0)
    P0 = conv2d_pred(tip)
    
    reshaped_p0 = paddle.reshape(P0, [-1, NUM_ANCHORS, NUM_CLASSES + 5, P0.shape[2], P0.shape[3]])
    pred_objectness = reshaped_p0[:, :, 4, :, :]
    pred_objectness_probability = F.sigmoid(pred_objectness)
    print(pred_objectness.shape, pred_objectness_probability.shape)
    

    上面的输出程序显示,预测框是否包含物体的概率pred_objectness_probability,其数据形状是[1, 3, 20, 20],与我们上面提到的预测框个数一致,数据大小在0~1之间,表示预测框为正样本的概率。

    计算预测框位置坐标

    P 0 [ t , 0 : 4 , i , j ] P0[t, 0:4, i, j] P0[t,0:4,i,j]与输入的第 t t t张图片上小方块区域 ( i , j ) (i, j) (i,j)第1个预测框的位置对应, P 0 [ t , 12 : 16 , i , j ] P0[t, 12:16, i, j] P0[t,12:16,i,j]与第2个预测框的位置对应,依此类推,则使用下面的程序可以从 P 0 P0 P0中取出跟预测框位置相关的预测值。

    NUM_ANCHORS = 3
    NUM_CLASSES = 7
    num_filters=NUM_ANCHORS * (NUM_CLASSES + 5)
    
    backbone = DarkNet53_conv_body()
    detection = YoloDetectionBlock(ch_in=1024, ch_out=512)
    conv2d_pred =  paddle.nn.Conv2D(in_channels=1024, out_channels=num_filters,  kernel_size=1)
    
    x = np.random.randn(1, 3, 640, 640).astype('float32')
    x = paddle.to_tensor(x)
    C0, C1, C2 = backbone(x)
    route, tip = detection(C0)
    P0 = conv2d_pred(tip)
    
    
    reshaped_p0 = paddle.reshape(P0, [-1, NUM_ANCHORS, NUM_CLASSES + 5, P0.shape[2], P0.shape[3]])
    pred_objectness = reshaped_p0[:, :, 4, :, :]
    pred_objectness_probability = F.sigmoid(pred_objectness)
    
    pred_location = reshaped_p0[:, :, 0:4, :, :]
    print(pred_location.shape)
    
    

    网络输出值是 ( t x , t y , t w , t h ) (t_x, t_y, t_w, t_h) (tx,ty,tw,th),还需要将其转化为 ( x 1 , y 1 , x 2 , y 2 ) (x_1, y_1, x_2, y_2) (x1,y1,x2,y2)这种形式的坐标表示。使用飞桨paddle.vision.ops.yolo_box API可以直接计算出结果,但为了给读者更清楚的展示算法的实现过程,我们使用Numpy来实现这一过程。

    # 定义Sigmoid函数
    def sigmoid(x):
        return 1./(1.0 + np.exp(-x))
    
    # 将网络特征图输出的[tx, ty, th, tw]转化成预测框的坐标[x1, y1, x2, y2]
    def get_yolo_box_xxyy(pred, anchors, num_classes, downsample):
        """
        pred是网络输出特征图转化成的numpy.ndarray
        anchors 是一个list。表示锚框的大小,
                    例如 anchors = [116, 90, 156, 198, 373, 326],表示有三个锚框,
                    第一个锚框大小[w, h]是[116, 90],第二个锚框大小是[156, 198],第三个锚框大小是[373, 326]
        """
        batchsize = pred.shape[0]
        num_rows = pred.shape[-2]
        num_cols = pred.shape[-1]
    
        input_h = num_rows * downsample
        input_w = num_cols * downsample
    
        num_anchors = len(anchors) // 2
    
        # pred的形状是[N, C, H, W],其中C = NUM_ANCHORS * (5 + NUM_CLASSES)
        # 对pred进行reshape
        pred = pred.reshape([-1, num_anchors, 5+num_classes, num_rows, num_cols])
        pred_location = pred[:, :, 0:4, :, :]
        pred_location = np.transpose(pred_location, (0,3,4,1,2))
        anchors_this = []
        for ind in range(num_anchors):
            anchors_this.append([anchors[ind*2], anchors[ind*2+1]])
        anchors_this = np.array(anchors_this).astype('float32')
        
        # 最终输出数据保存在pred_box中,其形状是[N, H, W, NUM_ANCHORS, 4],
        # 其中最后一个维度4代表位置的4个坐标
        pred_box = np.zeros(pred_location.shape)
        for n in range(batchsize):
            for i in range(num_rows):
                for j in range(num_cols):
                    for k in range(num_anchors):
                        pred_box[n, i, j, k, 0] = j
                        pred_box[n, i, j, k, 1] = i
                        pred_box[n, i, j, k, 2] = anchors_this[k][0]
                        pred_box[n, i, j, k, 3] = anchors_this[k][1]
    
        # 这里使用相对坐标,pred_box的输出元素数值在0.~1.0之间
        pred_box[:, :, :, :, 0] = (sigmoid(pred_location[:, :, :, :, 0]) + pred_box[:, :, :, :, 0]) / num_cols
        pred_box[:, :, :, :, 1] = (sigmoid(pred_location[:, :, :, :, 1]) + pred_box[:, :, :, :, 1]) / num_rows
        pred_box[:, :, :, :, 2] = np.exp(pred_location[:, :, :, :, 2]) * pred_box[:, :, :, :, 2] / input_w
        pred_box[:, :, :, :, 3] = np.exp(pred_location[:, :, :, :, 3]) * pred_box[:, :, :, :, 3] / input_h
    
        # 将坐标从xywh转化成xyxy
        pred_box[:, :, :, :, 0] = pred_box[:, :, :, :, 0] - pred_box[:, :, :, :, 2] / 2.
        pred_box[:, :, :, :, 1] = pred_box[:, :, :, :, 1] - pred_box[:, :, :, :, 3] / 2.
        pred_box[:, :, :, :, 2] = pred_box[:, :, :, :, 0] + pred_box[:, :, :, :, 2]
        pred_box[:, :, :, :, 3] = pred_box[:, :, :, :, 1] + pred_box[:, :, :, :, 3]
    
        pred_box = np.clip(pred_box, 0., 1.0)
    
        return pred_box
    
    
    

    通过调用上面定义的get_yolo_box_xxyy函数,可以从 P 0 P0 P0计算出预测框坐标来,具体程序如下:

    NUM_ANCHORS = 3
    NUM_CLASSES = 7
    num_filters=NUM_ANCHORS * (NUM_CLASSES + 5)
    
    backbone = DarkNet53_conv_body()
    detection = YoloDetectionBlock(ch_in=1024, ch_out=512)
    conv2d_pred = paddle.nn.Conv2D(in_channels=1024, out_channels=num_filters,  kernel_size=1)
    
    x = np.random.randn(1, 3, 640, 640).astype('float32')
    x = paddle.to_tensor(x)
    C0, C1, C2 = backbone(x)
    route, tip = detection(C0)
    P0 = conv2d_pred(tip)
    
    reshaped_p0 = paddle.reshape(P0, [-1, NUM_ANCHORS, NUM_CLASSES + 5, P0.shape[2], P0.shape[3]])
    pred_objectness = reshaped_p0[:, :, 4, :, :]
    pred_objectness_probability = F.sigmoid(pred_objectness)
    
    pred_location = reshaped_p0[:, :, 0:4, :, :]
    
    # anchors包含了预先设定好的锚框尺寸
    anchors = [116, 90, 156, 198, 373, 326]
    # downsample是特征图P0的步幅
    pred_boxes = get_yolo_box_xxyy(P0.numpy(), anchors, num_classes=7, downsample=32) # 由输出特征图P0计算预测框位置坐标
    print(pred_boxes.shape)
    

    上面程序计算出来的pred_boxes的形状是 [ N , H , W , n u m _ a n c h o r s , 4 ] [N, H, W, num\_anchors, 4] [N,H,W,num_anchors,4],坐标格式是 [ x 1 , y 1 , x 2 , y 2 ] [x_1, y_1, x_2, y_2] [x1,y1,x2,y2],数值在0~1之间,表示相对坐标。

    计算物体属于每个类别概率

    P 0 [ t , 5 : 12 , i , j ] P0[t, 5:12, i, j] P0[t,5:12,i,j]与输入的第 t t t张图片上小方块区域 ( i , j ) (i, j) (i,j)第1个预测框包含物体的类别对应, P 0 [ t , 17 : 24 , i , j ] P0[t, 17:24, i, j] P0[t,17:24,i,j]与第2个预测框的类别对应,依此类推,则使用下面的程序可以从 P 0 P0 P0中取出那些跟预测框类别相关的预测值。

    NUM_ANCHORS = 3
    NUM_CLASSES = 7
    num_filters=NUM_ANCHORS * (NUM_CLASSES + 5)
    
    backbone = DarkNet53_conv_body()
    detection = YoloDetectionBlock(ch_in=1024, ch_out=512)
    conv2d_pred = paddle.nn.Conv2D(in_channels=1024, out_channels=num_filters,  kernel_size=1)
    
    x = np.random.randn(1, 3, 640, 640).astype('float32')
    x = paddle.to_tensor(x)
    C0, C1, C2 = backbone(x)
    route, tip = detection(C0)
    P0 = conv2d_pred(tip)
    
    reshaped_p0 = paddle.reshape(P0, [-1, NUM_ANCHORS, NUM_CLASSES + 5, P0.shape[2], P0.shape[3]])
    # 取出与objectness相关的预测值
    pred_objectness = reshaped_p0[:, :, 4, :, :]
    pred_objectness_probability = F.sigmoid(pred_objectness)
    # 取出与位置相关的预测值
    pred_location = reshaped_p0[:, :, 0:4, :, :]
    # 取出与类别相关的预测值
    pred_classification = reshaped_p0[:, :, 5:5+NUM_CLASSES, :, :]
    pred_classification_probability = F.sigmoid(pred_classification)
    print(pred_classification.shape)
    

    上面的程序通过 P 0 P0 P0计算出了预测框包含的物体所属类别的概率,pred_classification_probability的形状是 [ 1 , 3 , 7 , 20 , 20 ] [1, 3, 7, 20, 20] [1,3,7,20,20],数值在0~1之间。

    展开全文
  • 一、路由选择协议分类、 二、OSPF 协议 简介、 三、链路状态路由算法、 四、OSPF 区域、 五、OSPF 特点





    一、路由选择协议分类



    路由选择协议分类 :

    ① 内部网管协议 IGP :自治系统 ( Autonomous System ) 内部 使用的协议 ;

    • RIP 协议 : 使用 距离向量 算法 ; 用于 小型网络 ;
    • OSPF 协议 : 使用 链路状态 算法 ; 用于 大型网络 ;

    ② 外部网关协议 EGP :自治系统 ( Autonomous System ) 之间 使用的协议 ;


    下图中 自治系统 A A A 内部使用 RIP 协议 , 自治系统 B B B 内部使用 OSPF 协议 , 两个自治系统 A , B A,B A,B 之间使用 BGP 协议 ;
    在这里插入图片描述





    二、OSPF 协议 简介



    OSPF 协议 简介 :

    ① 全称 : 开放最短路径优先协议 ;

    • “开放” 说明该协议是公开发表的
    • “最短路径优先” 指的是使用了 最短路径算法 ;

    ② 主要特征 : 使用 分布式 链路状态协议 ;



    OSPF 协议细节 :

    ① 交换对象 : OSPF 中使用 洪泛法自治系统 ( Autonomous System ) 内部 所有路由器 发送消息 ; 本路由器 向 相邻路由器 发送消息 , 相邻路由器 再向 其相邻路由器 发送消息 , 直到所有的路由器收到消息为止 , 相当于广播 ;

    ② 交换信息 : OSPF 中发送消息内容是 , 本路由器 与 所有 相邻路由器 的链路状态 , 包括 有哪些相邻路由器 , 链路状态 如 距离 , 时延 , 带宽 等指标 ;

    ③ 交换时机 : 只有当 链路状态发生变化 时 , 路由器才使用 洪范法 向 AS 内所有路由器 广播 本身与所有相邻的路由器的链路状态 ;

    最终目的 : 所有的路由器 都有一个 链路状态数据库 ( 全网拓扑图 ) ;





    三、链路状态路由算法



    链路状态路由算法 :

    ① HELLO 问候分组 : 路由器 通过发送 HELLO 问候分组 , 发现邻居节点 ;

    ② 度量 : 设置 路由器 到 每个邻居 的成本度量 ;

    ③ DD 数据库描述分组 : 路由器 向 相邻路由器 给出自己的 链路状态数据库所有链路状态 的 摘要信息 ; ( 注意不是所有信息 )

    ④ LSR 链路状态请求分组 :

    • 存在摘要对应信息 : 如果 收到的 DD 数据库描述分组 中的摘要 , 自己都有 , 不做任何处理 ;
    • 不存在摘要对应信息 : 如果 没有 或者 有最新的 , 发送 LSR 链路状态请求分组 , 请求自己 没有 或者 有更新 的详细信息 ; ( 这一这里是详细信息 )

    ⑤ LSU 链路状态更新分组 : 收到 LSR 链路状态请求分组 后 , 发送 LSU 链路状态更新分组 , 更新对方路由器的 链路状态数据库信息 ;

    ⑥ LSAck 链路状态确认分组 : 收到 LSU 链路状态更新分组 后 , 返回 LSAck 链路状态确认分组 进行确认 ;



    某个 路由器 链路状态 发生变化 后的操作 :

    ① LSU 链路状态更新分组 : 泛洪法 发送 LSU 链路状态更新分组 , 更新所有路由器的 链路状态数据库 ;

    ② LSAck 链路状态确认分组 : 路由器更新完毕后 , 回送 LSAck 链路状态确认分组 ;

    ③ 构造最短路径 : 每个路由器 根据自身的 链路状态数据库 , 构造本节点到其它节点的最短路径 ;





    四、OSPF 区域



    OSPF 区域 :

    ① 协议使用场景 : OSPF 是 自治系统 ( Autonomous System ) 内部 使用的协议 ;

    ② 应用场景 : OSPF 应用于 规模较大 的网络 ;

    ③ 区域划分 : OSPF 会将 自治系统 划分为 若干 小的范围 , 称为区域 ;

    ④ 区域表示 : 每个区域使用 32 32 32 位 点分十进制 区域标识符 表示 , 如 0.0.0.1 0.0.0.1 0.0.0.1 , 0.0.0.2 0.0.0.2 0.0.0.2 , 等 ;

    ⑤ 区域范围限制 : 一般情况下 , 一个 区域内的路由器应控制在 200 200 200 个以内 ;



    区域分类 :

    ① 主干区域 : 标识符规定使用 0.0.0.0 0.0.0.0 0.0.0.0 表示 ; 其作用是联通下层的 普通区域 ;

    • 主干路由器 : 主干区域的路由器 , 都成为 主干路由器 ;
    • 区域边界路由器 : 主干区域 与 普通区域 连接的 路由器 除了是主干路由器之外 , 还是 区域边界路由器 ;
    • 自治系统边界路由器 : 本 自治系统 与 其它自治系统 连接的路由器 , 也在主干区域中 ;

    ② 普通区域 :

    • 区域内部路由器 : 普通区域内部的路由器 是 区域内部路由器 ;




    五、OSPF 特点



    OSPF 特点 :

    ① 刷新周期 : 每隔 30 30 30 分钟 , 刷新一次 数据库中的 链路状态 ;

    ② 适用于大规模网络 : 路由器 的 链路状态 只涉及 与 相邻路由器 的联通状态 , 与整个网络规模无关 ; 如果 网络规模较大 , OSPF 比 RIP 协议好用 ;

    ③ 收敛速度快 : RIP 中坏消息传输慢 , 收敛慢 , OSPF 不存在坏消息传的慢的问题 ;

    展开全文
  • 图像处理图像分割区域增长

    热门讨论 2009-05-10 11:20:20
    图像处理中有用的程序算法,很有用的哦,基于区域增长的图像分割,特征值提取
  • 之前写的都是有关于ROI的区域提取,但是对于提取到的区域我们需要提取它的特征,才可以在后期的特征匹配中排上用场。 这篇文章主要记录我是如何对指静脉图片做二值纹理特征提取的 原理: 一种比较特征提取简单的...
  • 感受野的含义及计算方法

    千次阅读 2022-02-15 00:39:02
    感受野(Receptive Field)的概念:在卷积神经网络中,感受野的定义是 卷积神经网络每一层输出的特征图(feature map)上的像素点在原始输入图像上映射的区域大小。第一层卷积层的输出特征图像素的感受野大小等于卷积...
  • 运行维护目标从保障网络安全发展为新含义.pdf运行维护目标从保障网络安全发展为新含义.pdf运行维护目标从保障网络安全发展为新含义.pdf运行维护目标从保障网络安全发展为新含义.pdf运行维护目标从保障网络安全发展为...
  • 原文出处: 阮一峰(@ruanyf) 学习编程的时候,经常会看到stack这个词,它的中文名字叫做”栈...stack的第一种含义是一组数据的存放方式,特点为LIFO,即后进先出(Last in, first out)。 在这种数据结构中,数据
  • 叠置分析的含义.pptx

    2020-06-15 02:25:13
    叠置分析是指在统一空间参照系统条件下把两层或两层以上的专题要素图层进行叠置以产生空间区域的多重属性特征或建立地理要素之间的空间对应关系; 从原理上来说叠置分析是对新要素的属性按一定的数学模型进行计算...
  • 矩阵特征值和特征向量物理含义

    千次阅读 2017-01-09 10:55:55
    最近在做聚类的时候用到了主成分分析PCA技术,里面涉及一些关于矩阵特征值和特征向量的内容,在网上找到一篇对特征向量及其物理意义说明较好的文章,整理下来,分享一下。   一、矩阵基础[1]: 矩阵是一个...
  • 一种表情符号含义展示方法,其特征在于:所述方法包括以下步骤:获取用户的手势操作输入信息;根据所述手势操作输入信息获取信息交互界面中的表情符号信息;根据表情符号信息与表情符号含义信息的映射关系,提取与所...
  • 学习笔记20--可行驶区域检测

    千次阅读 2022-01-12 18:31:17
    本系列博客包括6个专栏,分别为:《自动驾驶技术概览》、《自动驾驶汽车平台技术基础》、《自动驾驶汽车定位技术》、《自动驾驶汽车环境感知》、《自动驾驶汽车决策与控制》、《自动驾驶系统设计应用》,笔者不是...
  • 某大学农村与区域发展研究生组织工作概述.pptx
  • C#设置VisionPro工具中的掩膜区域

    千次阅读 2020-12-24 22:09:12
    visionpro中有几个工具都可以设置掩膜区域,用来分离不关心或者不怎么关心的区域。它们分别是PMAlign、Blob、CNLSearch、CogHistogram,下面以PMAlign工具掩膜示例。话说这个掩膜康耐视做得很神...
  • 仿射变换和透视变换矩阵的参数含义与区别

    千次阅读 多人点赞 2020-11-16 16:22:30
    进行训练 可以看到,在无法提取足够特征点的弱纹理区域,HomographyNet相比传统方法确实有一定的优势: Spatial Transformer Networks(直接对CNN中的卷积特征进行变换) Spatial Transformer Networks​ arxiv.org ...
  • 变量的含义(转载)

    2020-08-19 11:17:43
    保存变量的区域 程序运行时内存中有三个区域可以保存变量:静态存储区、栈(stack)、堆(heap); 根据变量定义的位置可分为全局变量(定义在函数体外的变量)和局部变量(定义在函数体内的变量)。 1.所有的全局...
  • 【多选题】Ethics always involve people....【单选题】产业规划编制中,在确定区域产业发展重点时,可以用专业化部门分析法,常用( )表示。【多选题】中药化学研究的主要内容是( )【判断题】SWOT分...
  • 我们表明,用于描述暗物质与标准模型粒子之间相互作用的简化模型在一般情况下并不符合规范不变性,并且在参数空间的较大区域中可能会破坏微扰统一性。 解决这些矛盾所必需的修改可能意味着现象学更加丰富,并导致对...
  • 图像分割与特征提取 MATLAB实现 图像分割是指将图像中有意义的对象与其背景分离并把这些对象按照不同的含义分割开来也就是说把图像中具有不同含义的对象提取出来图像分割的方法大致可以分为基于边缘检测的方法和...
  • Ceres匹配算法收敛速度配置 TRAJECTORY_BUILDER_nD.ceres_scan_matcher.ceres_solver_options.use_nonmonotonic_steps 含义:bool量,启动非单调置信区域; TRAJECTORY_BUILDER_nD.ceres_scan_matcher.ceres_solver...
  • OSPF所含包的含义

    2022-01-12 22:30:29
    即Totally NSSA区域内的路由器可以成为ASBR,由于没有去往其它OSPF区域的路由,所以ABR会自动向Totally NSSA内发送一条指向自己的默认路由,如下图: 总结各区域特征如下: 区域类型 接收区域间路由 ABR是否发送...
  • 变量的含义

    千次阅读 2020-08-16 18:47:00
    保存变量的区域 程序运行时内存中有三个区域可以保存变量:静态存储区、栈(stack)、堆(heap); 根据变量定义的位置可分为全局变量(定义在函数体外的变量)和局部变量(定义在函数体内的变量)。 1.所有的全局...
  • 区域检测算法-MSERs

    千次阅读 2019-04-09 16:41:00
    参考书籍——《图像局部不变性特征与描述》王永明、王贵锦著 MSER最大极值稳定区域的提取步骤:1.像素点排序 2.极值区域生成 3.稳定区域判定 4.区域拟合 5.区域归一化 MSER算法介绍:参看博客——...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,620
精华内容 28,248
关键字:

区域的含义及特征