ITKeyword,专注技术干货聚合推荐

注册 | 登录

深度学习(六)caffe入门学习

qq_26569761 分享于 2016-04-07

推荐:深度学习框架Caffe学习之依赖库

Caffe是UC Berkeley的Ph.D贾扬清写的一个用于深度学习的框架,编程语言C++,GPU计算则是使用cuda加速,CPU的计算主要是依赖于BLAS进行加速。 依赖库如下: 1. Cud

2020腾讯云7月秒杀活动,优惠非常大!(领取2860元代金券),
地址https://cloud.tencent.com/act/cps/redirect?redirect=1040

2020阿里云最低价产品入口,含代金券(新老用户有优惠),
地址https://www.aliyun.com/minisite/goods

caffe入门学习

原文地址http://blog.csdn.net/hjimce/article/details/48933813

作者:hjimce

本文主要讲解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   在CODE上查看代码片 派生到我的代码片
  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   在CODE上查看代码片 派生到我的代码片
  1. <span style="font-size:18px;">net: "examples/mnist/lenet_train_test.prototxt"  //定义网络结构文件,也就是我们上一步编写的文件  
  2.   
  3. test_iter: 100   
  4.   
  5. test_interval: 500 //每隔500次用测试数据,做一次验证  
  6.   
  7. base_lr: 0.01     //学习率  
  8. momentum: 0.9   //动量参数  
  9. weight_decay: 0.0005   //权重衰减系数  
  10.   
  11. lr_policy: "inv"   //梯度下降的相关优化策略  
  12. gamma: 0.0001  
  13. power: 0.75  
  14.   
  15. display: 100  
  16.   
  17. max_iter: 10000   //最大迭代次数  
  18.   
  19. snapshot: 5000    //每迭代5000次,保存一次结果  
  20. snapshot_prefix: "examples/mnist/lenet" //保存结果路径  
  21.   
  22. solver_mode: GPU   //训练硬件设备选择GPU还是CPU</span>  

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

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

[cpp]  view plain   copy   在CODE上查看代码片 派生到我的代码片
  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   在CODE上查看代码片 派生到我的代码片
  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.   
  5. EXAMPLE=.          # 生成模型训练数据文化夹  
  6. TOOLS=../../build/tools                              # caffe的工具库,不用变  
  7. DATA=.                  # python脚步处理后数据路径  
  8.   
  9. TRAIN_DATA_ROOT=train/  #待处理的训练数据图片路径  
  10. VAL_DATA_ROOT=val/      # 带处理的验证数据图片路径  
  11.   
  12.   
  13.   
  14. # Set RESIZE=true to resize the images to 256x256. Leave as false if images have  
  15. # already been resized using another tool.  
  16. RESIZE=true   #图片缩放  
  17. if $RESIZE; then  
  18.   RESIZE_HEIGHT=256  
  19.   RESIZE_WIDTH=256  
  20. else  
  21.   RESIZE_HEIGHT=0  
  22.   RESIZE_WIDTH=0  
  23. fi  
  24.   
  25. if [ ! -d "$TRAIN_DATA_ROOT" ]; then  
  26.   echo "Error: TRAIN_DATA_ROOT is not a path to a directory: $TRAIN_DATA_ROOT"  
  27.   echo "Set the TRAIN_DATA_ROOT variable in create_imagenet.sh to the path" \  
  28.        "where the ImageNet training data is stored."  
  29.   exit 1  
  30. fi  
  31.   
  32. if [ ! -d "$VAL_DATA_ROOT" ]; then  
  33.   echo "Error: VAL_DATA_ROOT is not a path to a directory: $VAL_DATA_ROOT"  
  34.   echo "Set the VAL_DATA_ROOT variable in create_imagenet.sh to the path" \  
  35.        "where the ImageNet validation data is stored."  
  36.   exit 1  
  37. fi  
  38.   
  39. echo "Creating train lmdb..."  
  40.   
  41. GLOG_logtostderr=1 $TOOLS/convert_imageset \  
  42.     --resize_height=$RESIZE_HEIGHT \  
  43.     --resize_width=$RESIZE_WIDTH \  
  44.     --shuffle \  
  45.     $TRAIN_DATA_ROOT \  
  46.     $DATA/train.txt \     #标签训练数据文件  
  47.     $EXAMPLE/train_lmdb  
  48.   
  49. echo "Creating val lmdb..."  
  50.   
  51. GLOG_logtostderr=1 $TOOLS/convert_imageset \  
  52.     --resize_height=$RESIZE_HEIGHT \  
  53.     --resize_width=$RESIZE_WIDTH \  
  54.     --shuffle \  
  55.     $VAL_DATA_ROOT \  
  56.     $DATA/val.txt \    #验证集标签数据  
  57.     $EXAMPLE/val_lmdb  
  58.   
  59. echo "Done."</span>  
同时我们需要制作如下四个文件:

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

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

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

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

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

**********************作者:hjimce   时间:2015.10.6  联系QQ:1393852684   原创文章,转载请保留原文地址、作者等信息***************

推荐:贾扬清分享_深度学习框架caffe

本文转自: http://www.datakit.cn/blog/2015/06/12/online_meet_up_with_yangqing_jia.html Caffe是一个清晰而高效的深度学习框架,其作者是博士毕业于UC Berke

caffe入门学习 原文地址:http://blog.csdn.net/hjimce/article/details/48933813 作者:hjimce 本文主要讲解caffe的整个使用流程,适用于初级入门caffe,通过学习本篇博文,理清项目训练、测试

相关阅读排行


相关内容推荐

最新文章

×

×

请激活账号

为了能正常使用评论、编辑功能及以后陆续为用户提供的其他产品,请激活账号。

您的注册邮箱: 修改

重新发送激活邮件 进入我的邮箱

如果您没有收到激活邮件,请注意检查垃圾箱。