本文主要讲解caffe的整个使用流程，适用于初级入门caffe，通过学习本篇博文，理清项目训练、测试流程。初级教程，高手请绕道。

我们知道，在caffe编译完后，在caffe目录下会生成一个build目录，在build目录下有个tools，这个里面有个可执行文件caffe，如下图所示：

有了这个可执行文件我们就可以进行模型的训练，只需要学会调用这个可执行文件就可以了，这便是最简单的caffe学习，不需要对caffe底层的东西懂太多，只需要会调参数，就可以构建自己的网络，然后调用这个可执行文件就可以进行训练，当然如果你不仅仅是调参数，而且想要更改相关的算法，那就要深入学习caffe的底层函数调用了，这个以后再讲。本篇博文仅适合于刚入门学习caffe，高手请绕道。废话不多说，回归正题：

一、总流程

完成一个简单的自己的网络模型训练预测，主要包含几个步骤：

1、数据格式处理，也就是把我们的图片.jpg,.png等图片以及标注标签,打包在一起，搞成caffe可以直接方便调用的文件。后面我将具体讲解如何打包自己的数据，让caffe进行调用。

2、编写网络结构文件，这个文件的后缀格式是.prototxt。就是编写你的网络有多少层，每一层有多少个特征图，输入、输出……。看个例子，看一下caffe-》example-》mnist-》lenet_train_test.prototxt。这个便是手写字体网络结构文件了，我们需要根据自己的需要学会修改这个文件：

[cpp] view plain copy
  1. <span style="font-size:18px;">name: "LeNet"
  2. layer {
  3. name: "mnist"
  4. type: "Data"  //data层
  5. top: "data"
  6. top: "label"
  7. include {
  8. phase: TRAIN   //训练阶段
  9. }
  10. transform_param {
  11. scale: 0.00390625   //对所有的图片归一化到0~1之间，也就是对输入数据全部乘以scale，0.0039= 1/255
  12. }
  13. data_param {
  14. source: "examples/mnist/mnist_train_lmdb"  //训练数据图片路径
  15. batch_size: 64    //每次训练采用的图片64张，min-batch
  16. backend: LMDB
  17. }
  18. }
  19. layer {
  20. name: "mnist"
  21. type: "Data"
  22. top: "data"
  23. top: "label"
  24. include {
  25. phase: TEST   //测试
  26. }
  27. transform_param {
  28. scale: 0.00390625
  29. }
  30. data_param {
  31. source: "examples/mnist/mnist_test_lmdb" //测试数据图片路径
  32. batch_size: 100
  33. backend: LMDB
  34. }
  35. }
  36. layer {
  37. name: "conv1"   //卷积神经网络的第一层，卷积层
  38. type: "Convolution"  //这层操作为卷积
  39. bottom: "data"   //这一层的前一层是data层
  40. top: "conv1"   //
  41. param {
  42. lr_mult: 1
  43. }
  44. param {
  45. lr_mult: 2
  46. }
  47. convolution_param {
  48. num_output: 20    //定义输出特征图个数
  49. kernel_size: 5    //定义卷积核大小
  50. stride: 1
  51. weight_filler {
  52. type: "xavier"
  53. }
  54. bias_filler {
  55. type: "constant"
  56. }
  57. }
  58. }
  59. layer {
  60. name: "pool1"
  61. type: "Pooling"      //池化层，这一层的操作为池化
  62. bottom: "conv1"   //这一层的前面一层名字为：conv1
  63. top: "pool1"
  64. pooling_param {
  65. pool: MAX   //最大池化
  66. kernel_size: 2
  67. stride: 2
  68. }
  69. }
  70. layer {
  71. name: "conv2"
  72. type: "Convolution"
  73. bottom: "pool1"
  74. top: "conv2"
  75. param {
  76. lr_mult: 1
  77. }
  78. param {
  79. lr_mult: 2
  80. }
  81. convolution_param {
  82. num_output: 50
  83. kernel_size: 5
  84. stride: 1
  85. weight_filler {
  86. type: "xavier"
  87. }
  88. bias_filler {
  89. type: "constant"
  90. }
  91. }
  92. }
  93. layer {
  94. name: "pool2"
  95. type: "Pooling"
  96. bottom: "conv2"
  97. top: "pool2"
  98. pooling_param {
  99. pool: MAX
  100. kernel_size: 2
  101. stride: 2
  102. }
  103. }
  104. layer {
  105. name: "ip1"
  106. type: "InnerProduct"
  107. bottom: "pool2"
  108. top: "ip1"
  109. param {
  110. lr_mult: 1
  111. }
  112. param {
  113. lr_mult: 2
  114. }
  115. inner_product_param {
  116. num_output: 500
  117. weight_filler {
  118. type: "xavier"
  119. }
  120. bias_filler {
  121. type: "constant"
  122. }
  123. }
  124. }
  125. layer {
  126. name: "relu1"
  127. type: "ReLU"
  128. bottom: "ip1"
  129. top: "ip1"
  130. }
  131. layer {
  132. name: "ip2"
  133. type: "InnerProduct"
  134. bottom: "ip1"
  135. top: "ip2"
  136. param {
  137. lr_mult: 1
  138. }
  139. param {
  140. lr_mult: 2
  141. }
  142. inner_product_param {
  143. num_output: 10
  144. weight_filler {
  145. type: "xavier"
  146. }
  147. bias_filler {
  148. type: "constant"
  149. }
  150. }
  151. }
  152. layer {
  153. name: "accuracy"
  154. type: "Accuracy"
  155. bottom: "ip2"
  156. bottom: "label"
  157. top: "accuracy"
  158. include {
  159. phase: TEST
  160. }
  161. }
  162. layer {
  163. name: "loss"
  164. type: "SoftmaxWithLoss"
  165. bottom: "ip2"
  166. bottom: "label"
  167. top: "loss"
  168. }</span>

上面的网络结构，定义的data层，就是定义我们输入的训练数据的路径、图片变换等。

3、网络求解文件，这个文件我们喜欢把它取名为：solver.prototxt，这个文件的后缀格式也是.prototxt。这个文件主要包含了一些求解网络，梯度下降参数、迭代次数等参数……，看下手写字体的solver.prototxt文件：

[cpp] view plain copy
  1. <span style="font-size:18px;">net: "examples/mnist/lenet_train_test.prototxt"  //定义网络结构文件，也就是我们上一步编写的文件
  2. test_iter: 100
  3. test_interval: 500 //每隔500次用测试数据，做一次验证
  4. base_lr: 0.01     //学习率
  5. momentum: 0.9   //动量参数
  6. weight_decay: 0.0005   //权重衰减系数
  7. lr_policy: "inv"   //梯度下降的相关优化策略
  8. gamma: 0.0001
  9. power: 0.75
  10. display: 100
  11. max_iter: 10000   //最大迭代次数
  12. snapshot: 5000    //每迭代5000次，保存一次结果
  13. snapshot_prefix: "examples/mnist/lenet" //保存结果路径
  14. solver_mode: GPU   //训练硬件设备选择GPU还是CPU</span>

这个文件的输入就是我们前面一步定义的网络结构。

4、编写网络求解文件后，我们可以说已经完成了CNN网络的编写。接着我们需要把这个文件，作为caffe的输入参数，调用caffe可执行文件，进行训练就可以了。具体的命令如下：

[cpp] view plain copy
  1. ./build/tools/caffe train --solver=examples/mnist/lenet_solver.prototxt

这样就完事了，程序就开始训练了。上面的第一个参数caffe，就是我们在编译caffe，生成的可执行文件：

然后solver就是我们在步骤3编写的solver文件了，只要在ubuntu终端输入上面的命令，就可以开始训练了。

回想一下文件调用过程：首先caffe可执行文件，调用了solver.prototxt文件，而这个文件又调用了网络结构文件lenet_train_test.prototxt，然后lenet_train_test.prototxt文件里面又会调用输入的训练图片数据等。因此我们如果要训练自己的模型，需要备好3个文件：数据文件lmdb(该文件包含寻数据)、网络结构lenet_train_test.prototxt、求解文件solver.prototxt，这几个文件名随便，但是文件后缀格式不要随便乱改。把这三个文件放在同一个目录下，然后在终端输入命令，调用caffe就可以开始训练了。

二、相关细节

1、lmdb数据格式生成

caffe输入训练图片数据我比较喜欢用lmdb格式，好像还有另外一种格式leveldb，这个具体没用过，这里主要讲解lmdb格式数据的制作。其实在caffe-》example-》imagenet文件夹下面的一些脚本文件可以帮助我们快速生产相关的caffe所需的数据。

create_imagenet.sh这个文件可以帮我们快速的生成lmdb的数据格式文件，因此我们只需要把这个脚本文件复制出来，稍作修改，就可以对我们的训练图片、标注文件进行打包为lmdb格式文件了。制作图片的脚本文件如下：

[python] view plain copy
  1. <span style="font-size:18px;">#!/usr/bin/env sh
  2. # Create the imagenet lmdb inputs
  3. # N.B. set the path to the imagenet train + val data dirs
  4. EXAMPLE=.          # 生成模型训练数据文化夹
  5. TOOLS=../../build/tools                              # caffe的工具库，不用变
  6. DATA=.                  # python脚步处理后数据路径
  7. TRAIN_DATA_ROOT=train/  #待处理的训练数据图片路径
  8. VAL_DATA_ROOT=val/      # 带处理的验证数据图片路径
  9. # Set RESIZE=true to resize the images to 256x256. Leave as false if images have
  10. # already been resized using another tool.
  11. RESIZE=true   #图片缩放
  12. if $RESIZE; then
  13. RESIZE_HEIGHT=256
  14. RESIZE_WIDTH=256
  15. else
  16. RESIZE_HEIGHT=0
  17. RESIZE_WIDTH=0
  18. fi
  19. if [ ! -d "$TRAIN_DATA_ROOT" ]; then
  20. echo "Error: TRAIN_DATA_ROOT is not a path to a directory: $TRAIN_DATA_ROOT"
  21. echo "Set the TRAIN_DATA_ROOT variable in create_imagenet.sh to the path" \
  22. "where the ImageNet training data is stored."
  23. exit 1
  24. fi
  25. if [ ! -d "$VAL_DATA_ROOT" ]; then
  26. echo "Error: VAL_DATA_ROOT is not a path to a directory: $VAL_DATA_ROOT"
  27. echo "Set the VAL_DATA_ROOT variable in create_imagenet.sh to the path" \
  28. "where the ImageNet validation data is stored."
  29. exit 1
  30. fi
  31. echo "Creating train lmdb..."
  32. GLOG_logtostderr=1 $TOOLS/convert_imageset \
  33. --resize_height=$RESIZE_HEIGHT \
  34. --resize_width=$RESIZE_WIDTH \
  35. --shuffle \
  36. $TRAIN_DATA_ROOT \
  37. $DATA/train.txt \     #标签训练数据文件
  38. $EXAMPLE/train_lmdb
  39. echo "Creating val lmdb..."
  40. GLOG_logtostderr=1 $TOOLS/convert_imageset \
  41. --resize_height=$RESIZE_HEIGHT \
  42. --resize_width=$RESIZE_WIDTH \
  43. --shuffle \
  44. $VAL_DATA_ROOT \
  45. $DATA/val.txt \    #验证集标签数据
  46. $EXAMPLE/val_lmdb
  47. echo "Done."</span>

同时我们需要制作如下四个文件：

1、文件夹train，用于存放训练图片

2、文件夹val，用于存放验证图片

3、文件train.txt，里面包含这每张图片的名称，及其对应的标签。

[python] view plain copy
  1. <span style="font-size:18px;">first_batch/train_female/992.jpg    1
  2. first_batch/train_female/993.jpg    1
  3. first_batch/train_female/994.jpg    1
  4. first_batch/train_female/995.jpg    1
  5. first_batch/train_female/996.jpg    1
  6. first_batch/train_female/997.jpg    1
  7. first_batch/train_female/998.jpg    1
  8. first_batch/train_female/999.jpg    1
  9. first_batch/train_male/1000.jpg 0
  10. first_batch/train_male/1001.jpg 0
  11. first_batch/train_male/1002.jpg 0
  12. first_batch/train_male/1003.jpg 0
  13. first_batch/train_male/1004.jpg 0
  14. first_batch/train_male/1005.jpg 0
  15. first_batch/train_male/1006.jpg 0
  16. first_batch/train_male/1007.jpg 0
  17. first_batch/train_male/1008.jpg 0</span>

上面的标签编号:1，表示女。标签：0，表示男。

4、文件val.txt，同样这个文件也是保存图片名称及其对应的标签。

这四个文件在上面的脚本文件中，都需要调用到。制作玩后，跑一下上面的脚本文件，就ok了，跑完后，即将生成下面两个文件夹：

文件夹下面有两个对应的文件：

制作完后，要看看文件的大小，有没有问题，如果就几k，那么正常是每做好训练数据，除非你的训练图片就几张。

二、训练

1、直接训练法

[python] view plain copy
  1. #!/usr/bin/env sh
  2. TOOLS=../cafferead/build/tools
  3. $TOOLS/caffe train --solver=gender_solver.prorotxt  -gpu all  #加入 -gpu 选项

-gpu 可以选择gpu的id号，如果是 -gpu all表示启用所有的GPU进行训练。

2、采用funing-tuning 训练法

[python] view plain copy
  1. $TOOLS/caffe train --solver=gender_solver.prorotxt -weights gender_net.caffemodel #加入-weights

加入-weights，这个功能很好用，也经常会用到，因为现在的CNN相关的文献，很多都是在已有的模型基础上，进行fine-tuning，因为我们大部分人都缺少训练数据，不像谷歌、百度这些土豪公司，有很多人专门做数据标注，对于小公司而言，往往缺少标注好的训练数据。因此我们一般使用fine-tuning的方法，在少量数据的情况下，尽可能的提高精度。我们可以使用：-weights 选项，利用已有的模型训练好的参数，作为初始值，进行继续训练。

三、调用Python接口

训练完毕后，我们就可以得到caffe的训练模型了，接着我们的目标就预测，看看结果了。caffe为我们提供了方便调用的python接口函数，这些都在模块pycaffe里面。因此我们还需要知道如何使用pycaffe，进行测试，查看结果。下面是pycaffe的预测调用使用示例：

[python] view plain copy
  1. # coding=utf-8
  2. import os
  3. import numpy as np
  4. from matplotlib import pyplot as plt
  5. import cv2
  6. import shutil
  7. import time
  8. #因为RGB和BGR需要调换一下才能显示
  9. def showimage(im):
  10. if im.ndim == 3:
  11. im = im[:, :, ::-1]
  12. plt.set_cmap('jet')
  13. plt.imshow(im)
  14. plt.show()
  15. #特征可视化显示，padval用于调整亮度
  16. def vis_square(data, padsize=1, padval=0):
  17. data -= data.min()
  18. data /= data.max()
  19. #因为我们要把某一层的特征图都显示到一个figure上，因此需要计算每个图片占用figure多少比例，以及绘制的位置
  20. n = int(np.ceil(np.sqrt(data.shape[0])))
  21. padding = ((0, n ** 2 - data.shape[0]), (0, padsize), (0, padsize)) + ((0, 0),) * (data.ndim - 3)
  22. data = np.pad(data, padding, mode='constant', constant_values=(padval, padval))
  23. # tile the filters into an image
  24. data = data.reshape((n, n) + data.shape[1:]).transpose((0, 2, 1, 3) + tuple(range(4, data.ndim + 1)))
  25. data = data.reshape((n * data.shape[1], n * data.shape[3]) + data.shape[4:])
  26. showimage(data)
  27. #设置caffe源码所在的路径
  28. caffe_root = '../../../caffe/'
  29. import sys
  30. sys.path.insert(0, caffe_root + 'python')
  31. import caffe
  32. #加载均值文件
  33. mean_filename='./imagenet_mean.binaryproto'
  34. proto_data = open(mean_filename, "rb").read()
  35. a = caffe.io.caffe_pb2.BlobProto.FromString(proto_data)
  36. mean  = caffe.io.blobproto_to_array(a)[0]
  37. #创建网络，并加载已经训练好的模型文件
  38. gender_net_pretrained='./caffenet_train_iter_1500.caffemodel'
  39. gender_net_model_file='./deploy_gender.prototxt'
  40. gender_net = caffe.Classifier(gender_net_model_file, gender_net_pretrained,mean=mean,
  41. channel_swap=(2,1,0),#RGB通道与BGR
  42. raw_scale=255,#把图片归一化到0~1之间
  43. image_dims=(256, 256))#设置输入图片的大小
  44. #预测分类及其可特征视化
  45. gender_list=['Male','Female']
  46. input_image = caffe.io.load_image('1.jpg')#读取图片
  47. prediction_gender=gender_net.predict([input_image])#预测图片性别
  48. #打印我们训练每一层的参数形状
  49. print 'params:'
  50. for k, v in gender_net.params.items():
  51. print 'weight:'
  52. print (k, v[0].data.shape)#在每一层的参数blob中，caffe用vector存储了两个blob变量，用v[0]表示weight
  53. print 'b:'
  54. print (k, v[1].data.shape)#用v[1]表示偏置参数
  55. #conv1滤波器可视化
  56. filters = gender_net.params['conv1'][0].data
  57. vis_square(filters.transpose(0, 2, 3, 1))
  58. #conv2滤波器可视化
  59. '''''filters = gender_net.params['conv2'][0].data
  60. vis_square(filters[:48].reshape(48**2, 5, 5))'''
  61. #特征图
  62. print 'feature maps:'
  63. for k, v in gender_net.blobs.items():
  64. print (k, v.data.shape);
  65. feat = gender_net.blobs[k].data[0,0:4]#显示名字为k的网络层,第一张图片所生成的4张feature maps
  66. vis_square(feat, padval=1)
  67. #显示原图片，以及分类预测结果
  68. str_gender=gender_list[prediction_gender[0].argmax()]
  69. print str_gender
  70. plt.imshow(input_image)
  71. plt.title(str_gender)
  72. plt.show()

上面的接口，同时包含了pycaffe加载训练好的模型，进行预测及其特征可视化的调用方法。

深度学习 deep learning caffe CNN
摘要：Caffe是一个清晰而高效的深度学习框架，本文详细介绍了caffe的优势、架构，网络定义、各层定义，Caffe的安装与配置，解读了Caffe实现的图像分类模型AlexNet，并演示了CIFAR-10在caffe上进行训练与学习。

Caffe是一个清晰而高效的深度学习框架，其作者是博士毕业于UC Berkeley的 贾扬清，目前在Google工作。

Caffe是纯粹的C++/CUDA架构，支持命令行、Python和MATLAB接口；可以在CPU和GPU直接无缝切换：

Caffe::set_mode(Caffe::GPU);

Caffe的优势

  1. 上手快：模型与相应优化都是以文本形式而非代码形式给出。
    Caffe给出了模型的定义、最优化设置以及预训练的权重，方便立即上手。
  2. 速度快：能够运行最棒的模型与海量的数据。
    Caffe与cuDNN结合使用，测试AlexNet模型，在K40上处理每张图片只需要1.17ms.
  3. 模块化：方便扩展到新的任务和设置上。
    可以使用Caffe提供的各层类型来定义自己的模型。
  4. 开放性：公开的代码和参考模型用于再现。
  5. 社区好：可以通过BSD-2参与开发与讨论。

Caffe的网络定义

Caffe中的网络都是有向无环图的集合，可以直接定义：

name: "dummy-net"
layers {<span><span>name: <span>"data" …</span></span></span>}
layers {<span><span>name: <span>"conv" …</span></span></span>}
layers {<span><span>name: <span>"pool" …</span></span></span>}
layers {<span><span>name: <span>"loss" …</span></span></span>}

数据及其导数以blobs的形式在层间流动。

Caffe的各层定义

Caffe层的定义由2部分组成：层属性与层参数，例如

name:"conv1"
type:CONVOLUTION
bottom:"data"
top:"conv1"
convolution_param{num_output:<span>20kernel_size:5stride:1weight_filler{type: "<span style="color: #c0504d;">xavier</span>"}
}

这段配置文件的前4行是层属性，定义了层名称、层类型以及层连接结构（输入blob和输出blob）；而后半部分是各种层参数。

Blob

Blob是用以存储数据的4维数组，例如

  • 对于数据：Number*Channel*Height*Width
  • 对于卷积权重：Output*Input*Height*Width
  • 对于卷积偏置：Output*1*1*1

训练网络

网络参数的定义也非常方便，可以随意设置相应参数。

甚至调用GPU运算只需要写一句话：

solver_mode:GPU

Caffe的安装与配置

Caffe需要预先安装一些依赖项，首先是CUDA驱动。不论是CentOS还是Ubuntu都预装了开源的nouveau显卡驱动（SUSE没有这种问题），如果不禁用，则CUDA驱动不能正确安装。以Ubuntu为例，介绍一下这里的处理方法，当然也有其他处理方法。

生成mnist-train-leveldb/ 和 mnist-test-leveldb/，把数据转化成leveldb格式：

训练网络:

# sudo vi/etc/modprobe.d/blacklist.conf
# 增加一行 ：blacklist nouveau
sudoapt-get --purge remove xserver-xorg-video-nouveau   #把官方驱动彻底卸载：
sudoapt-get --purge remove nvidia-*    #清除之前安装的任何NVIDIA驱动
sudo service lightdm stop    #进命令行，关闭Xserver
sudo kill all Xorg

安装了CUDA之后，依次按照Caffe官网安装指南安装BLAS、OpenCV、Boost即可。

Caffe跑跑MNIST试试

在Caffe安装目录之下，首先获得MNIST数据集：

cd data/mnist
sh get_mnist.sh

生成mnist-train-leveldb/ 和 mnist-test-leveldb/，把数据转化成leveldb格式：

cd examples/lenet
sh create_mnist.sh

训练网络:

sh train_lenet.sh

让Caffe生成的数据集能在Theano上直接运行

不论使用何种框架进行CNNs训练，共有3种数据集：

  • Training Set：用于训练网络
  • Validation Set：用于训练时测试网络准确率
  • Test Set：用于测试网络训练完成后的最终正确率

Caffe生成的数据分为2种格式：Lmdb和Leveldb

  • 它们都是键/值对（Key/Value Pair）嵌入式数据库管理系统编程库。
  • 虽然lmdb的内存消耗是leveldb的1.1倍，但是lmdb的速度比leveldb快10%至15%，更重要的是lmdb允许多种训练模型同时读取同一组数据集。
  • 因此lmdb取代了leveldb成为Caffe默认的数据集生成格式。

Google Protocol Buffer的安装

Protocol Buffer是一种类似于XML的用于序列化数据的自动机制。
首先在Protocol Buffers的中下载最新版本：
https://developers.google.com/protocol-buffers/docs/downloads
解压后运行：

./configure
$ make
$ make check
$ make install
pip installprotobuf

添加动态链接库

export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH

Lmdb的安装

pip install lmdb

要parse（解析）一个protobuf类型数据，首先要告诉计算机你这个protobuf数据内部是什么格式（有哪些项，这些项各是什么数据类型的决定了占用多少字节，这些项可否重复，重复几次），安装protobuf这个module就可以用protobuf专用的语法来定义这些格式（这个是.proto文件）了，然后用protoc来编译这个.proto文件就可以生成你需要的目标文件。
想要定义自己的.proto文件请阅读：
https://developers.google.com/protocol-buffers/docs/proto?hl=zh-cn

编译.proto文件

protoc--proto_path=IMPORT_PATH --cpp_out=DST_DIR --java_out=DST_DIR--python_out=DST_DIR path/to/file.proto
--proto_path 也可以简写成-I 是.proto所在的路径
输出路径：
--cpp_out 要生成C++可用的头文件，分别是***.pb.h（包含申明类）***.pb.cc（包含可执行类），使用的时候只要include “***.pb.h”
--java_out 生成java可用的头文件
--python_out 生成python可用的头文件，**_pb2.py，使用的时候import**_pb2.py即可
最后一个参数就是你的.proto文件完整路径。

Caffe (CNN, deep learning) 介绍

Caffe -----------Convolution Architecture For Feature Embedding (Extraction)

  1. Caffe 是什么东东？

    • CNN (Deep Learning) 工具箱
    • C++ 语言架构
    • CPU 和GPU 无缝交换
    • Python 和matlab的封装
    • 但是，Decaf只是CPU 版本。

  2. 为什么要用Caffe？

    • 运算速度快。简单 友好的架构 用到的一些库：
    • Google Logging library (Glog): 一个C++语言的应用级日志记录框架，提供了C++风格的流操作和各种助手宏.
    • lebeldb(数据存储)： 是一个google实现的非常高效的kv数据库，单进程操作。
    • CBLAS library（CPU版本的矩阵操作）
    • CUBLAS library (GPU 版本的矩阵操作)

  3. Caffe 架构

  1. 预处理图像的leveldb构建
    输入：一批图像和label （2和3）
    输出：leveldb （4）
    指令里包含如下信息：

    • conver_imageset （构建leveldb的可运行程序）
    • train/ （此目录放处理的jpg或者其他格式的图像)
    • label.txt (图像文件名及其label信息)
    • 输出的leveldb文件夹的名字
    • CPU/GPU (指定是在cpu上还是在gpu上运行code)

  2. CNN网络配置文件

    • Imagenet_solver.prototxt （包含全局参数的配置的文件）
    • Imagenet.prototxt （包含训练网络的配置的文件）
    • Imagenet_val.prototxt （包含测试网络的配置文件）

Caffe深度学习之图像分类模型AlexNet解读

在imagenet上的图像分类challenge上Alex提出的alexnet网络结构模型赢得了2012届的冠军。要研究CNN类型DL网络模型在图像分类上的应用，就逃不开研究alexnet，这是CNN在图像分类上的经典模型（DL火起来之后）。

在DL开源实现caffe的model样例中，它也给出了alexnet的复现，具体网络配置文件如下 train_val.prototxt

接下来本文将一步步对该网络配置结构中各个层进行详细的解读（训练阶段）：

各种layer的operation更多解释可以参考 Caffe Layer Catalogue

从计算该模型的数据流过程中，该模型参数大概5kw+。

  1. conv1阶段DFD（data flow diagram）： 

  2. conv2阶段DFD（data flow diagram）：

  3. conv3阶段DFD（data flow diagram）：

  4. conv4阶段DFD（data flow diagram）：

  5. conv5阶段DFD（data flow diagram）：

  6. fc6阶段DFD（data flow diagram）：

  7. fc7阶段DFD（data flow diagram）：
                 

  8. fc8阶段DFD（data flow diagram）：

caffe的输出中也有包含这块的内容日志，详情如下：

I0721 10:38:15.326920  4692 net.cpp:125] Top shape: 256 3 227 227 (39574272)
I0721 10:38:15.326971  4692 net.cpp:125] Top shape: 256 1 1 1 (256)
I0721 10:38:15.326982  4692 net.cpp:156] data does not need backward computation.
I0721 10:38:15.327003  4692 net.cpp:74] Creating Layer conv1
I0721 10:38:15.327011  4692 net.cpp:84] conv1 <- data
I0721 10:38:15.327033  4692 net.cpp:110] conv1 -> conv1
I0721 10:38:16.721956  4692 net.cpp:125] Top shape: 256 96 55 55 (74342400)
I0721 10:38:16.722030  4692 net.cpp:151] conv1 needs backward computation.
I0721 10:38:16.722059  4692 net.cpp:74] Creating Layer relu1
I0721 10:38:16.722070  4692 net.cpp:84] relu1 <- conv1
I0721 10:38:16.722082  4692 net.cpp:98] relu1 -> conv1 (in-place)
I0721 10:38:16.722096  4692 net.cpp:125] Top shape: 256 96 55 55 (74342400)
I0721 10:38:16.722105  4692 net.cpp:151] relu1 needs backward computation.
I0721 10:38:16.722116  4692 net.cpp:74] Creating Layer pool1
I0721 10:38:16.722125  4692 net.cpp:84] pool1 <- conv1
I0721 10:38:16.722133  4692 net.cpp:110] pool1 -> pool1
I0721 10:38:16.722167  4692 net.cpp:125] Top shape: 256 96 27 27 (17915904)
I0721 10:38:16.722187  4692 net.cpp:151] pool1 needs backward computation.
I0721 10:38:16.722205  4692 net.cpp:74] Creating Layer norm1
I0721 10:38:16.722221  4692 net.cpp:84] norm1 <- pool1
I0721 10:38:16.722234  4692 net.cpp:110] norm1 -> norm1
I0721 10:38:16.722251  4692 net.cpp:125] Top shape: 256 96 27 27 (17915904)
I0721 10:38:16.722260  4692 net.cpp:151] norm1 needs backward computation.
I0721 10:38:16.722272  4692 net.cpp:74] Creating Layer conv2
I0721 10:38:16.722280  4692 net.cpp:84] conv2 <- norm1
I0721 10:38:16.722290  4692 net.cpp:110] conv2 -> conv2
I0721 10:38:16.725225  4692 net.cpp:125] Top shape: 256 256 27 27 (47775744)
I0721 10:38:16.725242  4692 net.cpp:151] conv2 needs backward computation.
I0721 10:38:16.725253  4692 net.cpp:74] Creating Layer relu2
I0721 10:38:16.725261  4692 net.cpp:84] relu2 <- conv2
I0721 10:38:16.725270  4692 net.cpp:98] relu2 -> conv2 (in-place)
I0721 10:38:16.725280  4692 net.cpp:125] Top shape: 256 256 27 27 (47775744)
I0721 10:38:16.725288  4692 net.cpp:151] relu2 needs backward computation.
I0721 10:38:16.725298  4692 net.cpp:74] Creating Layer pool2
I0721 10:38:16.725307  4692 net.cpp:84] pool2 <- conv2
I0721 10:38:16.725317  4692 net.cpp:110] pool2 -> pool2
I0721 10:38:16.725329  4692 net.cpp:125] Top shape: 256 256 13 13 (11075584)
I0721 10:38:16.725338  4692 net.cpp:151] pool2 needs backward computation.
I0721 10:38:16.725358  4692 net.cpp:74] Creating Layer norm2
I0721 10:38:16.725368  4692 net.cpp:84] norm2 <- pool2
I0721 10:38:16.725378  4692 net.cpp:110] norm2 -> norm2
I0721 10:38:16.725389  4692 net.cpp:125] Top shape: 256 256 13 13 (11075584)
I0721 10:38:16.725399  4692 net.cpp:151] norm2 needs backward computation.
I0721 10:38:16.725409  4692 net.cpp:74] Creating Layer conv3
I0721 10:38:16.725419  4692 net.cpp:84] conv3 <- norm2
I0721 10:38:16.725427  4692 net.cpp:110] conv3 -> conv3
I0721 10:38:16.735193  4692 net.cpp:125] Top shape: 256 384 13 13 (16613376)
I0721 10:38:16.735213  4692 net.cpp:151] conv3 needs backward computation.
I0721 10:38:16.735224  4692 net.cpp:74] Creating Layer relu3
I0721 10:38:16.735234  4692 net.cpp:84] relu3 <- conv3
I0721 10:38:16.735242  4692 net.cpp:98] relu3 -> conv3 (in-place)
I0721 10:38:16.735250  4692 net.cpp:125] Top shape: 256 384 13 13 (16613376)
I0721 10:38:16.735258  4692 net.cpp:151] relu3 needs backward computation.
I0721 10:38:16.735302  4692 net.cpp:74] Creating Layer conv4
I0721 10:38:16.735312  4692 net.cpp:84] conv4 <- conv3
I0721 10:38:16.735321  4692 net.cpp:110] conv4 -> conv4
I0721 10:38:16.743952  4692 net.cpp:125] Top shape: 256 384 13 13 (16613376)
I0721 10:38:16.743988  4692 net.cpp:151] conv4 needs backward computation.
I0721 10:38:16.744000  4692 net.cpp:74] Creating Layer relu4
I0721 10:38:16.744010  4692 net.cpp:84] relu4 <- conv4
I0721 10:38:16.744020  4692 net.cpp:98] relu4 -> conv4 (in-place)
I0721 10:38:16.744030  4692 net.cpp:125] Top shape: 256 384 13 13 (16613376)
I0721 10:38:16.744038  4692 net.cpp:151] relu4 needs backward computation.
I0721 10:38:16.744050  4692 net.cpp:74] Creating Layer conv5
I0721 10:38:16.744057  4692 net.cpp:84] conv5 <- conv4
I0721 10:38:16.744067  4692 net.cpp:110] conv5 -> conv5
I0721 10:38:16.748935  4692 net.cpp:125] Top shape: 256 256 13 13 (11075584)
I0721 10:38:16.748955  4692 net.cpp:151] conv5 needs backward computation.
I0721 10:38:16.748965  4692 net.cpp:74] Creating Layer relu5
I0721 10:38:16.748975  4692 net.cpp:84] relu5 <- conv5
I0721 10:38:16.748983  4692 net.cpp:98] relu5 -> conv5 (in-place)
I0721 10:38:16.748998  4692 net.cpp:125] Top shape: 256 256 13 13 (11075584)
I0721 10:38:16.749011  4692 net.cpp:151] relu5 needs backward computation.
I0721 10:38:16.749022  4692 net.cpp:74] Creating Layer pool5
I0721 10:38:16.749030  4692 net.cpp:84] pool5 <- conv5
I0721 10:38:16.749039  4692 net.cpp:110] pool5 -> pool5
I0721 10:38:16.749050  4692 net.cpp:125] Top shape: 256 256 6 6 (2359296)
I0721 10:38:16.749058  4692 net.cpp:151] pool5 needs backward computation.
I0721 10:38:16.749074  4692 net.cpp:74] Creating Layer fc6
I0721 10:38:16.749083  4692 net.cpp:84] fc6 <- pool5
I0721 10:38:16.749091  4692 net.cpp:110] fc6 -> fc6
I0721 10:38:17.160079  4692 net.cpp:125] Top shape: 256 4096 1 1 (1048576)
I0721 10:38:17.160148  4692 net.cpp:151] fc6 needs backward computation.
I0721 10:38:17.160166  4692 net.cpp:74] Creating Layer relu6
I0721 10:38:17.160177  4692 net.cpp:84] relu6 <- fc6
I0721 10:38:17.160190  4692 net.cpp:98] relu6 -> fc6 (in-place)
I0721 10:38:17.160202  4692 net.cpp:125] Top shape: 256 4096 1 1 (1048576)
I0721 10:38:17.160212  4692 net.cpp:151] relu6 needs backward computation.
I0721 10:38:17.160222  4692 net.cpp:74] Creating Layer drop6
I0721 10:38:17.160230  4692 net.cpp:84] drop6 <- fc6
I0721 10:38:17.160238  4692 net.cpp:98] drop6 -> fc6 (in-place)
I0721 10:38:17.160258  4692 net.cpp:125] Top shape: 256 4096 1 1 (1048576)
I0721 10:38:17.160265  4692 net.cpp:151] drop6 needs backward computation.
I0721 10:38:17.160277  4692 net.cpp:74] Creating Layer fc7
I0721 10:38:17.160286  4692 net.cpp:84] fc7 <- fc6
I0721 10:38:17.160295  4692 net.cpp:110] fc7 -> fc7
I0721 10:38:17.342094  4692 net.cpp:125] Top shape: 256 4096 1 1 (1048576)
I0721 10:38:17.342157  4692 net.cpp:151] fc7 needs backward computation.
I0721 10:38:17.342175  4692 net.cpp:74] Creating Layer relu7
I0721 10:38:17.342185  4692 net.cpp:84] relu7 <- fc7
I0721 10:38:17.342198  4692 net.cpp:98] relu7 -> fc7 (in-place)
I0721 10:38:17.342208  4692 net.cpp:125] Top shape: 256 4096 1 1 (1048576)
I0721 10:38:17.342217  4692 net.cpp:151] relu7 needs backward computation.
I0721 10:38:17.342228  4692 net.cpp:74] Creating Layer drop7
I0721 10:38:17.342236  4692 net.cpp:84] drop7 <- fc7
I0721 10:38:17.342245  4692 net.cpp:98] drop7 -> fc7 (in-place)
I0721 10:38:17.342254  4692 net.cpp:125] Top shape: 256 4096 1 1 (1048576)
I0721 10:38:17.342262  4692 net.cpp:151] drop7 needs backward computation.
I0721 10:38:17.342274  4692 net.cpp:74] Creating Layer fc8
I0721 10:38:17.342283  4692 net.cpp:84] fc8 <- fc7
I0721 10:38:17.342291  4692 net.cpp:110] fc8 -> fc8
I0721 10:38:17.343199  4692 net.cpp:125] Top shape: 256 22 1 1 (5632)
I0721 10:38:17.343214  4692 net.cpp:151] fc8 needs backward computation.
I0721 10:38:17.343231  4692 net.cpp:74] Creating Layer loss
I0721 10:38:17.343240  4692 net.cpp:84] loss <- fc8
I0721 10:38:17.343250  4692 net.cpp:84] loss <- label
I0721 10:38:17.343264  4692 net.cpp:151] loss needs backward computation.
I0721 10:38:17.343305  4692 net.cpp:173] Collecting Learning Rate and Weight Decay.
I0721 10:38:17.343327  4692 net.cpp:166] Network initialization done.
I0721 10:38:17.343335  4692 net.cpp:167] Memory required for Data 1073760256

CIFAR-10在caffe上进行训练与学习

使用数据库：CIFAR-10

60000张 32X32 彩色图像 10类，50000张训练，10000张测试

准备

在终端运行以下指令：

cd $CAFFE_ROOT/data/cifar10
./get_cifar10.sh
cd $CAFFE_ROOT/examples/cifar10
./create_cifar10.sh

其中CAFFE_ROOT是caffe-master在你机子的地址

运行之后，将会在examples中出现数据库文件./cifar10-leveldb和数据库图像均值二进制文件./mean.binaryproto

模型

该CNN由卷积层，POOLing层，非线性变换层，在顶端的局部对比归一化线性分类器组成。该模型的定义在CAFFE_ROOT/examples/cifar10 directory’s cifar10_quick_train.prototxt中，可以进行修改。其实后缀为prototxt很多都是用来修改配置的。

训练和测试

训练这个模型非常简单，当我们写好参数设置的文件cifar10_quick_solver.prototxt和定义的文件cifar10_quick_train.prototxt和cifar10_quick_test.prototxt后，运行train_quick.sh或者在终端输入下面的命令：

cd $CAFFE_ROOT/examples/cifar10
./train_quick.sh

即可，train_quick.sh是一个简单的脚本，会把执行的信息显示出来，培训的工具是train_net.bin,cifar10_quick_solver.prototxt作为参数。

然后出现类似以下的信息：这是搭建模型的相关信息

I0317 21:52:48.945710 2008298256 net.cpp:74] Creating Layer conv1
I0317 21:52:48.945716 2008298256 net.cpp:84] conv1 <- data
I0317 21:52:48.945725 2008298256 net.cpp:110] conv1 -> conv1
I0317 21:52:49.298691 2008298256 net.cpp:125] Top shape: 100 32 32 32 (3276800)
I0317 21:52:49.298719 2008298256 net.cpp:151] conv1 needs backward computation.

接着：

0317 21:52:49.309370 2008298256 net.cpp:166] Network initialization done.
I0317 21:52:49.309376 2008298256 net.cpp:167] Memory required for Data 23790808
I0317 21:52:49.309422 2008298256 solver.cpp:36] Solver scaffolding done.
I0317 21:52:49.309447 2008298256 solver.cpp:47] Solving CIFAR10_quick_train

之后，训练开始

I0317 21:53:12.179772 2008298256 solver.cpp:208] Iteration 100, lr = 0.001
I0317 21:53:12.185698 2008298256 solver.cpp:65] Iteration 100, loss = 1.73643
...
I0317 21:54:41.150030 2008298256 solver.cpp:87] Iteration 500, Testing net
I0317 21:54:47.129461 2008298256 solver.cpp:114] Test score #0: 0.5504
I0317 21:54:47.129500 2008298256 solver.cpp:114] Test score #1: 1.27805

其中每100次迭代次数显示一次训练时lr(learningrate),和loss（训练损失函数），每500次测试一次，输出score 0（准确率）和score 1（测试损失函数）

当5000次迭代之后，正确率约为75%，模型的参数存储在二进制protobuf格式在cifar10_quick_iter_5000

然后，这个模型就可以用来运行在新数据上了。

其他

另外，更改cifar*solver.prototxt文件可以使用CPU训练，

# solver mode: CPU or GPU
solver_mode: CPU

可以看看CPU和GPU训练的差别。

主要资料来源：caffe官网教程

深度学习之----caffe相关推荐

  1. 常用深度学习框——Caffe/TensorFlow / Keras/ PyTorch/MXNet

    常用深度学习框--Caffe/TensorFlow / Keras/ PyTorch/MXNet 一．概述 近几年来,深度学习的研究和应用的热潮持续高涨,各种开源深度学习框架层出不穷,包括Tensor ...

  2. 深度学习框架Caffe源码解析

    作者:薛云峰(https://github.com/HolidayXue),主要从事视频图像算法的研究, 本文来源微信公众号:深度学习大讲堂.  原文:深度学习框架Caffe源码解析  欢迎技术投稿. ...

  3. 【深度学习】caffe 中的一些参数介绍

     [深度学习]caffe 中的一些参数介绍 标签: 深度学习caffe 2016-05-30 14:33 7122人阅读 评论(1) 收藏 举报 本文章已收录于: 分类: [机器学习&深度 ...

  4. 深度学习框架caffe及py-faster-rcnn详细配置安装过程

    深度学习框架caffe及py-faster-rcnn详细配置安装过程 配置环境: ubuntu14.04 CUDA7.5 1.准备工作 安装vim.python-pip.git sudo apt-ge ...

  5. 深度学习框架Caffe, MXNet, TensorFlow, Torch, CNTK性能测试报告

    香港浸会大学对于深度学习框架Caffe, MXNet, TensorFlow, Torch, CNTK性能测试报告 http://dlbench.comp.hkbu.edu.hk/

  6. 深度学习工具caffe详细安装指南

    转载自 深度学习工具caffe详细安装指南 前言: 在一台系统环境较好的linux机器上可以很容易的安装caffe,但是如果系统本身很旧,又没有GPU的话,安装就太麻烦了,所有都得从头做起,本文档旨在 ...

  7. HI3559A和AI深度学习框架caffe

    from:http://blog.sina.com.cn/s/blog_156e567660102ygdf.html 1.HI3559A支持深度学习框架caffe.其中的NNIE神经网络加速单元是主要 ...

  8. 【深度学习】caffe中那些layers

    0. 引子 自从半年前开始进入418实验室研究深度学习,可以说caffe这一深度学习开源框架,一直伴随着我.经过了大半年的学习,虽然还有许多东西尚待完善,但起码对于caffe已经有了一个比较感性的认识 ...

  9. 深度学习库 caffe使用 源码分析 依赖库分析 caffe glog gflags openBlas prototxt yolo_darknet 转 caffe

    深度学习库 caffe使用 源码分析 依赖库分析 caffe glog gflags openBlas 本文github链接 yolo_darknet 转 caffe caffe 安装 Caffe代码 ...

  10. Windows系统下首次安装深度学习框架Caffe失败

    Caffe,全称Convolutional Architecture for Fast Feature Embedding,是一个兼具表达性.速度和思维模块化的深度学习框架. 下载caffe,GitH ...

最新文章

  1. tf.keras.losses.Huber 损失函数 示例
  2. python爬虫不错的文章
  3. 观察者模式-Observer Pattern
  4. Netty工作笔记0030---NIO与零拷贝原理剖析
  5. Beetl 性能揭秘 1 ：如何输出一个整型变量
  6. Haproxy反向代理WebSocket的方法
  7. python for 格式化字符串 list.count
  8. 打怪升级的monteCarlo仿真方法
  9. spark 数据倾斜之两阶段聚合（局部聚合+全局聚合）
  10. Eclipse的工作空间与项目
  11. Linux黑客基础01篇
  12. codeforces 558D Guess Your Way Out! II 规律
  13. Failed to obtain JDBC Connection；
  14. html_09网页超链接
  15. 一文让你搞懂 C语言可变参数 VA_LIST原理详解
  16. linux execl()函数
  17. Bpy三维图像建模基础库——（01）库的安装
  18. javaweb学生签到考勤请假系统
  19. FPGA 开发项目参考
  20. 东北大学软件项目管理与过程改进复习提纲（2020）——第一章

热门文章

  1. html显示图片原理,html+js实现图片预加载,lightbox底层原理。
  2. android样式和主题
  3. 如何将一个string变为string数组
  4. 用JavaScript写出100以内与7有关的数
  5. python文本分类_手把手教你在Python中实现文本分类.pdf
  6. SOA推动电信服务走向融合应用
  7. c# 调用ArcEngine的GP工具
  8. [[概率论与数理统计-2]：随机函数、概率、概率函数、概率分布函数
  9. 团队编程--MP3播放器
  10. 提高效率必须改掉的7种习惯