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入门学习

    万次阅读 多人点赞 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加载训练好的模型,进行预测及其特征可视化的调用方法。
    展开全文
  • 5天搞定深度学习框架-Caffe入门系列

    万人学习 2018-10-22 21:38:09
    本课程是在windows环境下的caffe课程,主要使用的是python的接口。 首先带着大家完成一个MNIST手写数字识别的项目,让大家了解caffe训练模型的大致流程。然后会讲到caffe中的一些重要文件和配置,使用python绘图。...
  • Caffe基础介绍

    万次阅读 多人点赞 2018-01-11 08:45:54
    Caffe基础介绍!

    Caffe的全称应该是Convolutional Architecture for Fast Feature Embedding,它是一个清晰、高效的深度学习框架,它是开源的,核心语言是C++,它支持命令行、Python和Matlab接口,它既可以在CPU上运行也可以在GPU上运行。它的license是BSD 2-Clause。

    Deep Learning比较流行的一个原因,主要是因为它能够自主地从数据上学到有用的feature。特别是对于一些不知道如何设计feature的场合,比如说图像和speech。

    Caffe的设计:基本上,Caffe follow了神经网络的一个简单假设----所有的计算都是以layer的形式表示的layer做的事情就是take一些数据,然后输出一些计算以后的结果,比如说卷积,就是输入一个图像,然后和这一层的参数(filter)做卷积,然后输出卷积的结果。每一个layer需要做两个计算:forward是从输入计算输出,然后backward是从上面给的gradient来计算相对于输入的gradient,只要这两个函数实现了以后,我们就可以把很多层连接成一个网络,这个网络做的事情就是输入我们的数据(图像或者语音或者whatever),然后来计算我们需要的输出(比如说识别的label),在training的时候,我们可以根据已有的label来计算loss和gradient,然后用gradient来update网络的参数,这个就是Caffe的一个基本流程。

    基本上,最简单地用Caffe上手的方法就是先把数据写成Caffe的格式,然后设计一个网络,然后用Caffe提供的solver来做优化看效果如何,如果你的数据是图像的话,可以从现有的网络,比如说alexnet或者googlenet开始,然后做fine tuning,如果你的数据稍有不同,比如说是直接的float vector,你可能需要做一些custom的configuration,Caffe的logistic regression example兴许会很有帮助。

    Fine tune方法:fine tuning的想法就是说,在imagenet那么大的数据集上train好一个很牛的网络了,那别的task上肯定也不错,所以我们可以把pretrain的网络拿过来,然后只重新train最后几层,重新train的意思是说,比如我以前需要classify imagenet的一千类,现在我只想识别是狗还是猫,或者是不是车牌,于是我就可以把最后一层softmax从一个4096*1000的分类器变成一个4096*2的分类器,这个strategy在应用中非常好使,所以我们经常会先在imagenet上pretrain一个网络,因为我们知道imagenet上training的大概过程会怎么样。

    Caffe可以应用在视觉、语音识别、机器人、神经科学和天文学。

    Caffe提供了一个完整的工具包,用来训练、测试、微调和部署模型。

    Caffe的亮点

    (1)、模块化:Caffe从一开始就设计得尽可能模块化,允许对新数据格式、网络层和损失函数进行扩展。

    (2)、表示和实现分离:Caffe的模型(model)定义是用Protocol Buffer语言写进配置文件的。以任意有向无环图的形式,Caffe支持网络架构。Caffe会根据网络的需要来正确占用内存。通过一个函数调用,实现CPU和GPU之间的切换。

    (3)、测试覆盖:在Caffe中,每一个单一的模块都对应一个测试。

    (4)、Python和Matlab接口:同时提供Python和Matlab接口。

    (5)、预训练参考模型:针对视觉项目,Caffe提供了一些参考模型,这些模型仅应用在学术和非商业领域,它们的license不是BSD。

    Caffe架构

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

    (2)、层:一个Caffe层(Layer)是一个神经网络层的本质,它采用一个或多个blobs作为输入,并产生一个或多个blobs作为输出。网络作为一个整体的操作,层有两个关键职责:前向传播,需要输入并产生输出;反向传播,取梯度作为输出,通过参数和输入计算梯度。Caffe提供了一套完整的层类型。

    (3)、网络和运行方式:Caffe保留所有的有向无环层图,确保正确的进行前向传播和反向传播。Caffe模型是终端到终端的机器学习系统。一个典型的网络开始于数据层,结束于loss层。通过一个单一的开关,使其网络运行在CPU或GPU上。在CPU或GPU上,层会产生相同的结果。

    (4)、训练一个网络:Caffe训练一个模型(Model)靠快速、标准的随机梯度下降算法。

    在Caffe中,微调(Fine tuning),是一个标准的方法,它适应于存在的模型、新的架构或数据。对于新任务,Caffe 微调旧的模型权重并按照需要初始化新的权重。

    Blobs,Layers,and Nets:深度网络的组成模式表示为数据块工作的内部连接层的集合。以它自己的model模式,Caffe定义了层层(layer-by-layer)网络。Caffe网络定义了从低端到顶层整个model,从输入数据到loss层。随着数据通过网络的前向传播和反向传播,Caffe存储、通信、信息操作作为Blobs。Blob是标准阵列和统一内存接口框架。Blob用来存储数据、参数以及loss。随之而来的layer作为model和计算的基础,它是网络的基本单元。net作为layer的连接和集合,网络的搭建。blob详细描述了layer与layer或net是怎样进行信息存储和通信的。Solver是Net的求解。

    Blob 存储和传输:一个blob是对要处理的实际数据的封装,它通过Caffe传递。在CPU和GPU之间,blob也提供同步能力。在数学上,blob是存储连续的N维数组阵列。

    Caffe通过blobs存储和传输数据。blobs提供统一的内存接口保存数据,例如,批量图像,model参数,导数的优化。

    Blobs隐藏了计算和混合CPU/GPU的操作根据需要从主机CPU到设备GPU进行同步的开销。主机和设备的内存是按需分配。

    对于批量图像数据,blob常规容量是图像数N*通道数K*图像高H*图像宽W。在布局上,Blob存储以行为主,因此最后/最右边的维度改变最快。例如,在一个4D blob中,索引(n, k, h, w)的值物理位置索引是((n * K + k) * H + h) * W + w。对于非图像应用,用blobs也是有效的,如用2D blobs。

    参数blob尺寸根据当前层的类型和配置而变化。

    一个blob存储两块内存,data和diff,前者是前向传播的正常数据,后者是通过网络计算的梯度。

    一个blob使用SyncedMem类同步CPU和GPU之间的值,为了隐藏同步的详细信息和尽量最小的数据传输。

    Layer计算和连接:Layer是模型(model)的本质和计算的基本单元。Layer卷积滤波、pool、取内积、应用非线性、sigmoid和其它元素转换、归一化、载入数据,计算losses.

    每一个layer类型定义了三个至关重要的计算:设置、前向和反向。(1)、设置:初始化这个layer及在model初始化时连接一次;(2)、前向:从底部对于给定的输入数据计算输出并传送到顶端;(3)、反向:对于给定的梯度,顶端输出计算这个梯度到输入并传送到低端。

    有两个前向(forward)和反向(backward)函数执行,一个用于CPU,一个用于GPU。

    Caffe layer的定义由两部分组成,层属性和层参数。

    每个layer有输入一些’bottom’blobs,输出一些’top’ blobs.

    Net定义和操作:net由组成和分化共同定义了一个函数和它的梯度。每一层输出计算函数来完成给定的任务,每一层反向从学习任务中通过loss计算梯度.Caffe model是终端到终端的机器学习引擎。

    Net是layers组成的有向无环图(DAG)。一个典型的net开始于数据层,此layer从磁盘加载数据,终止于loss层,此layer计算目标任务,如分类和重建。

    Model初始化通过Net::Init()进行处理。初始化主要做了两件事:通过创建blobs和layers来构建整个DAG,调用layers的SetUp()函数。它也做了一系列的其它bookkeeping(簿记)的事情,比如验证整个网络架构的正确性。

    Model格式:The models are defined in plaintext protocol buffer schema(prototxt) while the learned models are serialized as binary protocol buffer(binaryproto) .caffemodel files. The model format is defined by the protobufschema in caffe.proto.

    Forward and Backward:Forward inference, Backward learning.

    Solver优化一个model通过首先调用forward得到输出和loss,然后调用backward生成model的梯度,接着合并梯度到权值(weight)更新尽量减少loss.Solver, Net和Layer之间的分工,使Caffe保持模块化和开放式发展。

    Loss:在Caffe中,作为大多数机器学习,学习(learning)是通过loss函数(error, cost, or objective函数)来驱动。一个loss函数指定了学习的目标通过映射参数设置(例如,当前的网络权值)到一个标量值。因此,学习的目标是找到最小化loss函数权值的设置。

    在Caffe中,loss是由网络的forward计算。每一个layer采用一组输入blobs(bottom,表示输入),并产生一组输出blobs(top,表示输出)。一些layer的输出可能会用在loss函数中。对于分类任务,一个典型的loss函数选择是SoftmaxWithLoss函数。

    Loss weights:net通过许多个layers产生一个loss,loss weights能被用于指定它们的相对重要性。

    按照惯例,带有”loss”后缀的Caffe layer类型应用于loss函数,但其它layers是被假定为纯碎用于中间计算。然而,任一个layer都能被用于loss,通过添加一个”loss_weight”字段到一个layer定义。

    在Caffe中,最后的loss是被计算通过所有的weighted loss加和通过网络。

    Solver:Solver通过协调网络的前向推理和后向梯度形成参数更新试图改善loss达到model优化。Learning的职责是被划分为Solver监督优化和产生参数更新,Net产生loss和梯度。

    Caffe solver方法:随机梯度下降(Stochastic Gradient Descent, type:”SGD”);AdaDelta(type:”AdaDelta”);自适应梯度(Adaptive Gradient,type:”AdaGrad”);Adam(type:”Adam”);Nesterov’s Accelerated Gradient(type:”Nesterov”);RMSprop(type:”RMSProp”).

    Solver作用:Solver是Net的求解.(1)、优化bookkeeping、创建learning训练网络、对网络进行评估;(2)、调用forward/backward迭代优化和更新参数;(3)、定期评估测试网络;(4)、整个优化快照model和solver状态。

    Solver的每一次迭代执行:(1)、调用网络forward计算输出和loss;(2)、调用网络backward计算梯度;(3)、按照solver方法,采用渐变进行参数更新;(4)、按照学习率、历史和方法更新solver状态。通过以上执行来获得所有的weights从初始化到learned model.

    像Caffe models,Caffe solvers也可以在CPU或GPU模式下运行。

    solver方法处理最小化loss的总体优化问题。

    实际的weight更新是由solver产生,然后应用到net参数。

    Layer Catalogue:为了创建一个Caffe model,你需要定义model架构在一个prototxt文件(protocol buffer definition file)中。Caffe layers和它们的参数是被定义在protocol buffer definitions文件中,对于Caffe工程是caffe.proto.

    Vision Layers:Vision layers通常以图像作为输入,并产生其它图像作为输出:

    (1)、Convolution(Convolution):卷积层通过将输入图像与一系列可学习的滤波进行卷积,在输出图像中,每一个产生一个特征图;(2)、Pooling(Pooling);(3)、Local Response Normalization(LRN);(4)、im2col。

    Loss Layers:Loss驱动学习通过比较一个输出对应一个目标和分配成本到最小化。Loss本身是被计算通过前向传输,梯度到loss是被计算通过后向传输:

    (1)、Softmax(SoftmaxWithLoss);(2)、Sum-of-Squares/Euclidean(EuclideanLoss);(3)、Hinge/Margin(HingeLoss);(4)、SigmoidCross-Entropy(SigmoidCrossEntropyLoss);(5)、Infogain(InfogainLoss);(6)、Accuracy andTop-k。

    Activation/NeuronLayers:一般Activation/Neuron Layers是逐元素操作,输入一个bottom blob,产生一个同样大小的top blob:

    (1)、ReLU/Rectified-Linearand Leaky-ReLU(ReLU);(2)、Sigmoid(Sigmoid);(3)、TanH/Hyperbolic Tangent(TanH);(4)、Absolute Value(AbsVal);(5)、Power(Power);(6)、BNLL(BNLL)。

    Data Layers:数据输入Caffe通过Data Layers,它们在网络的低端。数据可以来自于:高效的数据库(LevelDB或LMDB)、直接来自内存、在不注重效率的情况下,也可以来自文件,磁盘上HDF5数据格式或普通的图像格式:

    (1)、Database(Data);(2)、In-Memory(MemoryData);(3)、HDF5Input(HDF5Data);(4)、HDF5 Output(HDF5Output);(5)、Images(ImageData);(6)、Windows(WindowData);(7)、Dummy(DummyData).

    Common Layers:(1)、InnerProduct(InnerProduct);(2)、Splitting(Split);(3)、Flattening(Flatten);(4)、Reshape(Reshape);(5)、Concatenation(Concat);(6)、Slicing(Slice);(7)、Elementwise Operations(Eltwise);(8)、Argmax(ArgMax);(9)、Softmax(Softmax);(10)、Mean-VarianceNormalization(MVN)。

    Data:在Caffe中,数据存储在Blobs中。Data Layers加载输入和保存输出通过转换从blob到其它格式。普通的转换像mean-subtraction和feature-scaling是通过配置data layer来完成。新的输入类型需要开发一个新的data layer来支持。

     

    以上内容来自于Caffe官方网站的翻译和一些网络blog的整理,主要参考:

    1.      《Caffe: Convolutional Architecture for Fast Feature Embedding》

    2.      http://caffe.berkeleyvision.org/tutorial/

    3.      http://suanfazu.com/t/caffe/281/3

    4.      http://mp.weixin.qq.com/s?__biz=MzAxNTE2MjcxNw==&mid=206508839&idx=1&sn=4dea40d781716da2f56d93fe23c158ab#rd

    5.      https://yufeigan.github.io/


    关于Caffe在Windows上的配置可以参考: http://blog.csdn.net/fengbingchun/article/details/50987353

    GitHub: https://github.com/fengbingchun/Caffe_Test 

    展开全文
  • 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的简介、依赖、框架

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

    万次阅读 2016-01-04 11:09:14
    转载自: Caffe 深度学习框架上手教程 - OPEN 开发经验库 ... ...Caffe的优势Caffe的网络定义数据及其导数以blobs的形式在层间...Caffe的各层定义训练网络安装了CUDA之后,依次按照Caffe官网安装指南安装BLAS、OpenCV
  • Ubuntu16.04 Caffe 安装步骤记录(超详尽)

    万次阅读 多人点赞 2020-04-07 23:23:44
    历时一周终于在 ubuntu16.04 系统成功安装 caffe 并编译,网上有很多教程,但是某些步骤并没有讲解详尽,导致配置过程总是出现各种各样匪夷所思的问题,尤其对于新手而言更是欲哭无泪,在我饱受折磨后决定把安装步骤...
  • 深度学习(六)caffe入门学习

    万次阅读 多人点赞 2016-03-26 12:27:11
    本文主要讲解caffe的整个使用流程,适用于初级入门caffe,通过学习本篇博文,理清项目训练、测试流程。初级教程,高手请绕道。 我们知道,在caffe编译完后,在caffe目录下会生成一个build目录,在build目录下有个...
  • caffe安装系列——安装caffe

    万次阅读 2019-09-25 16:53:28
    网上关于caffe的安装教程非常多,但是关于每一步是否操作成功,出现了什么样的错误又该如何处理没有给出说明。因为大家的操作系统的环境千差万别,按照博客中的教程一步步的安装,最后可能失败——这是很常见的哦。...
  • 网上关于caffe的安装教程非常多,但是关于每一步是否操作成功,出现了什么样的错误又该如何处理没有给出说明。因为大家的操作系统的环境千差万别,按照博客中的教程一步步的安装,最后可能失败——这是很常见的哦。...
  • caffe-Windows】caffe+VS2013+Windows无GPU快速配置教程

    万次阅读 多人点赞 2018-06-15 10:32:34
    首先来一波地址: happynear大神的第三方caffe:...Neil Z大神的第三方caffe:https://initialneil.wordpress.com/2015/01/11/build-caffe-in-windows-with-visual-studio-2013-cu
  • 解析caffe生成的caffemodel文件

    万次阅读 2018-07-29 20:44:09
    要想了解caffe生成的caffemodel文件里的内容,我们就需要解析.caffemodel文件(caffemodel里不仅存储了权重和偏置等信息,还存储了整个训练网络的结构信息,即.prototxt信息,当然solver.prototxt信息是看不见的)。...
  • 对于使用深度学习进行图像处理,Caffe是一个不错的框架选择。但是安装起来,并不是如想象中容易,稍不注意就会出错。 网上关于Ubuntu14.04下配置Caffe的资料很多,但是总是要自己亲自配置才能获得自己的心得。 从...
  • caffe学习系列:训练自己的图片集(超详细教程)

    万次阅读 多人点赞 2017-02-17 11:32:49
    学习的caffe的目的,不是简单的做几个练习,而是最终落实到自己的项目或科研中去。因此,本文介绍一下,从自己的原始图片到lmdb数据,再到训练和测试的整个流程。 一、数据的准备  有条件的同学,可以去ImageNet的...
  • Caffe学习之——caffe目录结构说明

    千次阅读 2018-06-07 13:28:28
    转自:http://yufeigan.github.io/下载caffe后,caffe文件夹下的文件目录结构如下图:这里,最重要的三个文件夹就是include, tools, src。在源码解读中会对里面的文件代码一一介绍,这里给出src文件的结构:src中的...
  • Win10使用VS2017安装Caffe详细总结

    万次阅读 多人点赞 2018-10-12 10:50:09
    1 前言   本文将在Win10系统上安装和配置caffe。与网络上大多数文章不同,本文...  本文中用%CAFFE_DIR%代表准备安装caffe的目录路径,请读者自行替换为实际路径,如D:\Caffe\。   本文中用%USER_NAME%代表Wi...
1 2 3 4 5 ... 20
收藏数 58,290
精华内容 23,316
关键字:

caffe