找回密码
 注nanjixiong2017册

QQ登录

只需一步,快速开始

发表帖子

caffe初探2:有关网络设计的探索

[复制链接]
续caffe初探1大笑大笑大笑有兴趣的朋友可以关注笔者的博客,笔者作为一个初涉深度学习领域和caffe的rookie,很高兴同大家一起学习和探讨,对于本人博客中的谬误与疏漏,笔者诚恳地期待各位读者朋友们的指点与建议。



在caffe初探1中,笔者提到了如何制作自己的数据集,那么在此文中,笔者将讲解如何撰写网络架构。众所周知,在卷及神经网络中,网络架构是最重要的一部分,网络的构造与模型效果的好与坏是息息相关的,因此,要学习如何构造符合各位读者朋友分类目的网络,请各位读者朋友们阅读有关机器学习与神经网络相关的文献。本文只是讲解如何在caffe框架下面如何设计网络架构。好了,废话不多说,下面具体讲解如何生成网络架构。



在撰写网络架构之前,我们需要一个meanfile文件,这个文件是训练模型的时候需要的,具体作用是什么呢?这里笔者以一张参与训练的图片举个栗子,均值文件会对这一张图片分通道(如B,G,R通道)求像素均值,然后求各通道像素值与均值的差值并以此作为输入。那么为什么需要求差值呢?其实是因为差值计算可以使结果像素均匀地分布在均值的周围。



和caffe初探1一样,我们生成的数据集在./caffe/forkrecognition/目录下面,有两个文件夹,名称分别为test_lmdb和train_lmdb,现在我们在./caffe/forkrecognition/目录下建立脚本文件make_imagenet_mean.sh,内容如下所示
  1. # Compute the mean image from the imagenet training lmdb


  2. EXAMPLE=forkrecognition     #存放训练集的根目录
  3. DATA=forkrecognition        #存放均值计算结果的根目录
  4. TOOLS=build/tools           #计算均值文件的目录


  5. $TOOLS/compute_image_mean $EXAMPLE/train_lmdb \
  6.   $DATA/imagenet_mean.binaryproto


  7. echo "Done."
复制代码


在caffe目录下执行./forkrecognition/make_imagenet_mean.sh命令,可以看到在./caffe/forkrecognition/目录下面生成了image_mean.binaryproto文件,这是我们在编写网络架构中需要用到的。接下来,我们就可以开始撰写网络结构了。



在此笔者想说的是,有关网络的设计规范官方文档,当我们在Ubuntu上配置caffe的时候就已经自动生成了,在caffe目录下面的src/caffe/proto/文件路径下面的caffe.proto文件中,建议各位读者朋友们对该文档建立大概的了解。在此文件中我们可以浏览深度神经网络设计规范,在此笔者想提醒大家的是,此规范使用的语法格式是google protobuf规范,因此,建议各位读者在阅读caffe.proto之前对google protobuf做一定的了解。在此笔者参照的是AlexNet经典网络,在./caffe/forkrecognition/路径下面建立一个train_val.prototxt文件并在其中撰写深度神经网络架构,内容如下所示。
  1. name: "AlexNet"       #网络名称
  2. layer {               #定义数据层
  3.   name: "forkdata"    #层名称
  4.   type: "Data"        #层类型
  5.   top: "data"         #层输出数据1:图像数据
  6.   top: "label"        #层输出数据2:图像标签,规定岔路口还是非岔路口
  7.   include {
  8.     phase: TRAIN      #规定此数据层只有在训练的时候调用
  9.   }
  10.   transform_param {
  11.     mirror: true      #制作镜像
  12.     crop_size: 227    #裁减了图像,请注意是裁剪不是缩放,如果需要缩放图像可以使用scale参数
  13.     mean_file: "forkrecognition/imagenet_mean.binaryproto"   #均值文件路径
  14.   }
  15.   data_param {
  16.     source: "forkrecognition/train_lmdb"    #训练集路径
  17.     batch_size: 5     #训练批次大小,就是训练一次送进网络多少图片,因为笔者数据集较少,因此批次容量也较小
  18.     backend: LMDB     #指定训练集的格式
  19.   }
  20. }
  21. layer {
  22.   name: "forkdata"   #此层数据用于训练模型时的测试数据
  23.   type: "Data"
  24.   top: "data"
  25.   top: "label"
  26.   include {
  27.     phase: TEST      #规定此数据只有在测试训练成果的时候调用
  28.   }
  29.   transform_param {
  30.     mirror: false
  31.     crop_size: 227
  32.     mean_file: "forkrecognition/imagenet_mean.binaryproto"
  33.   }
  34.   data_param {
  35.     source: "forkrecognition/test_lmdb"     #制定测试集路径
  36.     batch_size: 5
  37.     backend: LMDB
  38.   }
  39. }
  40. layer {        #定义卷积层
  41.   name: "conv1"
  42.   type: "Convolution"
  43.   bottom: "data"    #该层的输入为数据层的输出
  44.   top: "conv1"      #该层的输出
  45.   param {
  46.     lr_mult: 1    #规定学习率乘子
  47.     decay_mult: 1  #规定权重衰减乘子
  48.   }
  49.   param {
  50.     lr_mult: 2
  51.     decay_mult: 0
  52.   }
  53.   convolution_param {
  54.     num_output: 96    #规定一层输出元素的个数
  55.     kernel_size: 11   #规定卷积核的大小
  56.     stride: 4         #规定卷积核操作步长
  57.     weight_filler {
  58.       type: "gaussian"  #指定权重过滤器类型为高斯滤波
  59.       std: 0.01         #在高斯滤波中需要用到的标准差大小
  60.     }
  61.     bias_filler {
  62.       type: "constant"  #指定便宜滤波器类型为常值滤波
  63.       value: 0
  64.     }
  65.   }
  66. }
  67. layer {
  68.   name: "relu1"    #激励层
  69.   type: "ReLU"
  70.   bottom: "conv1"
  71.   top: "conv1"
  72. }
  73. layer {        #局部相应归一化层
  74.   name: "norm1"
  75.   type: "LRN"
  76.   bottom: "conv1"
  77.   top: "norm1"
  78.   lrn_param {
  79.     local_size: 5    #表征通道内归一化时求和区间的边长
  80.     alpha: 0.0001    #缩放因子
  81.     beta: 0.75       #指数项
  82.   }
  83. }
  84. layer {             #定义池化层
  85.   name: "pool1"     
  86.   type: "Pooling"
  87.   bottom: "norm1"
  88.   top: "pool1"
  89.   pooling_param {
  90.     pool: MAX        #池化操作类型
  91.     kernel_size: 3   #进行池化操作的核的大小
  92.     stride: 2        #进行池化操作时的步长
  93.   }
  94. }
  95. layer {
  96.   name: "conv2"
  97.   type: "Convolution"
  98.   bottom: "pool1"
  99.   top: "conv2"
  100.   param {
  101.     lr_mult: 1
  102.     decay_mult: 1
  103.   }
  104.   param {
  105.     lr_mult: 2
  106.     decay_mult: 0
  107.   }
  108.   convolution_param {
  109.     num_output: 256
  110.     pad: 2
  111.     kernel_size: 5
  112.     group: 2
  113.     weight_filler {
  114.       type: "gaussian"
  115.       std: 0.01
  116.     }
  117.     bias_filler {
  118.       type: "constant"
  119.       value: 0.1
  120.     }
  121.   }
  122. }
  123. layer {
  124.   name: "relu2"
  125.   type: "ReLU"
  126.   bottom: "conv2"
  127.   top: "conv2"
  128. }
  129. layer {
  130.   name: "norm2"
  131.   type: "LRN"
  132.   bottom: "conv2"
  133.   top: "norm2"
  134.   lrn_param {
  135.     local_size: 5
  136.     alpha: 0.0001
  137.     beta: 0.75
  138.   }
  139. }
  140. layer {
  141.   name: "pool2"
  142.   type: "Pooling"
  143.   bottom: "norm2"
  144.   top: "pool2"
  145.   pooling_param {
  146.     pool: MAX
  147.     kernel_size: 3
  148.     stride: 2
  149.   }
  150. }
  151. layer {
  152.   name: "conv3"
  153.   type: "Convolution"
  154.   bottom: "pool2"
  155.   top: "conv3"
  156.   param {
  157.     lr_mult: 1
  158.     decay_mult: 1
  159.   }
  160.   param {
  161.     lr_mult: 2
  162.     decay_mult: 0
  163.   }
  164.   convolution_param {
  165.     num_output: 384
  166.     pad: 1
  167.     kernel_size: 3
  168.     weight_filler {
  169.       type: "gaussian"
  170.       std: 0.01
  171.     }
  172.     bias_filler {
  173.       type: "constant"
  174.       value: 0
  175.     }
  176.   }
  177. }
  178. layer {
  179.   name: "relu3"
  180.   type: "ReLU"
  181.   bottom: "conv3"
  182.   top: "conv3"
  183. }
  184. layer {
  185.   name: "conv4"
  186.   type: "Convolution"
  187.   bottom: "conv3"
  188.   top: "conv4"
  189.   param {
  190.     lr_mult: 1
  191.     decay_mult: 1
  192.   }
  193.   param {
  194.     lr_mult: 2
  195.     decay_mult: 0
  196.   }
  197.   convolution_param {
  198.     num_output: 384
  199.     pad: 1
  200.     kernel_size: 3
  201.     group: 2
  202.     weight_filler {
  203.       type: "gaussian"
  204.       std: 0.01
  205.     }
  206.     bias_filler {
  207.       type: "constant"
  208.       value: 0.1
  209.     }
  210.   }
  211. }
  212. layer {
  213.   name: "relu4"
  214.   type: "ReLU"
  215.   bottom: "conv4"
  216.   top: "conv4"
  217. }
  218. layer {
  219.   name: "conv5"
  220.   type: "Convolution"
  221.   bottom: "conv4"
  222.   top: "conv5"
  223.   param {
  224.     lr_mult: 1
  225.     decay_mult: 1
  226.   }
  227.   param {
  228.     lr_mult: 2
  229.     decay_mult: 0
  230.   }
  231.   convolution_param {
  232.     num_output: 256
  233.     pad: 1
  234.     kernel_size: 3
  235.     group: 2
  236.     weight_filler {
  237.       type: "gaussian"
  238.       std: 0.01
  239.     }
  240.     bias_filler {
  241.       type: "constant"
  242.       value: 0.1
  243.     }
  244.   }
  245. }
  246. layer {
  247.   name: "relu5"
  248.   type: "ReLU"
  249.   bottom: "conv5"
  250.   top: "conv5"
  251. }
  252. layer {
  253.   name: "pool5"
  254.   type: "Pooling"
  255.   bottom: "conv5"
  256.   top: "pool5"
  257.   pooling_param {
  258.     pool: MAX
  259.     kernel_size: 3
  260.     stride: 2
  261.   }
  262. }
  263. layer {                #定义全连接层
  264.   name: "fc6"            
  265.   type: "InnerProduct"
  266.   bottom: "pool5"
  267.   top: "fc6"
  268.   param {
  269.     lr_mult: 1
  270.     decay_mult: 1
  271.   }
  272.   param {
  273.     lr_mult: 2
  274.     decay_mult: 0
  275.   }
  276.   inner_product_param {
  277.     num_output: 4096
  278.     weight_filler {
  279.       type: "gaussian"
  280.       std: 0.005
  281.     }
  282.     bias_filler {
  283.       type: "constant"
  284.       value: 0.1
  285.     }
  286.   }
  287. }
  288. layer {
  289.   name: "relu6"
  290.   type: "ReLU"
  291.   bottom: "fc6"
  292.   top: "fc6"
  293. }
  294. layer {
  295.   name: "drop6"
  296.   type: "Dropout"
  297.   bottom: "fc6"
  298.   top: "fc6"
  299.   dropout_param {
  300.     dropout_ratio: 0.5
  301.   }
  302. }
  303. layer {
  304.   name: "fc7"
  305.   type: "InnerProduct"
  306.   bottom: "fc6"
  307.   top: "fc7"
  308.   param {
  309.     lr_mult: 1
  310.     decay_mult: 1
  311.   }
  312.   param {
  313.     lr_mult: 2
  314.     decay_mult: 0
  315.   }
  316.   inner_product_param {
  317.     num_output: 4096
  318.     weight_filler {
  319.       type: "gaussian"
  320.       std: 0.005
  321.     }
  322.     bias_filler {
  323.       type: "constant"
  324.       value: 0.1
  325.     }
  326.   }
  327. }
  328. layer {
  329.   name: "relu7"
  330.   type: "ReLU"
  331.   bottom: "fc7"
  332.   top: "fc7"
  333. }
  334. layer {          #定义dropout层,目的是防止cnn过拟合,在模型训练时随机让网络某些隐含层节点的权重不工作,不工作的那些节点可以暂时认为不是网络结构的                                     #一部分,但是它的权重得保留下来(只是暂时不更新而已)
  335.   name: "drop7"
  336.   type: "Dropout"
  337.   bottom: "fc7"
  338.   top: "fc7"
  339.   dropout_param {
  340.     dropout_ratio: 0.5     #定义选择节点的概率
  341.   }
  342. }
  343. layer {
  344.   name: "forkfc8"
  345.   type: "InnerProduct"
  346.   bottom: "fc7"
  347.   top: "fc8"
  348.   param {
  349.     lr_mult: 1
  350.     decay_mult: 1
  351.   }
  352.   param {
  353.     lr_mult: 2
  354.     decay_mult: 0
  355.   }
  356.   inner_product_param {
  357.     num_output: 2
  358.     weight_filler {
  359.       type: "gaussian"
  360.       std: 0.01
  361.     }
  362.     bias_filler {
  363.       type: "constant"
  364.       value: 0
  365.     }
  366.   }
  367. }
  368. layer {               #定义准确率层
  369.   name: "accuracy"
  370.   type: "Accuracy"
  371.   bottom: "fc8"
  372.   bottom: "label"
  373.   top: "accuracy"
  374.   include {
  375.     phase: TEST
  376.   }
  377. }
  378. layer {              #定义损失层
  379.   name: "loss"
  380.   type: "SoftmaxWithLoss"
  381.   bottom: "fc8"
  382.   bottom: "label"
  383.   top: "loss"
  384. }
复制代码

值得注意的是,请各位读者朋友们观察定义网络时文档最开始两个名为"forkdata"的层和文档末尾名为"accuracy"和"loss"的层,这些层限定了训练时网络的输入与输出,两个"forkdata"层分别指定了训练网络时训练集和测试集的数据来源和均值文件来源,还规定了训练图像尺寸与批次;而通过"accuracy"层我们可以的得到训练出网络的准确率以评估网络的优劣,通过"loss"层我们可以得到训练网络时的损失;看到这里读者朋友可能已经看出了端倪,就是这四个层都和“训练网络”有关!请读者朋友切记,这四个层就是我们在训练网络和使用训练完毕的网络时最大的不同,这四个层是仅仅用于训练阶段的。



好了,到此就生成了进行网络训练的均值文件和描述网络架构的.prototxt文件,接下来,我们就可以训练模型了!
预知后事如何,请听下回:“caffe初探3:网络模型训练”分解~
原文:https://blog.csdn.net/jiongnima/article/details/52678320






使用道具 举报 回复
您需要登录后才可以回帖 登录 | 注nanjixiong2017册

本版积分规则