精华内容
下载资源
问答
  • MobileNet ssd模型文件

    2019-02-17 22:48:19
    MobileNet ssd模型文件,包含二进制文件,描述文件,标签文件
  • 本课程手把手讲解Caffe SSD框架代码编译和安装过程,并详细介绍如何基于一个无人零售商品数据集来成功训练出SSD和Mobilenet SSD模型,然后将它们量化且移植到海思开发板上正确运行。 课程主要内容有: 1. caffe SSD...
  • 今天小编就为大家分享一篇基于Pytorch SSD模型分析,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • SSD模型结构解析

    2020-07-05 18:54:36
    SSD模型结构解析模型简介模型结构anchorLoss函数 模型简介 SSD,全称Single Shot MultiBox Detector,single shot指的是SSD算法属于one-stage方法,MultiBox说明SSD是多框预测。SSD算法的性能与速度优于YOLO。 模型...

    模型简介

    SSD,全称Single Shot MultiBox Detector,single shot指的是SSD算法属于one-stage方法,MultiBox说明SSD是多框预测。SSD算法的性能与速度优于YOLO。

    模型结构

    SSD模型的输入图片大小是300x300,或512x512。
    SSD的主干特征提取网络依据VGG-16,并选取了6个有效特征层用来产生先验框,SSD采用了不同尺度和长宽比的先验框,每个网格的先验框的数量有4和6,最终共产生8732个box,进行分类和回归。
    在这里插入图片描述

    anchor

    default box的尺度计算方式如下:
    在这里插入图片描述

    Loss函数

    Loss = softmax_loss + l1_smooth_loss
    
    展开全文
  • SSD模型解析

    2018-07-13 10:51:00
    SSD模型训练起来较为简单,所以最近用的也比较多 现在做一个完整的SSD模型解析,包括训练过程中遇到的各种坑的解决办法 先放一个被用烂了的图 模型说明 图片通过vgg16的conv4_3layer得到一个feature_map_1...

    SSD模型训练起来较为简单,所以最近用的也比较多

    现在做一个完整的SSD模型解析,包括训练过程中遇到的各种坑的解决办法

    先放一个被用烂了的图

     

     

     模型说明

    图片通过vgg16的conv4_3layer得到一个feature_map_1

    对feature_map_1进行卷积,使用3*3的卷积核,再使用1*1的卷积核,使用multi_task方法(在使用3*3卷积核之后,分别经过两个不同的1*1卷积核)

    获得result_sigmoid(h*w*1)和result_softmax(h*w*m)

    result_sigmoid对应的是这个区域的archer_box是否包含正样本

    result_softmax对应的是这个区域那一个archer_box为字母框的概率最大

     

    对feature_map_1通过3*3卷积核卷积之后的结果进行max_pooling获取feature_map_2

    对feature_map_2进行卷积,使用3*3的卷积核,再使用1*1的卷积核,使用multi_task方法(在使用3*3卷积核之后,分别经过两个不同的1*1卷积核)

    获得result_sigmoid_2(hh*ww*1)和result_softmax_2(hh*ww*m)

    result_sigmoid_1对应的是这个区域的archer_box是否包含正样本

    result_softmax_2对应的是这个区域那一个archer_box为字母框的概率最大

    以此类推

     

    关于archer_box:

      先放个图

      

     

     

         一般来说,CNN的不同层有着不同的感受野。然而,在SSD结构中,default box不需要和每一层的感受野相对应,特定的特征图负责处理图像中特定尺度的物体。在每个特征图上,default box的尺度计算如下:

      计算feature_map_k的感受野 receptive_field

          其中,smin = 0.2 ×  receptive_field,smax = 0.9 × receptive_field


          default box的aspect ratios 有:

      一般来说,设置6个radio即可(m=6)

          每一个default box,宽度、高度、中心点计算如下:

      

      对于每一个Sk 我们有

      a = {1, 2, 3,1/2,1/3},对于 aspect ratio = 1,额外增加一个default box,该box的尺度为 

      

     

    训练过程:

    训练和解析是很不一样的

    因为ssd模型的输出是一个feature map嘛,我开始就拿输入为一张图和输出为n张feature map去做反向传播

    结果效果非常差,,,feature_map 全部趋于0

      

    之后重新读了一遍论文,又读了一些博客,找到了正确训练的方法

    我们已有的数据为带标记的图片数据

    数据生成:

      将图片输入vgg_16的conv5_3获取feature_map(h*w*c)

      使用3*3的滑动窗口,stride为1 ,padding = same 将feature_map 取成h*w个3*3*c的小窗口

      计算这个3*3滑动窗口的感受野

      通过感受野,每个滑动窗口生成35个default box

      遍历所有的标记,找到对这35个default_box最大的IOU

      若iou<0.3则记为负样本,若iou>0.7则记为正样本

      

      对于IOU>0.7的,找到对于iou最大的default box 相当于一个softmax 分类

     

      因为我们ssd是多层的,feature_map是可以替换的,所以每一个feature map按照以上规则生成数据即可

     

    网络训练

      我们的输入是3*3*c的一个feature map

      输出有两个

      一个是一维的值,表示是否是正负样本

      另一个是35维的向量,表示哪一个default box为iou最大的那个

      网络结构就是卷积加全连接嘛,这个也比较简单

      但要注意,最后一个卷积要使用(3*3) 的卷积核,输出为1*c

      就是把每一个通道变成一个

    网络封装

      封装之后的网络输入为h*w*3的bgr图像

      输出为3-5个map_1(h*w) ,     map_2(h*w*35)

      第一个map 表示正负样本  第二个map表示哪一个default box iou最大

     

      但是我们有全连接,,,全连接使用1*1卷积核代替即可

      

      卷积没什么好说的

      全连接用1*1卷积核代替即可  

     

    转载于:https://www.cnblogs.com/shensobaolibin/p/9303748.html

    展开全文
  • Caffe: SSD模型

    2019-09-27 20:22:30
    SSD模型配置(训练)与运行 参考博文: 1. *ssd模型配置及运行demo 2. *SSD: Signle Shot Detector 用于自然场景文字检测 3.SSD的配置安装与测试 4. *SSD: Single Shot MultiBox Detector检测单张图片 简介: ...

    SSD模型配置(训练)与运行

    参考博文:

    1. * ssd模型配置及运行demo

    2. * SSD: Signle Shot Detector 用于自然场景文字检测

    3. SSD的配置安装与测试

    4. * SSD: Single Shot MultiBox Detector检测单张图片

    简介:

    SSD基于Caffe框架实现,在Github上可以获得开源代码。SSD 是用来检测物体的,那么同样可以将 SSD 用来检测自然场景图像中的文字。

    第一部分:安装SSD(caffe)

    1、安装Git

    终端输入:

    sudo apt-get install git  

    2、安装SSD

    在主文件下终端输入(即/home/***(您的服务器名字)这个目录):

    git clone https://github.com/weiliu89/caffe.git
    cd caffe
    git checkout ssd(出现“分支”则说明copy-check成功)
    

    会在examples目录下出现ssd项目 

    第二部分:配置SSD(caffe)

    终端输入:
    cd /home/**(您服务器的名字)/caffe

    cp Makefile.config.example Makefile.config

    打开Makefile.config,开始修改,保存退出;或者从之前caffe项目复制其配置文件到这里
    终端输入:

    cd /home/**(您服务器的名字)/caffe
    mkdir build
    cd build
    # 下面的命令都在build目录下执行
    cmake ..(cmake和..中间又一个空格)
    make all -j16("‐j16"是使用 CPU 的多核进行编译,可以极大地加速编译的速度)
    make pycaffe(编译pycaffe)  
    

    注:编译最新的caffe使用cudnn,其版本要求至少为v4,否则出错.[2017-02-21]

    第三部分:下载数据文件

    1、 预训练模型下载

    下载地址:VGG_ILSVRC_16_layers_fc_reduced.caffemodel

    在caffe/models文件夹下新建文件夹,命名为VGGNet,将刚刚下载下来的文件放入这个VGGNet文件夹当中

    2、下载VOC2007和VOC2012数据集

    在用户主目录下(即/home/**(您服务器的名字)/)新建data/目录

    终端输入:

    cd /home/**(您服务器的名字)/data
    wget http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar
    wget http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtrainval_06-Nov-2007.tar
    wget http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtest_06-Nov-2007.tar  

    解压这三个文件,终端输入(请严格按照这个顺序解压):

    cd /home/**(您服务器的名字)/data
    tar -xvf VOCtrainval_11-May-2012.tar
    tar -xvf VOCtrainval_06-Nov-2007.tar
    tar -xvf VOCtest_06-Nov-2007.tar  

     

    第四部分:生成LMDB文件

    终端输入:

    cd /home/**(您服务器的名字)/caffe
    ./data/VOC0712/create_list.sh
    ./data/VOC0712/create_data.sh  
    
    

    在运行第三步时如果出现no module named caffe或者是no module named caffe-proto,则在终端输入:

    export PYTHONPATH=$PYTHONPATH:/home/**(您服务器的名字)/caffe/Python

    然后再次运行

    第五部分:训练测试演示

    1、 训练
    打开caffe/examples/ssd/ssd_pascal.py这个文件,找到gpus='0,1,2,3'这一行,如果您的服务器有一块显卡,则将123删去,如果有两个显卡,则删去23,以此类推。

    如果您服务器没有gpu支持,则注销以下几行,程序会以cpu形式训练。(这个是解决问题cudasuccess(10vs0)的方法) 

    #Ifnum_gpus >0:
    
        # batch_size_per_device =int(math.ceil(float(batch_size) / num_gpus))
    
    #iter_size =int(math.ceil(float(accum_batch_size) / (batch_size_per_device * num_gpus)))
    
    # solver_mode =P.Solver.GPU
    # device_id =int(gpulist[0]) 

    保存后终端运行:

    cd  /home/**(您服务器的名字)/caffe
    python examples/ssd/ssd_pascal.py

    如果出现问题cudasuccess(2vs0)则说明您的显卡计算量有限,则编辑文件 vim examples/ssd/ssd_pascal.py ,找到batch_size = 32这一行,修改数字32为16或8或4,保存后再次终端运行 python examples/ssd/ssd_pascal.py 

    注意,SSD模型训练过程中GPU显存需求略小于 8GB。这意味着4GB或6GB显存的GPU无法直接训练SSD[实验室配置为GT980,显存6GB,cudnn加速能力5],可以通过减小batchsize来绕过这个问题。

    wang@VisInt:~$ nvidia-smi
    Tue Feb 21 17:30:36 2017       
    +------------------------------------------------------+                       
    | NVIDIA-SMI 346.82     Driver Version: 346.82         |                       
    |-------------------------------+----------------------+----------------------+
    | GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
    | Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
    |===============================+======================+======================|
    |   0  GeForce GTX 980 Ti  Off  | 0000:02:00.0     N/A |                  N/A |
    |  0%   37C    P8    N/A /  N/A |     48MiB /  6143MiB |     N/A      Default |
    +-------------------------------+----------------------+----------------------+
                                                                                   
    +-----------------------------------------------------------------------------+
    | Processes:                                                       GPU Memory |
    |  GPU       PID  Type  Process name                               Usage      |
    |=============================================================================|
    |    0            C+G   Not Supported                                         |
    +-----------------------------------------------------------------------------+  

    2、 测试
    终端输入:

    python examples/ssd/score_ssd_pascal.py  

    演示detection的训练结果,数值在0.728左右


    3、 用训练好的 model 进行 predict

    >>演示网络摄像头识别效果,终端输入:

    python examples/ssd/ssd_pascal_webcam.py  
    

    要求机器上有摄像头,Linux服务器桌面环境下运行命令  

    >>检测图片:

    jupyter notebook  

    打开 ~/caffe/examples/ssd_detect.ipynb

    指定好 caffemodel

     

    要求在Linux服务器桌面环境下运行命令

      

      

     

    转载于:https://www.cnblogs.com/AbcFly/p/6425204.html

    展开全文
  • ssd-text_detection, 一种改进的文本检测SSD模型 ssd文本检测:文本检测器这是一种用于文本检测的改进的SSD模型。高速cnn相比,SSD更快。 在我的expriment中,SSD对于每个图像只需要 0.05秒。免责声明这是 mxnet SSD...
  • Pytorch SSD模型分析

    千次阅读 热门讨论 2019-01-07 19:32:01
    Pytorch SSD模型分析 ​ 本文参考github上SSD实现,对模型进行分析,主要分析模型组成及输入输出大小.SSD网络结构如下图: ​ 每输入的图像有8732个框输出; import torch import torch.nn as nn import torch.nn....

    Pytorch SSD模型分析

    ​ 本文参考github上SSD实现,对模型进行分析,主要分析模型组成及输入输出大小.SSD网络结构如下图:
    在这里插入图片描述

    ​ 每输入的图像有8732个框输出;

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    from torch.autograd import Variable
    #from layers import *
    from data import voc, coco
    import os
    
    base = {
        '300': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'C', 512, 512, 512, 'M',
                512, 512, 512],
        '512': [],
    }
    extras = {
        '300': [256, 'S', 512, 128, 'S', 256, 128, 256, 128, 256],
        '512': [],
    }
    mbox = {
        '300': [4, 6, 6, 6, 4, 4],  # number of boxes per feature map location
        '512': [],
    }
    

    VGG基础网络结构:

    def vgg(cfg, i, batch_norm=False):
        layers = []
        in_channels = i
        for v in cfg:
            if v == 'M':
                layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
            elif v == 'C':
                layers += [nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)]
            else:
                conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
                if batch_norm:
                    layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
                else:
                    layers += [conv2d, nn.ReLU(inplace=True)]
                in_channels = v
        pool5 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
        conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6)
        conv7 = nn.Conv2d(1024, 1024, kernel_size=1)
        layers += [pool5, conv6,
                   nn.ReLU(inplace=True), conv7, nn.ReLU(inplace=True)]
        return layers
    
    size=300
    vgg=vgg(base[str(size)], 3)
    print(vgg)
    

    输出为:

    Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    ReLU(inplace)
    Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    ReLU(inplace)
    MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    ReLU(inplace)
    Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    ReLU(inplace)
    MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    ReLU(inplace)
    Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    ReLU(inplace)
    Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    ReLU(inplace)
    MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)
    Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    ReLU(inplace)
    Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    ReLU(inplace)
    Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    ReLU(inplace)
    MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    ReLU(inplace)
    Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    ReLU(inplace)
    Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    ReLU(inplace)
    MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
    Conv2d(512, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(6, 6), dilation=(6, 6))
    ReLU(inplace)
    Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1))
    ReLU(inplace)
    

    SSD中添加的网络

    add_extras函数构建基本的卷积层

    def add_extras(cfg, i, batch_norm=False):
        # Extra layers added to VGG for feature scaling
        layers = []
        in_channels = i
        flag = False
        for k, v in enumerate(cfg):
            if in_channels != 'S':
                if v == 'S':
                    layers += [nn.Conv2d(in_channels, cfg[k + 1],
                               kernel_size=(1, 3)[flag], stride=2, padding=1)]
                else:
                    layers += [nn.Conv2d(in_channels, v, kernel_size=(1, 3)[flag])]
                flag = not flag
            in_channels = v
        return layers
    
    extra_layers=add_extras(extras[str(size)], 1024)
    for layer in extra_layers:
        print(layer)
    

    输出为:

    Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))
    Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
    Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))
    Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
    Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))
    Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1))
    Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))
    Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1))
    

    multibox函数得到每个特征图的默认box的位置计算网络和分类得分网络

    def multibox(vgg, extra_layers, cfg, num_classes):
        loc_layers = []
        conf_layers = []
        vgg_source = [21, -2]
        for k, v in enumerate(vgg_source):
            loc_layers += [nn.Conv2d(vgg[v].out_channels,
                                     cfg[k] * 4, kernel_size=3, padding=1)]
            conf_layers += [nn.Conv2d(vgg[v].out_channels,
                            cfg[k] * num_classes, kernel_size=3, padding=1)]
        for k, v in enumerate(extra_layers[1::2], 2):
            loc_layers += [nn.Conv2d(v.out_channels, cfg[k]
                                     * 4, kernel_size=3, padding=1)]
            conf_layers += [nn.Conv2d(v.out_channels, cfg[k]
                                      * num_classes, kernel_size=3, padding=1)]
        return vgg, extra_layers, (loc_layers, conf_layers)
    
    base_, extras_, head_ = multibox(vgg(base[str(size)], 3), ## 产生vgg19基本模型
                                         add_extras(extras[str(size)], 1024), 
                                         mbox[str(size)], num_classes)
    #mbox[str(size)]为:[4, 6, 6, 6, 4, 4]
    

    得到的输出为:

    base_为上述描述的vgg网络,extras_为extra_layers网络,head_为:

    ([Conv2d(512, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
      Conv2d(1024, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
      Conv2d(512, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
      Conv2d(256, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
      Conv2d(256, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
      Conv2d(256, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))],
     [Conv2d(512, 84, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
      Conv2d(1024, 126, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
      Conv2d(512, 126, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
      Conv2d(256, 126, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
      Conv2d(256, 84, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
      Conv2d(256, 84, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))])
    

    SSD网络及forward函数为:

    class SSD(nn.Module):
        """Single Shot Multibox Architecture
        The network is composed of a base VGG network followed by the
        added multibox conv layers.  Each multibox layer branches into
            1) conv2d for class conf scores
            2) conv2d for localization predictions
            3) associated priorbox layer to produce default bounding
               boxes specific to the layer's feature map size.
        See: https://arxiv.org/pdf/1512.02325.pdf for more details.
    
        Args:
            phase: (string) Can be "test" or "train"
            size: input image size
            base: VGG16 layers for input, size of either 300 or 500
            extras: extra layers that feed to multibox loc and conf layers
            head: "multibox head" consists of loc and conf conv layers
        """
    
        def __init__(self, phase, size, base, extras, head, num_classes):
            super(SSD, self).__init__()
            self.phase = phase
            self.num_classes = num_classes 
            self.cfg = (coco, voc)[num_classes == 21]
            self.priorbox = PriorBox(self.cfg)
            self.priors = Variable(self.priorbox.forward(), volatile=True)
            self.size = size
    
            # SSD network
            self.vgg = nn.ModuleList(base)
            # Layer learns to scale the l2 normalized features from conv4_3
            self.L2Norm = L2Norm(512, 20)
            self.extras = nn.ModuleList(extras)
    
            self.loc = nn.ModuleList(head[0])
            self.conf = nn.ModuleList(head[1])
    
            if phase == 'test':
                self.softmax = nn.Softmax(dim=-1)
                self.detect = Detect(num_classes, 0, 200, 0.01, 0.45)
    
        def forward(self, x):
            """Applies network layers and ops on input image(s) x.
    
            Args:
                x: input image or batch of images. Shape: [batch,3,300,300].
    
            Return:
                Depending on phase:
                test:
                    Variable(tensor) of output class label predictions,
                    confidence score, and corresponding location predictions for
                    each object detected. Shape: [batch,topk,7]
    
                train:
                    list of concat outputs from:
                        1: confidence layers, Shape: [batch*num_priors,num_classes]
                        2: localization layers, Shape: [batch,num_priors*4]
                        3: priorbox layers, Shape: [2,num_priors*4]
            """
            sources = list()
            loc = list()
            conf = list()
    
            # apply vgg up to conv4_3 relu
            for k in range(23):
                x = self.vgg[k](x) ##得到的x尺度为[1,512,38,38]
    
            s = self.L2Norm(x)
            sources.append(s)
    
            # apply vgg up to fc7
            for k in range(23, len(self.vgg)):
                x = self.vgg[k](x)  ##得到的x尺寸为[1,1024,19,19]
            sources.append(x)
    
            # apply extra layers and cache source layer outputs
            for k, v in enumerate(self.extras):
                x = F.relu(v(x), inplace=True)
                if k % 2 == 1:
                    sources.append(x)
            '''
            上述得到的x输出分别为:
            torch.Size([1, 512, 10, 10])
            torch.Size([1, 256, 5, 5])
            torch.Size([1, 256, 3, 3])
            torch.Size([1, 256, 1, 1])
            '''
    
            # apply multibox head to source layers
            for (x, l, c) in zip(sources, self.loc, self.conf):
                loc.append(l(x).permute(0, 2, 3, 1).contiguous())
                conf.append(c(x).permute(0, 2, 3, 1).contiguous())
    
            loc = torch.cat([o.view(o.size(0), -1) for o in loc], 1)
            conf = torch.cat([o.view(o.size(0), -1) for o in conf], 1)
            if self.phase == "test":
                output = self.detect(
                    loc.view(loc.size(0), -1, 4),                   # loc preds
                    self.softmax(conf.view(conf.size(0), -1,
                                 self.num_classes)),                # conf preds
                    self.priors.type(type(x.data))                  # default boxes
                )
            else:
                output = (
                    loc.view(loc.size(0), -1, 4), #[1,8732,4]
                    conf.view(conf.size(0), -1, self.num_classes),#[1,8732,21]
                    self.priors
                )
            return output
    

    上述代码中sources中保存的数据输出如下,即用于边框提取的特征图:

    torch.Size([1, 512, 38, 38])
    torch.Size([1, 1024, 19, 19])
    torch.Size([1, 512, 10, 10])
    torch.Size([1, 256, 5, 5])
    torch.Size([1, 256, 3, 3])
    torch.Size([1, 256, 1, 1])
    

    模型输入为

    x=Variable(torch.randn(1,3,300,300))
    
    展开全文
  • SSD模型详解

    万次阅读 2019-08-23 11:02:04
    ssd论文原文: https://arxiv.org/pdf/1512.02325.pdf 参考代码 https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/ssd https://github.com/amdegroot/ssd.pytorch SSD网络总体描述 网络组成...
  • 包含deploy.prototxt、labelmap_det.txt、VGG_ILSVRC2016_SSD_300x300_iter_440000.caffemodel文件 和SSD模型实现对象检测源码、图片素材 具体实现效果见CSDN博客“DNN系列3_SSD模型实现对象检测”
  • 该文件里面提供了SSD模型与视频,更改路径即可(出现问题可以联系我.. )
  • voc0712 训练的ssd模型,mAP值为77%,网络结构是作者开源的ssd代码的标准的ssd 300*300的网络
  • 首先引入更深的Resnet50残差网络替换原始SSD模型中的VGG16基础网络,改善网络特征提取能力。然后采用基于特征金字塔(FPN)的网络结构进行高低层特征融合,进一步提高了检测精度。实验结果表明,在构建的缝纫手势数据集中...
  • 3 使用SSD模型实现对象检测  SSD模型与数据介绍  使用模型实现对象检测 3.1 SSD模型与数据介绍  SSD模型 - https://github.com/weiliu89/caffe/tree/ssd#models  Fast –R-CNN模型基础上延伸  基于...
  • 调用SSD模型 # -*- coding: utf-8 -*- from tensorflow.python.keras.preprocessing.image import img_to_array from tensorflow.python.keras.applications.imagenet_utils import preprocess_input import cv2 as ...
  • OpenCV使用MobileNet-SSD模型实现目标检测 OpenCV使用MobileNet-SSD模型实现目标检测 1. 前言 2.OpenCV深度学习模块调用模型 2.1 导入相关包 2.2 构造命令行参数 2.3 定义模型的检测分类 2.4 打开视频或摄像头并...
  • SSD 模型的C++推理部署

    2020-12-08 18:04:58
    <div><p>在C++推理部署中,配置中的FEEDS_SIZE表示 # 输入的tensor数量,...推理代码并没有考虑SSD模型。</p><p>该提问来源于开源项目:PaddlePaddle/PaddleDetection</p></div>
  • SSD模型训练一、创建网络配置文件1.打开configs文件夹2.创建configs文件3.修改配置文件 一、创建网络配置文件 1.打开configs文件夹 具体路径:anaconda3/envs/tensorflow/lib/python3.6/site-packages/tensorflow/...
  • 安装Caffe_ssd并用自己的数据训练MobileNetSSD模型 0 引言原来那台Dell电脑是Win10和Ubuntu16.04的双系统1 安装Caffe2 配置 MobileNet-ssd下载MobileNet-SSD测试demo参数文件和网络文件的详细说明3 利用自己的数据集...
  • --Tensorflow+SSD+Yolo(目标检测)文章7.更换SSD模型 该资源是本篇文章的操作步骤以及参考帖子的截图,以防参考帖子失效。
  • SSD模型论文:https://blog.csdn.net/quincuntial/article/details/78854930 汉化 0、环境准备: ubuntu18.04.4系统,pytorch1.2.0,CUDN10,CUDNN7.4.2,GPU为GTX1050 1、训练前的准备: VOC数据集的准备,使用...
  • 最后,我们在视频文件上演示了某种动物类型(SSD模型能够检测到)的检测结果。 下载源34.8 KB 下载模型-26 MB(外部链接) 介绍 野蛮的野生生物可能给企业和房主带来痛苦。鹿、驼鹿甚至猫等动物都会对花园、庄稼...
  • SSD模型 两个优化策略
  • 之前对ssd的整个原理已经了解了,对于整个网络走动的流程,loss的计算这些,已经心里有数了,那么接下来,要么去训练ssd模型,要么就去利用ssd去测试模型,这不,我们现在就学习一下利用opencv来使用ssd,在这之前,...
  • 目录 一、jetson-nano上的SSD模型选择 二、jetson-nano上模型部署 三、SSD模型原理 一、jetson-nano上的SSD模型选择 为什么选择SSD模型? 如果应用场景没有小目标检测需求。 推理的硬件设备算力不是很高又要求较高的...
  • SSD模型--目标检测

    千次阅读 2017-12-13 21:06:02
    配置SSD模型,用于目标检测实验。第一部分:源码下载,编译git clone https://github.com/weiliu89/caffe.git cd caffe git checkout ssd # 或者是 git clone -b ssd https://github.com/weiliu89/caffe.git cd ...
  • 训练自己的目标检测SSD模型 1. 安装标注工具 #这里我们使用的是labelimg——可以通过可视化界面进行画框标注就能自动生成VOC格式的xml文件 #通过Python下载 pip install labelImg #然后使用命令行开启labelImag ...

空空如也

空空如也

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

ssd模型