caffe_caffeine - CSDN
caffe 订阅
Caffe,全称Convolutional Architecture for Fast Feature Embedding,是一个兼具表达性、速度和思维模块化的深度学习框架。由伯克利人工智能研究小组和伯克利视觉和学习中心开发。虽然其内核是用C++编写的,但Caffe有Python和Matlab 相关接口。Caffe支持多种类型的深度学习架构,面向图像分类和图像分割,还支持CNN、RCNN、LSTM和全连接神经网络设计。Caffe支持基于GPU和CPU的加速计算内核库,如NVIDIA cuDNN和Intel MKL。 展开全文
Caffe,全称Convolutional Architecture for Fast Feature Embedding,是一个兼具表达性、速度和思维模块化的深度学习框架。由伯克利人工智能研究小组和伯克利视觉和学习中心开发。虽然其内核是用C++编写的,但Caffe有Python和Matlab 相关接口。Caffe支持多种类型的深度学习架构,面向图像分类和图像分割,还支持CNN、RCNN、LSTM和全连接神经网络设计。Caffe支持基于GPU和CPU的加速计算内核库,如NVIDIA cuDNN和Intel MKL。
信息
外文名
Convolutional Architecture for Fast Feature Embedding
领    域
人工智能
特    点
清晰,可读性高,学习快速
简    称
Caffe
中文名
快速特征嵌入的卷积结构
接    口
Python和Matlab 相关接口
实    质
一种深度学习框架
Caffe简介
Caffe是一个深度学习框架,最初开发于加利福尼亚大学伯克利分校。Caffe在BSD许可下开源,使用C++编写,带有Python接口。是贾扬清在加州大学伯克利分校攻读博士期间创建了Caffe项目。项目托管于GitHub,拥有众多贡献者。Caffe应用于学术研究项目、初创原型甚至视觉、语音和多媒体领域的大规模工业应用。雅虎还将Caffe与Apache Spark集成在一起,创建了一个分布式深度学习框架CaffeOnSpark。2017年4月,Facebook发布Caffe2,加入了递归神经网络等新功能。2018年3月底,Caffe2并入PyTorch。
收起全文
精华内容
参与话题
  • Caffe简介

    千次阅读 多人点赞 2018-08-19 19:01:58
    什么是caffe? caffe的特点 caffe架构 caffe的硬件环境 caffe的依赖库 caffe的接口 1、什么是caffe?  caffe是一个清晰而高效的深度学习框架,是纯粹的C++/CUDA架构,支持命令行、python和matlab接口;可以在...
    • 什么是caffe?
    • caffe的特点
    • caffe架构
    • caffe的硬件环境
    • caffe的依赖库
    • caffe的接口

    1、什么是caffe?

            caffe是一个清晰而高效的深度学习框架,是纯粹的C++/CUDA架构,支持命令行、python和matlab接口;可以在CPU和GPU之间无缝切换,其作者是贾扬清,目前caffe2已经发布。

           caffe的全称是Convolutional Architecture for Fast Feature Embedding(译为:快速特征嵌入的卷积体系结构),核心语言是C++。caffe的基本工作流程是设计建立在神经网络的一个简单假设,所有的计算都是层的形式表示的,网络层所做的事情就是输入数据,然后输出计算结果。比如卷积就是输入一幅图像,然后和这一层的参数(filter)做卷积,最终输出卷积结果。每层需要两种函数计算,一种是forward,从输入计算到输出;另一种是backward,从上层给的gradient来计算相对于输入层的gradient。这两个函数实现之后,我们就可以把许多层连接成一个网络,这个网络输入数据(图像,语音或其他原始数据),然后计算需要的输出(比如识别的标签)。在训练的时候,可以根据已有的标签计算loss和gradient,然后用gradient来更新网络中的参数。

    2、caffe的特点

    *模块化

    caffe设计之初就做到了尽可能的模块化,允许对数据格式、网络层和损失函数进行扩展。

    *表示和实现分离

    caffe的模型定义是用Protocol Buffer(协议缓冲区)语言写进配置文件的,以任意有向无环图的形式,caffe支持网络架构。caffe会根据网络需要正确占用内存,通过一个函数调用实现CPU和GPU之间的切换。

    *测试覆盖

    每一个单一的模块都对应一个测试

    *python和matlab接口

    同时提供两种接口

    *预训练参考模型

    针对视觉项目,caffe提供了一些参考模型,这些模型仅应用在学术和非商业领域

    3、caffe架构

    *数据存储

    caffe通过“Blobs”即以四维数组的方式存储和传递数据。Blobs提供了一个统一的内存接口,用于批量图像(或其他数据)的操作和参数更新,Models是以Google Protocol Buffers的方式存储在磁盘上的。大型数据存储在LevelDB数据库中。

    *层             http://caffe.berkeleyvision.org/tutorial/layers.html

    一个caffe层(Layer)是一个神经网络层的本质,它采用一个或多个Blobs作为输入,并产生一个或者多个Blobs作为输出。层有两个关键的职责,前向传播,需要输入并产生输出;反向传播,取梯度作为输出通过参数和输入计算梯度。

    *网络和运行方式

    caffe保留所有的有向无环图,保证前向传播和反向传播正确进行。caffe模型是终端到终端的机器学习系统。一个典型的网络开始于数据层,结束于loss层。在CPU和GPU上,层会产生相同的结果。

    4、caffe的硬件环境

    *CPU的选择

    caffe支持CPU和GPU训练。如果采用CPU训练,CPU支持的线程越多越好,因为caffe本身显性的使用两个线程。一个线程用来读取数据,另一个线程用来执行前向传播和反向传播;如果采用GPU训练,则大量运算由GPU完成,CPU只运行caffe的两个线程,因此即使选用更多的CPU也无法大幅度加速训练,训练时效取决于GPU。

    *GPU的选择

    因为caffe只支持cuda(Computer Unified Device Architecture)库,而cuda库是NVIDIA显卡专用的,所以选择caffe作为深度学习框架一定要选用NVIDIA显卡。如果电脑使用两个不同显卡的版本,则训练速度是两张低速卡一起训练的速度。

    *内存的选择

    选择支持双通道的内存以及高频率的内存有利于训练,GPU训练下,内存频率不是重要影响因素。

    *硬盘选择

    caffe采用单独线程异步方式从硬盘中顺序读取数据,需要根据实际情况看是否考虑固态硬盘(SSD),硬盘容量和数据集密切相关。

    5、caffe的依赖库

    Boost库:一个可移植、提供源代码的C++库,作为标准库的后备,是C++标准化进程的开发引擎之一。caffe采用C++作为主开发语言,其中大量的代码依赖于Boost库。

    GFlags库:Google的一个开源的处理命令行参数的库,使用C++开发。caffe库采用GFlags库开发caffe的命令行。

    GLog库:一个应用程序的日志库,提供基于C++风格的流日志API,caffe运行时的日志依赖于GLog库。

    LevelDB库:Google实现的一个非常高效的Key-Value数据库。单进程服务,性能非常高。是caffe支持的两种数据库之一。

    LMDB库:是一个超级小、超级快的Key-Value数据存储服务,使用内存映射文件,因此在读取数据的性能跟内存数据库一样,其大小受限于虚拟地址空间的大小。是caffe支持的两种数据库之一。

    ProtoBuf库:Google Protocol Buffer,一种轻便高效的结构化数据存储格式,可用于结构化数据的串行化(序列化),适合做数据存储或RPC数据交换格式。可用于通信协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。caffe使用起来非常方便很大程度上是因为采用.proto文件作为用户的输入接口。用户通过编写.proto文件定义网络模型和Solver。按序排列时二进制字符串尺寸最小,高效序列化,易读的文本格式与二进制版本兼容,可用多种语言实现高效的接口,尤其是 C++
    和 Python。这些优势造就了 Caffe 模型的灵活性与扩展性。

    HDF5库:Hierarchical Data File,一种高效存储和分发科学数据的新型数据格式,可存储不同类型的图像和数码数据的文件格式,可在不同的机器上进行传输,同时还有统一处理这种文件格式的函数库。caffe支持HDF5格式。

    snappy库:一个C++库,用来压缩和解压缩的开发包。旨在提供高速压缩速度和合理的压缩率。caffe在数据处理时依赖于snappy库。

    6、caffe的接口

    caffe python接口------Pycaffe

    (1)caffe.Net是主要接口,负责导入数据、校验数据、计算模型;

    (2)caffe.Classifier用于图像分类;

    (3)caffe.Detector用于图像检测;

    (4)caffe.SGDSolver是搂在外的solver的接口;

    (5)caffe.io处理输入输出,数据预处理;

    (6)caffe.draw可视化net的结构;

    (7)Caffe blobs以numpy ndarrays的形式表示,方便而且高效。

    caffe matlab接口------matcaffe

    caffe命令行接口

               caffe train:用于模型学习

               caffe test:用于测试运行模型的得分,并且用百分比表示网络输出的最终结果

               caffe time:用来检测系统性能和测量模型相对执行时间,此命令通过逐层计时与同步,执行模型检测

     

    展开全文
  • 本课程在windows下搭建CPU版本Caffe环境,便于初学者学习和调试。通过实例介绍了Caffe的的训练和预测方法以及对应的python接口,便于大家掌握Caffe常用的训练和预测方法;结合以图形化的方式介绍网络结构、训练的...
  • 深度学习(五)caffe环境搭建

    万次阅读 热门讨论 2016-05-20 10:16:11
    对于caffe的系统一般使用linux系统,当然也有windows版本的caffe,不过如果你一开始使用了windows下面的caffe,后面学习的过程中,会经常遇到各种错误,网上下载的一些源码、模型也往往不能快速的跑起来,因为貌似...

    ubuntu 系统下的Caffe环境搭建

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

    作者:hjimce

    对于caffe的系统一般使用linux系统,当然也有windows版本的caffe,不过如果你一开始使用了windows下面的caffe,后面学习的过程中,会经常遇到各种错误,网上下载的一些源码、模型也往往不能快速的跑起来,因为貌似caffe的官方只提供了linux版本,而且caffe在不断的快速迭代更新中,如果不使用原版的话,后面编译出现什么问题,自己怎么错的,自己都不知道。本篇博文主要讲解快速搭建caffe环境:

    电脑系统:ubuntu 14.04

    显卡:GTX 850

    在ubuntu下要完整的搭建caffe,个人感觉最难的一步就是cuda的安装了,特别是对于双显卡的电脑来说,很容易黑屏、无法登陆图形界面,这个我安装了n久,都没装成功,因为我的电脑笔记本双显卡,每次装完cuda就黑屏,网上的教程一大堆,但都中看不中用,导致我重装了二三十次的系统,最后才成功。这里为了讲caffe的安装,我们先不使用GPU,进行安装测试,因为没有GPU我们依旧可以跑caffe,只是速度比较慢而已。

    1、安装caffe所需要的依赖库

    命令:

    sudo apt-get install libatlas-base-dev
    sudo apt-get install libprotobuf-dev libleveldb-dev libsnappy-dev libopencv-dev libboost-all-dev libhdf5-serial-dev
    sudo apt-get install libgflags-dev libgoogle-glog-dev liblmdb-dev protobuf-compiler
    这些库要安装挺久的,请耐心等待。

    2、下载caffe。

    到github上下载caffe:https://github.com/BVLC/caffe。下载完成后,解压caffe源码包。解压后,我们打开文件,可以看到caffe的源码包如下:


    3、配置Make.config 文件。caffe文件解压后,文件夹下面有一个Makefile.config.example文件,我们需要对这个文件进行重命名为:Make.config  。也就是去掉后缀example。然后我们打开这个文件,可以看到如下内容:


    然后我们把:#CPU_ONLY:=1,那一行的注释符号去掉:CPU_ONLY:=1。这是因为我们没有安装CUDA,还不能使用gpu,所以我们把配置改为只使用cpu。

    4、编译caffe。

    方案一:

    (1)在完成Make.config配置后,我们输入命令:

    make all

    进行caffe源码编译.这一步有可能遇到如下错误:

    caffe/proto/caffe.pb.h: No such file or directory
    如果出现这个错误,那么输入命令:

    protoc src/caffe/proto/caffe.proto --cpp_out=.
    mkdir include/caffe/proto
    mv src/caffe/proto/caffe.pb.h include/caffe/proto

    然后在进行make all 就可以了

    (2)编译完成后,在安装python接口,输入命令:

    make pycaffe
    这个如果不使用python接口,调用caffe模型的话也可以不用安装,不过建议还是搞一下,就一句话的事。完事后,我们会发现caffe源码目录下,多了一个build文件,这个文件下面有个tools,打开这个文件夹:


    这个文件夹下面的工具可是个好东西啊,以后我们会经常用到这些可执行文件,最常用的就是可执行文件:caffe,我们只要调用这个工具,就可以进行训练。

    (3)接着编译test文件夹下面的源码。命令如下:

    make test
    make runtest

    采用这种方案一般没问题,不过我在使用c++调用的时候,会使用到链接库:libcaffe.so.1.0.0-rc3,这种方法编译后没有生成这个文件;经过google查找,发现采用cmake编译,才会生成libcaffe.so文件

    方案二:直接采用cmake:

    mkdir build
    cd build
    cmake ..
    make all -j8

    5、测试阶段

    安装完了,自然要测试一下能不能用咯。首先cd到caffe目录,然后输入命令:

    sh data/mnist/get_mnist.sh
    sh examples/mnist/create_mnist.sh
    vim examples/mnist/lenet_solver.prototxt

    把lenet_solver.prototxt里面的solver_mode 改为 CPU。因为我们还没装GPU,暂时只使用CPU就好了。

    然后我们运行脚本:

    ./examples/mnist/train_lenet.sh
    这个时候,如果成功的话,就会开始跑起来:


    说明:如果在使用caffe、或者编译安装caffe过程中,出现如下错误:

    CXX/LD -o .build_release/tools/convert_imageset.bin
    .build_release/lib/libcaffe.so: undefined reference tocv::imread(cv::String const&, int)'.build_release/lib/libcaffe.so: undefined reference tocv::imencode(cv::String const&, cv::_InputArray const&, std::vector >&, std::vector > const&)'
    
    那么请修改上面的Makefile文件(不是Makefile.config):

    LIBRARIES += glog gflags protobuf leveldb snappy \
    lmdb boost_system hdf5_hl hdf5 m \
    opencv_core opencv_highgui opencv_imgproc opencv_imgcodecs
    也就是在libraries后面,加上opencv的相关库文件。

    接着就开始caffe搞起吧,推荐个caffe模型网站:https://github.com/BVLC/caffe/wiki/Model-Zoo。本来个人不是很喜欢caffe的,就是因为这个网站吸引了我,这个网站可以搞到好多caffe模型、源码,非常适合于我们学习。

    二、在Eclipse中使用编译调试caffe

    1、首先就是安装Eclipse,然后安装c++开发插件,这个可以百度搜一下,eclipse下面怎么进行c++开发。

    2.导入caffe makefile工程到eclipse (由于是英文版,下面描述也用英文,省的翻译,方便大家调试)
    (1)File→New→Project→C/C++ →Makefile Project with Existing Code.
    (2)Create a new Makefile Project from existing code
    Projectname: caffe-master
    Existing code location:/home/user/caffe-workspace/caffe-master
    Language: choose C and C++
    Toolchain:choose Linux GCC
    (3)Then click on caffe-master in Project Explorer (set Window→Open  Perspective → C/C++).

    (4)Now go File → Properties → Run/Debug settings.Click  New.., and choose C/C++ application
    (5)Fill launch configurationproperties
    ·        Arguments:
    fill   train –solver=examples/mnist/lenet_solver.prototxt
    and change working directory from default to /home/user/caffe-workspace/caffe-master(change to your own directory)

    (6)Now you can use debug caffe code: Run-> Debug

    三、C++函数调用相关路径,makefile

    CC=g++
    
    CXXFLAGS = -O2 -Wall -D__STDC_CONSTANT_MACROS 
    
    INCLUDE = -I/usr/local/cuda/include -I. -I/usr/local/cuda/include -I/home/hjimce/caffe/include/ -I/home/hjimce/caffe/src/
    
    LIBRARY = -L/usr/local/x86_64-linux-gnu/ -lprotobuf \
    					-L/usr/lib/x86_64-linux-gnu/ -lglog \
    					-L/usr/local/cuda/lib64/ -lcudart -lcublas -lcurand \
    					-L/usr/local/lib/ -lm -lpthread -lavutil -lavformat -lavcodec -lswscale -lopencv_core -lopencv_imgproc -lopencv_highgui \
    					-L/usr/lib/python2.7/config-x86_64-linux-gnu/ -lpython2.7 \
    					-L/sur/lib32/ -lrt \
    					-L../../caffe/build/lib/ -lcaffe
    
    all:
    	$(CC) $(INCLUDE) $(OBJS) testcpp.cpp -o exercise $(LIBRARY)


    windows下的caffe环境搭建


    最近在ubuntu搞了一个月的caffe,总感觉很不爽,因为ubuntn下面的c++集成开发工具,eclipse用起来没有vs爽,因为对caffe的函数名不是很熟悉,所以需要借助vs的c++助手。然后前一个月大部分也是调用pycaffe,但是最近感觉需要对caffe的c++函数比较熟悉,才能把自己的能力进一步提高,于是就开始搞起了windows 下的caffe,借助vs的强大功能,快速学习caffe。一开始采用vs2012,最后各种错误,最后改成vs2013很容易就编译成功了。

    最后推荐一个windows下caffe安装网站:http://thirdeyesqueegee.com/deepdream/2015/07/13/running-deep-dream-on-windows-with-full-cuda-acceleration/    这个包含了python的集成开发环境anaconda,caffe的全套功能。

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

    附录:在使用pycaffe遇到如下错误

    raise ValueError('Mean shape incompatible with input shape.')
    ValueError: Mean shape incompatible with input shape.
    那么把 ./python/caffe/io.py文件夹下面的代码:

    if ms != self.inputs[in_][1:]:  
    raise ValueError('Mean shape incompatible with input shape.') 
    改成:

    if ms != self.inputs[in_][1:]:  
    print(self.inputs[in_])  
    in_shape = self.inputs[in_][1:]  
    m_min, m_max = mean.min(), mean.max()  
    normal_mean = (mean - m_min) / (m_max - m_min)  
    mean = resize_image(normal_mean.transpose((1,2,0)),  
        in_shape[1:]).transpose((2,0,1)) * \  
       (m_max - m_min) + m_min  
    #raise ValueError('Mean shape incompatible with input shape.')




    
    
    展开全文
  • Caffe的简介、依赖、框架

    万次阅读 2018-08-14 16:48:35
    1. Caffe Caffe是一个以表达式、速度和模块化为核心的深度学习框架,由BLVC(Berkeley Vision and Learning Center)和社区贡献者开发。项目创建者是贾扬清。 2. Feature Expressive architecture 具有表现力的...

    1. 官网介绍

    1. Caffe

    Caffe是一个以表达式、速度和模块化为核心的深度学习框架,由BLVC(Berkeley Vision and Learning Center)和社区贡献者开发。项目创建者是贾扬清。

    2. Feature

    • Expressive architecture

    具有表现力的结构鼓励应用和创新。模型及优化是通过配置定义的,而不是使用硬编码的方式。可以在GPU和CPU之间无缝切换,可以用GPU训练,然后部署到集群或移动设备上。

    • Extensible code

    具有扩展性的代码促进了Caffe的积极发展。Caffe第一年fork超过一千次,有许多有意义的贡献和反馈。由于众多的贡献者,Caffe框架跟踪并实现了当前最新的代码和模型。

    • Speed

    快速性使Caffe适合研究实验和工业开发。Caffe在单个的NVIDIA K40 GPU上每天能处理6千万张图片。识别时速度为1ms/张,训练时速度为4ms/张,BLVC相信Caffe具有最快的卷积神经网络实现。

    • Community

    Caffe已经支持学术研究项目,启动原型,甚至支持大规模视觉、语音和多媒体的工业应用。

    3. Document

    一个介绍Caffe的PPT

    实践指导和框架参考

    安装,已经在Ubuntu,Red Hat,OS X上测试过了。

    模型规范及已经训练的模型

    API文档,通过代码中的注释生成的。

    4. Demo

    在ImageNet上训练和测试CaffeNet

    Yann LeCun的手写字符识别,训练和测试。

    CIFAR-10数据集上Caffe的训练与测试。

    ImageNet上训练的CaffeNet在Flickr Style数据集上的调优。

    用Caffe工具提取CaffeNet和AlexNet特征。

    用底层API进行图像的简单分类

    运行在Flask web服务器上的图像分类Demo

    在MNIST数据集上训练和测试siamese网络。

    5. NoteBook Demo

    通过预先训练的模型进行图像实时识别,对神经网络的每层特征和参数进行可视化,可以了解可视化的神经网络接口。

    使用Python定义、训练、测试经典的LeNet。

    在新数据集上对ImageNet上训练的CaffeNet进行调优。

    使用Caffe作为一般的SGD优化器在非图像的HDF5数据上训练逻辑回归。

    使用Python数据层在PASCAL VOC上进行多标签分类。

    怎样修改神经网络,手动改变模型参数来进行定制化使用。

    在Python中使用预先训练的模型作为检测器来进行目标检测。

    提取特征、绘制Siamese网络嵌入。

    6. Philosophy

    • Expression

    模型和优化都是通过纯文本模式定义的而不是通过代码的方式。

    • Speed

    对于研究和工业而言,在最新的模型和大规模数据上具有同样的速度是关键。

    • Modularity

    新任务及设置要求灵活性和可扩展性

    • Openness

    科学和应用进展需要通用的代码、参考模型和再现性。

    • Community

    学术研究、启动原型和工业应用通过在BSD-2项目中的联合讨论和开发实现所有共享。

    7. Tour

    • Net,Lays and Blobs

    Caffe模型的结构组成

    • Forward/Backward

    分层结构模型的基本计算

    • Loss

    通过损失函数定义要学习的任务

    • Solver

    求解程序协调模型优化

    • Layer Catalogue

    这一层是建模和计算的基本单元,Caffe的目录包含最新模型的层

    • Interfaces

    命令行,Python,MATLAB

    • Data

    怎样将模型输入变为Caffe能处理的数据

    • Caffeinated Convolution

    Caffe怎样计算卷积

    2. 普通介绍

    1. Caffe介绍

    在深度学习领域,Caffe框架是人们无法绕过的一座山。Caffe是一个用C++编写的深度学习框架,作者是UC Berkeley博士贾扬清,Caffe。由于Caffe清晰、高效,因此在深度学习中被广泛使用,用户逐渐地也形成了一个开放的社区,一些重要的研究成果(主要是各种模型)被引入到了Caffe中,例如著名的AlexNet。 
    Caffe无论在结构、性能上,还是在代码质量上,都是一款非常出色的开源框架。它将深度学习的每一个细节都原原本本地展现出来,大大降低了人们学习、研究和开发的难度。

    Caffe是纯粹的C++/CUDA架构,支持命令行、Python和MATLAB接口。Caffe的清晰性表现在网络结构与参数都独立于代码,用户只要以普通文本(但需遵循一定的简单格式)就可以定义好自己的神经网络,并按自己的需要进行调整。而高效性则体现在对CUDA的支持,GPU 运算能极大地提高图像处理的速度,同时Caffe提供了在CPU模式和GPU模式之间的无缝切换。

    2. Caffe特点

    • 上手快:模型与相应优化都是以文本形式而非代码形式给出。Caffe给出了模型的定义、最优化设置以及预训练的权重,方便立即上手。

    • 速度快:能够运行最棒的模型与海量的数据。Caffe与cuDNN结合使用,测试AlexNet模型,在K40上处理每张图片只需要1.17ms.

    • 模块化:方便扩展到新的任务和设置上。可以使用Caffe提供的各层类型来定义自己的模型。

    • 开放性:公开的代码和参考模型用于再现。

    • 社区好:可以通过开源社区和Github参与讨论和开发。

    参考资料:

    1. Caffe官网

    2. http://www.zmonster.me/2015/07/21/caffe-base-usage.html

    3. http://www.cnblogs.com/zdz8207/p/DeepLearning-Caffe.html



    Caffe是一个开源的深度学习框架,其实现依赖于许多其它的库,下面将分别介绍Caffe所需的依赖库。

    1. OpenCV

    OpenCV的全称是Open Source Computer Vision Library,是一个跨平台的计算机视觉库。OpenCV是由英特尔公司发起并参与开发,以BSD许可证授权发行,可以在商业和研究领域中免费使用。OpenCV可用于开发实时的图像处理、计算机视觉以及模式识别程序。

    2. Boost

    Boost C++库是一个经过千锤百炼、可移植、提供源代码的C++库,作为标准库的后备,是C++标准化进程的发动机之一。 Boost库由C++标准委员会库工作组成员发起,在C++社区中影响甚大。 Boost库为我们带来了最新、最酷、最实用的技术,是不折不扣的“准”标准库。Boost作为一个准标准库,相当于STL的延续和扩充,它的设计理念和STL比较接近,都是利用泛型让复用达到最大化。不过相比于STL,Boost更加实用。STL集中在算法部分,而Boost包含了不少工具类,可以完成比较具体的工作。Boost主要包含以下几个大类:字符串及文本处理、容器、迭代器(Iterator)、算法、函数对象和高阶编程、泛型编程、模板元编程、预处理元编程、并发编程、数学相关、纠错和测试、数据结构、输入/输出、跨语言支持、内存相关、语法分析、杂项。

    3. CUDA

    CUDA(Compute Unified Device Architecture,统一计算架构)是由NVIDIA所推出的一种集成技术,是NVIDIA推出的运算平台。CUDA是由NVIDIA推出的通用并行计算架构,该架构使GPU能够解决复杂的计算问题。 它包含了CUDA指令集架构(ISA)以及GPU内部的并行计算引擎。从CUDA体系结构的组成来说,包含了三个部分:开发库、运行期环境和驱动。开发库是基于CUDA技术所提供的应用开发库。运行期环境提供了应用开发接口和运行期组件,包括基本数据类型的定义和各类计算、类型转换、内存管理、设备访问和执行调度等函数。驱动部分基本上可以理解为是CUDA-enable的GPU的设备抽象层,提供硬件设备的抽象访问接口。CUDA提供运行期环境也是通过这一层来实现各种功能的。

    4. BLAS

    BLAS(Basic Linear Algebra Subprograms,基础线性代数程序集)是一个应用程序接口(API)标准,用以规范发布基础线性代数操作的数值库(如矢量或矩阵乘法)。在高性能计算领域,BLAS被广泛使用。Caffe推荐的BLAS(Basic Linear Algebra Subprograms)有三个选择ATLAS,Intel MKL,OpenBLAS。其中ATLAS是caffe是默认选择的,其开源免费,如果没有安装CUDA的不太推荐使用,因为对CPU多线程的支持不太好;Intel MKL是商业库要收费,学生可申请试用,贾扬清安装的是MKL,估计效果应该是最好的;OpenBLAS开源免费,支持CPU多线程。

    5. LevelDB

    LevelDB是一个由Google公司所研发的键/值对(Key/Value Pair)嵌入式数据库管理系统编程库,以开源的BSD许可证发布,是Caffe支持的数据格式之一。LevelDb有如下一些特点:

    • 首先,LevelDb是一个持久化存储的KV系统,和Redis这种内存型的KV系统不同,LevelDb不会像Redis一样狂吃内存,而是将大部分数据存储到磁盘上。

    • 其次,LevleDb在存储数据时,是根据记录的key值有序存储的,就是说相邻的key值在存储文件中是依次顺序存储的,而应用可以自定义key大小比较函数,LevleDb会按照用户定义的比较函数依序存储这些记录。

    • 再次,像大多数KV系统一样,LevelDb的操作接口很简单,基本操作包括写记录,读记录以及删除记录。也支持针对多条操作的原子批量操作。

    • 另外,LevelDb支持数据快照(snapshot)功能,使得读取操作不受写操作影响,可以在读操作过程中始终看到一致的数据。

    6. LMDB

    LMDB是一种小型的键值对数据库,具有一些非常优异的特性:

    • 有序的映射接口(键一直是按字典排序的)

    • 读写事务:读不会锁住写,写也不会锁住读

    • 读取数据代价很低

    • 内存映射,允许零拷贝查找和迭代

    • 维护不需要外部进程或后台线程

    虽然LMDB的内存消耗是LevelDB的1.1倍,但是LMDB的速度比LevelDB快10%至15%,更重要的是LMDB允许多种训练模型同时读取同一组数据集。因此LMDB取代了LevelDB成为Caffe默认的数据集生成格式。

    7. GLog

    Google的Glog是一个应用程序的日志库。它提供基于C++风格的流的日志API,以及各种辅助的宏。打印日志只需以流的形式传给 LOG(level) 。

    8. GFlags

    GFlags是Google的一个开源的处理命令行参数的库,使用C++开发,具备Python接口,可以替代getopt。GFlags使用起来比getopt方便,但是不支持参数的简写。

    9. Protobuff

    Google Protocol Buffer(简称Protobuf) 是Google公司内部的混合语言数据标准,它提供了一种灵活、高效、自动序列化结构数据的机制,但是比XML更小、更快、更简单。仅需要自定义一次你所需的数据格式,然后用户就可以使用Protobuf编译器自动生成各种语言的源码,方便的读写用户自定义的格式化的数据。与语言无关,与平台无关,还可以在不破坏原数据格式的基础上,依据老的数据格式,更新现有的数据格式。它们用于RPC 系统和持续数据存储系统。Protobuf是一种轻便高效的结构化数据存储格式,可以用于结构化数据串行化,或者说序列化。它很适合做数据存储或RPC数据交换格式。可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。目前提供了C++、Java、Python三种语言的API。

    10. HDF5

    HDF(英语:Hierarchical Data Format)指一种为存储和处理大容量科学数据设计的文件格式及相应库文件。HDF最早由NCSA开发,目前在非盈利组织HDF小组维护下继续发展。当前流行的版本是HDF5。 
    HDF5文件包含两种基本数据对象:

    • 群组(group):类似文件夹,可以包含多个数据集或下级群组。

    • 数据集(dataset):数据内容,可以是多维数组,也可以是更复杂的数据类型。

    群组和数据集都支持元数据,用户可以自定义其属性,提供附加信息。HDF现在被众多商业与非商业平台支持,包括Java,MATLAB/Scilab,Octave,IDL,Python和R。

    11. Snappy

    Snappy(以前称Zippy)是Google基于LZ77的思路用C++语言编写的快速数据压缩与解压程序库,并在2011年开源。它的目标并非最大压缩率或与其他压缩程序库的兼容性,而是非常高的速度和合理的压缩率。LevelDB需要Snappy的支持。

     



    Caffe的设计

    根据贾扬清的分享整理

    Caffe遵循了神经网络的一个假设:所有的计算都是以layer形式表示的,layer的作用就是根据输入数据,输出一些计算以后的结果。以卷积为例,就是输入一幅图像,然后与这一层的参数(filter)进行卷积运算,然后输出卷积的结果。每一个layer需要进行两种运算:1.forward,从输入计算输出;2.backward根据上面的梯度(gradient)来计算相对于输入的梯度。在每个layer都实现了这两个函数以后,我们可以将很多层连接成一个网络,这个网络做的事情就是输入我们的数据(图像或者语音或者whatever),然后来计算我们需要的输出(比如说识别的label)。在训练时,我们可以根据已有的label来计算loss和gradient,然后用gradient来update网络的参数。这个就是Caffe的一个基本流程!

    Caffe主要结构

    Caffe代码本身非常模块化,主要由4部分组成Blob,Layer,Net和Solver。

    • Blob

    Blob主要用来表示网络中的数据,包括训练数据,网络各层自身的参数,网络之间传递的数据都是通过Blob来实现的,同时Blob数据也支持在CPU与GPU上存储,能够在两者之间做同步。

    • Layer

    Layer是对神经网络中各种层的一个抽象,包括卷积层和下采样层,还有全连接层和各种激活函数层等等。同时每种Layer都实现了前向传播和反向传播,并通过Blob来传递数据。

    • Net

    Net是对整个神经网络的表示,由各种Layer前后连接组合而成,也是我们要构建的网络模型。

    • Solver

    Solver定义了针对Net网络模型的求解方法,记录神经网络的训练过程,保存神经网络模型参数,中断并恢复网络的训练过程。自定义Solver能够实现不同的神经网络求解方式。

    Caffe整体架构

    Caffe的架构与其它的深度学习框架稍微不同,它没有根据算法实现过程的方式来进行编码,而是以系统级的抽象作为整体架构,逐层的封装实现细节,使得上层的架构变得很清晰。Caffe的整体架构如下:

    1. SyncedMem

    这个类的主要功能是封装CPU和GPU的数据交互操作。一般来说,数据的流动形式都是:硬盘->CPU内存->GPU内存->CPU内存->(硬盘),所以在写代码的过程中经常会写CPU/GPU之间数据传输的代码,同时还要维护CPU和GPU两个处理端的内存指针。这些事情处理起来不会很难,但是会很繁琐。因此SyncedMem的出现就是把CPU/GPU的数据传输操作封装起来,只需要调用简单的接口就可以获得两个处理端同步后的数据。

    2. Blob

    Blob是用于存储数据的对象,在Caffe中各种数据(图像输入、模型参数)都是以Blob的形式在网络中传输的,Blob提供统一的存储操作接口,可用来保存训练数据、模型参数等,同时Blob还能在CPU和GPU之间进行同步以支持CPU/GPU的混合运算。 
    这个类做了两个封装:一个是操作数据的封装,使用Blob可以操纵高维的数据,快速访问其中的数据,变换数据的维度等;另一个是对原始数据和更新量的封装,每一个Blob中都有data和diff两个数据指针,data用于存储原始数据,diff用于存储反向传播(Backpropagation)的梯度更新值。Blob使用了SyncedMem,这样便于访问不同的处理端。Blob基本实现了整个Caffe数据结构部分的封装,在Net类中可以看到所有的前后向数据和参数都用Blob来表示就足够了。数据的抽象到这个就可以了,接下来作层级的抽象。神经网络的前后向计算可以做到层与层之间完全独立,只要每个层按照一定的接口规则实现,就可以确保整个网络的正确性。

    3. Layer

    Layer是网络Net的基本单元,也是Caffe中能在外部进行调整的最小网络结构单元,每个Layer都有输入Blob和输出Blob。Layer(层)是Caffe中最庞大最繁杂的模块,它是神经网络的基本计算单元。由于Caffe强调模块化设计,因此只允许每个layer完成一类特定的计算,例如convolution操作、pooling、非线性变换、内积运算,以及数据加载、归一化和损失计算等。Caffe中layer的种类有很多,具体的种类及功能请看官方文档。在创建一个Caffe模型的时候,也是以Layer为基础进行的。Layer是一个父类,它的下面还有各种实现特定功能的子类,例如data_layer,conv_layer,loss_layer等。Layer是通过LayFactory来创建的。

    4. Net

    Net是一个完整的深度网络,包含输入层、隐藏层、输出层,在Caffe中一般是一个卷积神经网络(Convolution Neural Networ,CNN)。通过定义不同类型的Layer,并用Blob将不同的Layer连接起来,就能产生一个Net。Net将数据Blob和层Layer组合起来做进一步的封装,对外提供了初始化和前后传播的接口,使得整体看上去和一个层的功能类似,但内部的组合可以是多种多样的。值得一提的是,每一层的输入输出数据统一保存在Net中,同时每个层内的参数指针也保存在Net中,不同的层可以通过WeightShare共享相同的参数,因此可以通过配置来实现多个神经网络层之间共享参数的功能。一个Net由多个Layer组成。一个典型的网络从data layer(从磁盘中载入数据)出发到loss layer结束。

    5. Solver

    有了Net就可以进行神经网络的前后向传播计算了,但是还缺少神经网络的训练和预测功能,Solver类进一步封装了训练和预测相关的一些功能。它还提供了两个接口:一个是更新参数的接口,继承Solver可以实现不同的参数更新方法,如Momentum,Nesterov,Adagrad等,因此可以使用不同的优化算法。另一个接口是训练过程中每一轮特定状态下的可注入的一些回调函数,在代码中这个回调点的直接使用者就是多GPU训练算法。Solver定义了针对Net网络模型的求解方法,记录网络的训练过程,保存网络模型参数,中断并恢复网络的训练过程。自定义Solver能够实现不同的神经网络求解方式。阅读Solver的代码可以了解网络的求解优化过程。Solver是一个父类,它下面还有实现不同优化方法的子类,例如sgd_solver,adagrad_sovler等,Solver是通过SolverFactory来创建的。

    6. Proto

    caffe.proto位于…/src/caffe/proto目录下,在这个文件夹下还有一个.pb.cc和一个.pb.h文件,这两个文件都是由caffe.proto编译而来的。 在caffe.proto中定义了很多结构化数据,包括: 
    BlobProto、Datum、FillerParameter、NetParameter、SolverParameter、SolverState、LayerParameter、ConcatParameter、ConvolutionParameter、DataParameter、DropoutParameter、HDF5DataParameter、HDF5OutputParameter、ImageDataParameter、InfogainLossParameter、InnerProductParameter、LRNParameter、MemoryDataParameter、PoolingParameter、PowerParameter、WindowDataParameter、V0LayerParameter。

    7. IO

    除了上面的东西之外,还需要输入数据和参数。DataReader和DataTransformer帮助准备输入数据,Filler对参数进行初始化,一些Snapshot方法可以对模型进行持久化。

    参考资料:

    1. https://zhuanlan.zhihu.com/p/21796890
    展开全文
  • caffe入门学习

    万次阅读 多人点赞 2015-12-29 16:53:50
    转载自:深度学习(六)caffe入门学习 - hjimce的专栏 - 博客频道 - CSDN.NET http://blog.csdn.net/hjimce/article/details/48933813 本文主要讲解caffe的整个使用流程,适用于初级入门caffe,通过学习本...

    转载自:深度学习(六)caffe入门学习 - hjimce的专栏 - 博客频道 - CSDN.NET
    http://blog.csdn.net/hjimce/article/details/48933813


    本文主要讲解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。这个便是手写字体网络结构文件了,我们需要根据自己的需要学会修改这个文件:

    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文件:

    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可执行文件,进行训练就可以了。具体的命令如下:

    1. <span style="font-size:18px;">./build/tools/caffe train --solver=examples/mnist/lenet_solver.prototxt</span>  

    这样就完事了,程序就开始训练了。上面的第一个参数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 plaincopy
    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 plaincopy
    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 plaincopy
    1. <span style="font-size:18px;">#!/usr/bin/env sh  
    2. TOOLS=../cafferead/build/tools  
    3. $TOOLS/caffe train --solver=gender_solver.prorotxt  -gpu all  #加入 -gpu 选项</span>  

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

    2、采用funing-tuning 训练法

    [python] view plaincopy
    1. <span style="font-size:18px;">$TOOLS/caffe train --solver=gender_solver.prorotxt -weights gender_net.caffemodel #加入-weights</span>  

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

    三、调用python接口

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

    [python] view plaincopy
    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)) + ((00),) * (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((0213) + 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=(256256))#设置输入图片的大小  
    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(0231))  
    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加载训练好的模型,进行预测及其特征可视化的调用方法。
    展开全文
  • Caffe的各个版本简介

    千次阅读 2019-06-03 17:47:35
    Tensorflow和Caffe是机器学习初学者常用的2种深度学习框架。相对于Tensorflow有简单的python pip一键安装包,Caffe的安装更考验开发者的计算机编译水平,需要自己下载源码编译。尽管caffe的配置教程网上很多,但是...
  • 什么是caffe

    万次阅读 2017-08-20 19:24:56
    Caffe的全称应该是Convolutional Architecture for Fast Feature Embedding,它是一个清晰、高效的深度学习框架,它是开源的,核心语言是C++,它支持命令行、Python和Matlab接口,它既可以在CPU上运行也可以在GPU上...
  • Caffe 深度学习框架上手教程

    万次阅读 2016-01-04 11:09:14
    转载自: Caffe 深度学习框架上手教程 - OPEN 开发经验库 ... ...Caffe的优势Caffe的网络定义数据及其导数以blobs的形式在层间...Caffe的各层定义训练网络安装了CUDA之后,依次按照Caffe官网安装指南安装BLAS、OpenCV
  • 1,在代码中进行 import caffe 后报错ImportError:No module named _caffe  因为我显卡之前出错了,重现编译了caffe ,后面导致如上问题,解决方法如下:  cd caffe #进入caffe目录,可能你的是cd caffe-master ...
  • Caffe2和Caffe有何不同?

    万次阅读 2017-04-21 15:17:22
    目前Caffe2还不能完全替代Caffe,还缺不少东西,例如CuDNN。与Caffe2相比,Caffe仍然是主要的稳定版本,在生产环境中使用仍然推荐Caffe
  • 180519 五种方法利用Anaconda安装Caffe

    万次阅读 2018-05-22 08:36:43
    方法1:Conda-caffe-27 # 首先创建一个新的运行环境并安装相应工具包,避免与其他配置的冲突 conda create -n caffe27 python=2.7 # 然后下面二选一即可,安装caffe conda install -c conda-forge caffe conda ...
  • python调用caffe

    万次阅读 2017-08-14 11:38:44
    首先需要安装caffe for python,安装过程可以参考:...python 中调用caffe库函数为: import caffe 如果不再caffe目录下运行汇报错: import caffe ImportError: No module named caffe 这是
  • python导入caffe模块的问题

    万次阅读 2017-08-30 20:31:20
    ImportError: No module named caffe这是由于没有将caffe的python模块添加到python的引用目录中导致的,解决方法:sudo vim ~/.bashrc在文件最后写入如下内容:export PYTHONPATH=~/caffe/python
  • pycharm中import caffe/caffe2

    千次阅读 2017-04-26 17:05:39
    pycharm中import caffe/caffe2
  • import caffe失败 No module named caffe

    万次阅读 2017-05-03 19:16:31
    在成功编译caffe的源码之后,可以在python环境中使用caffe。 在Ubuntu环境下,打开python解释程序,输入import caffe时:出现以下错误 >>>import caffe Traceback (most recent call last): File "", line 1, in ...
  • Caffe学习笔记

    万次阅读 多人点赞 2015-11-15 20:27:35
    安装与配置 Tutorial学习 PyCaffe学习 buildtools学习 其他
  • caffecaffe2踩坑经验分享

    万次阅读 2017-06-20 11:40:21
    caffecaffe2踩坑后的吐血经验分享
  • PROTOC src/caffe/proto/caffe.proto CXX .build_release/src/caffe/proto/caffe.pb.cc CXX src/caffe/common.cpp CXX src/caffe/net.cpp CXX src/caffe/internal_thread.cpp CXX src/caffe/layers/cudnn_...
  • 使用caffe时编译出错

    万次阅读 2015-09-07 20:04:11
    使用caffe时编译出错 使用自己机器编译的include和lib (caffe/build/lib, caffe/include) caffe.pb.h丢失问题: /home/wuliwei/caffe/include/caffe/blob.hpp:9:34: fatal error: caffe/proto/caffe.pb.h: No such ...
  • make: *** [.build_release/lib/libcaffe.so] 错误 1

    万次阅读 热门讨论 2017-01-06 10:32:47
    caffe 安装的时候遇到这个问题。 PROTOC src/caffe/proto/caffe.proto CXX src/caffe/layer.cpp CXX src/caffe/util/io.cpp CXX src/caffe/util/signal_handler.cpp CXX src/caffe/util/db_lmdb.cpp CXX src/caffe/...
1 2 3 4 5 ... 20
收藏数 58,002
精华内容 23,200
关键字:

caffe