Caffe源码中layer文件分析

Caffe源码(caffe version commit: 09868ac , date: 2015.08.15)中有一些重要的头文件，这里介绍下include/caffe/layer.hpp文件的内容：

1.      include文件：

(1)、<caffe/blob.hpp>：此文件的介绍可以参考：http://blog.csdn.net/fengbingchun/article/details/59106613

(2)、<caffe/common.hpp>：此文件的介绍可以参考：http://blog.csdn.net/fengbingchun/article/details/54955236

(3)、<caffe/layer_factory.hpp>：此文件的介绍可以参考：http://blog.csdn.net/fengbingchun/article/details/54310956

(4)、<caffe/proto/caffe.pb.h>：此文件的介绍可以参考：http://blog.csdn.net/fengbingchun/article/details/55267162

(5)、<caffe/util/device_alternate.hpp>：此文件的介绍可以参考：http://blog.csdn.net/fengbingchun/article/details/54955236

2.        类Layer：抽象基类，有纯虚函数，不能实例化，定义了所有layer的基本接口，具体的每个layer完成一类特定的计算

Layer是Caffe模型的本质内容和执行计算的基本单元。Layer可以进行很多运算，如convolve(卷积)、pool(池化)、inner product(内积)，rectified-linear和sigmoid等非线性运算，元素级的数据变换，normalize(归一化)、load data(数据加载)、softmax和hinge等losses(损失计算)。可在Caffe的  http://caffe.berkeleyvision.org/tutorial/layers.html  (层目录)中查看所有操作，其囊括了绝大部分目前最前沿的深度学习任务所需要的层类型。

一个layer通过bottom(底部) 连接层接收blobs数据，通过top(顶部)连接层输出blobs数据。Caffe中每种类型layer的参数说明定义在caffe.proto文件中，具体的layer参数值则定义在具体应用的prototxt网络结构说明文件中。

在Caffe中，一个网络的大部分功能都是以layer的形式去展开的。在创建一个Caffe模型的时候，也是以layer为基础进行的，需按照caffe.proto中定义的网络及参数格式定义网络prototxt文件。在.prototxt文件中会有很多个layer {  } 字段。

每一个layer都定义了3种重要的运算：setup(初始化设置)，forward(前向传播)，backward(反向传播)。

(1)、setup：在模型初始化时重置layers及其相互之间的连接；

(2)、forward：从bottom层中接收数据，进行计算后将输出送人到top层中；

(3)、backward：给定相对于top层输出的梯度，计算其相对于输入的梯度，并传递到bottom层。一个有参数的layer需要计算相对于各个参数的梯度值并存储在内部。

特别地，forward和backward函数分别有CPU和GPU两张实现方式。如果没有实现GPU版本，那么layer将转向作为备用选项的CPU方式。这样会增加额外的数据传送成本(输入数据由GPU上复制到CPU，之后输出数据从CPU又复制回到GPU)。

总的来说，Layer承担了网络的两个核心操作：forward pass(前向传播)----接收输入并计算输出；backward pass(反向传播)----接收关于输出的梯度，计算相对于参数和输入的梯度并反向传播给在它前面的层。由此组成了每个layer的前向和反向传播。

Layer是网络的基本单元，由此派生出了各种层类。在Layer中input data用bottom表示，output data用top表示。由于Caffe网络的组合性和其代码的模块化，自定义layer是很容易的。只要定义好layer的setup(初始化设置)、forward(前向传播，根据input计算output)和backward(反向传播，根据output计算input的梯度)，就可将layer纳入到网络中。

前传(forward)过程为给定的待推断的输入计算输出。在前传过程中，Caffe组合每一层的计算以得到整个模型的计算”函数”。本过程自底向上进行。

反传(backward)过程根据损失来计算梯度从而进行学习。在反传过程中，Caffe通过自动求导并反向组合每一层的梯度来计算整个网络的梯度。这就是反传过程的本质。本过程自顶向下进行。

反传过程以损失开始，然后根据输出计算梯度。根据链式准则，逐层计算出模型其余部分的梯度。有参数的层，会在反传过程中根据参数计算梯度。

与大多数的机器学习模型一样，在Caffe中，学习是由一个损失函数驱动的(通常也被称为误差、代价或者目标函数)。一个损失函数通过将参数集(即当前的网络权值)映射到一个可以标识这些参数”不良程度”的标量值来学习目标。因此，学习的目的是找到一个网络权重的集合，使得损失函数最小。

在Caffe中，损失是通过网络的前向计算得到的。每一层由一系列的输入blobs(bottom)，然后产生一系列的输出blobs(top)。这些层的某些输出可以用来作为损失函数。典型的一对多分类任务的损失函数是softMaxWithLoss函数。

Caffe中每种类型layer的参数说明定义在caffe.proto文件中，具体的layer参数值则定义在具体应用的protobuf网络结构说明文件中。

注：以上关于Layer内容的介绍主要摘自由CaffeCN社区翻译的《Caffe官方教程中译本》。

<caffe/layer.hpp>文件的详细介绍如下：

#ifndef CAFFE_LAYER_H_
#define CAFFE_LAYER_H_#include <algorithm>
#include <string>
#include <vector>#include "caffe/blob.hpp"
#include "caffe/common.hpp"
#include "caffe/layer_factory.hpp"
#include "caffe/proto/caffe.pb.h"
#include "caffe/util/device_alternate.hpp"/**Forward declare boost::thread instead of including boost/thread.hppto avoid a boost/NVCC issues (#1009, #1010) on OSX.*/
// 前向声明boost的互斥类：boost::mutex
namespace boost { class mutex; }namespace caffe {
/*** @brief An interface for the units of computation which can be composed into a*        Net.** Layer%s must implement a Forward function, in which they take their input* (bottom) Blob%s (if any) and compute their output Blob%s (if any).* They may also implement a Backward function, in which they compute the error* gradients with respect to their input Blob%s, given the error gradients with* their output Blob%s.*/
template <typename Dtype>
class Layer { // 抽象基类，有纯虚函数，不能实例化，定义了所有layer的基本接口public:/*** You should not implement your own constructor. Any set up code should go* to SetUp(), where the dimensions of the bottom blobs are provided to the* layer.*/
// 显式构造函数，不需要重写，获得成员变量layer_param_、phase_、blobs_的值explicit Layer(const LayerParameter& param): layer_param_(param), is_shared_(false) {// Set phase and copy blobs (if there are any).phase_ = param.phase();if (layer_param_.blobs_size() > 0) {blobs_.resize(layer_param_.blobs_size());for (int i = 0; i < layer_param_.blobs_size(); ++i) {blobs_[i].reset(new Blob<Dtype>());blobs_[i]->FromProto(layer_param_.blobs(i));}}}
// 虚析构函数virtual ~Layer() {}/*** @brief Implements common layer setup functionality.** @param bottom the preshaped input blobs* @param top*     the allocated but unshaped output blobs, to be shaped by Reshape** Checks that the number of bottom and top blobs is correct.* Calls LayerSetUp to do special layer setup for individual layer types,* followed by Reshape to set up sizes of top blobs and internal buffers.* Sets up the loss weight multiplier blobs for any non-zero loss weights.* This method may not be overridden.*/
// layer初始化,此方法不需要重写void SetUp(const vector<Blob<Dtype>*>& bottom,const vector<Blob<Dtype>*>& top) {InitMutex();CheckBlobCounts(bottom, top);LayerSetUp(bottom, top);Reshape(bottom, top);SetLossWeights(top);}/*** @brief Does layer-specific setup: your layer should implement this function*        as well as Reshape.** @param bottom*     the preshaped input blobs, whose data fields store the input data for*     this layer* @param top*     the allocated but unshaped output blobs** This method should do one-time layer specific setup. This includes reading* and processing relevent parameters from the <code>layer_param_</code>.* Setting up the shapes of top blobs and internal buffers should be done in* <code>Reshape</code>, which will be called before the forward pass to* adjust the top blob sizes.*/
// 通过Layer参数即LayerParameter类获得layer中某些成员变量的值virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,const vector<Blob<Dtype>*>& top) {}/*** @brief Whether a layer should be shared by multiple nets during data*        parallelism. By default, all layers except for data layers should*        not be shared. data layers should be shared to ensure each worker*        solver access data sequentially during data parallelism.*/
// 获得layer data共享状态:一个layer的data是否被多个net共享virtual inline bool ShareInParallel() const { return false; }/** @brief Return whether this layer is actually shared by other nets.*         If ShareInParallel() is true and using more than one GPU and the*         net has TRAIN phase, then this function is expected return true.*/
// 获得layer是否被其它net共享inline bool IsShared() const { return is_shared_; }/** @brief Set whether this layer is actually shared by other nets*         If ShareInParallel() is true and using more than one GPU and the*         net has TRAIN phase, then is_shared should be set true.*/
// 设置layer是否被其它net共享inline void SetShared(bool is_shared) {CHECK(ShareInParallel() || !is_shared)<< type() << "Layer does not support sharing.";is_shared_ = is_shared;}/*** @brief Adjust the shapes of top blobs and internal buffers to accommodate*        the shapes of the bottom blobs.** @param bottom the input blobs, with the requested input shapes* @param top the top blobs, which should be reshaped as needed** This method should reshape top blobs as needed according to the shapes* of the bottom (input) blobs, as well as reshaping any internal buffers* and making any other necessary adjustments so that the layer can* accommodate the bottom blobs.*/
// 调整top blobs的shapevirtual void Reshape(const vector<Blob<Dtype>*>& bottom,const vector<Blob<Dtype>*>& top) = 0;/*** @brief Given the bottom blobs, compute the top blobs and the loss.** @param bottom*     the input blobs, whose data fields store the input data for this layer* @param top*     the preshaped output blobs, whose data fields will store this layers'*     outputs* \return The total loss from the layer.** The Forward wrapper calls the relevant device wrapper function* (Forward_cpu or Forward_gpu) to compute the top blob values given the* bottom blobs.  If the layer has any non-zero loss_weights, the wrapper* then computes and returns the loss.** Your layer should implement Forward_cpu and (optionally) Forward_gpu.*/
// 前向传播，通过输入bottom blobs，计算输出top blobs和返回loss和inline Dtype Forward(const vector<Blob<Dtype>*>& bottom,const vector<Blob<Dtype>*>& top);/*** @brief Given the top blob error gradients, compute the bottom blob error*        gradients.** @param top*     the output blobs, whose diff fields store the gradient of the error*     with respect to themselves* @param propagate_down*     a vector with equal length to bottom, with each index indicating*     whether to propagate the error gradients down to the bottom blob at*     the corresponding index* @param bottom*     the input blobs, whose diff fields will store the gradient of the error*     with respect to themselves after Backward is run** The Backward wrapper calls the relevant device wrapper function* (Backward_cpu or Backward_gpu) to compute the bottom blob diffs given the* top blob diffs.** Your layer should implement Backward_cpu and (optionally) Backward_gpu.*/
// 反向传播，通过给定top blob误差梯度，计算bottom blob误差梯度inline void Backward(const vector<Blob<Dtype>*>& top,const vector<bool>& propagate_down,const vector<Blob<Dtype>*>& bottom);/*** @brief Returns the vector of learnable parameter blobs.*/
// 获得layer的权值、偏置等vector<shared_ptr<Blob<Dtype> > >& blobs() {return blobs_;}/*** @brief Returns the layer parameter.*/
// 获得layer的配置参数const LayerParameter& layer_param() const { return layer_param_; }/*** @brief Writes the layer parameter to a protocol buffer*/
// 序列化函数，将layer参数写入protobuf文件virtual void ToProto(LayerParameter* param, bool write_diff = false);/*** @brief Returns the scalar loss associated with a top blob at a given index.*/
// 获得top blob指定index的loss值inline Dtype loss(const int top_index) const {return (loss_.size() > top_index) ? loss_[top_index] : Dtype(0);}/*** @brief Sets the loss associated with a top blob at a given index.*/
// 设置top blob指定index的loss值inline void set_loss(const int top_index, const Dtype value) {if (loss_.size() <= top_index) {loss_.resize(top_index + 1, Dtype(0));}loss_[top_index] = value;}/*** @brief Returns the layer type.*/
// 获得layer的类型virtual inline const char* type() const { return ""; }/*** @brief Returns the exact number of bottom blobs required by the layer,*        or -1 if no exact number is required.** This method should be overridden to return a non-negative value if your* layer expects some exact number of bottom blobs.*/
// 获得layer所需的bottom blobs的个数virtual inline int ExactNumBottomBlobs() const { return -1; }/*** @brief Returns the minimum number of bottom blobs required by the layer,*        or -1 if no minimum number is required.** This method should be overridden to return a non-negative value if your* layer expects some minimum number of bottom blobs.*/
// 获得layer所需的bottom blobs的最少个数virtual inline int MinBottomBlobs() const { return -1; }/*** @brief Returns the maximum number of bottom blobs required by the layer,*        or -1 if no maximum number is required.** This method should be overridden to return a non-negative value if your* layer expects some maximum number of bottom blobs.*/
// 获得layer所需的bottom blobs的最多个数virtual inline int MaxBottomBlobs() const { return -1; }/*** @brief Returns the exact number of top blobs required by the layer,*        or -1 if no exact number is required.** This method should be overridden to return a non-negative value if your* layer expects some exact number of top blobs.*/
// 获得layer所需的top blobs的个数virtual inline int ExactNumTopBlobs() const { return -1; }/*** @brief Returns the minimum number of top blobs required by the layer,*        or -1 if no minimum number is required.** This method should be overridden to return a non-negative value if your* layer expects some minimum number of top blobs.*/
// 获得layer所需的top blobs的最少个数virtual inline int MinTopBlobs() const { return -1; }/*** @brief Returns the maximum number of top blobs required by the layer,*        or -1 if no maximum number is required.** This method should be overridden to return a non-negative value if your* layer expects some maximum number of top blobs.*/
// 获得layer所需的top blobs的最多个数virtual inline int MaxTopBlobs() const { return -1; }/*** @brief Returns true if the layer requires an equal number of bottom and*        top blobs.** This method should be overridden to return true if your layer expects an* equal number of bottom and top blobs.*/
// 判断layer所需的bottom blobs和top blobs的个数是否相等virtual inline bool EqualNumBottomTopBlobs() const { return false; }/*** @brief Return whether "anonymous" top blobs are created automatically*        by the layer.** If this method returns true, Net::Init will create enough "anonymous" top* blobs to fulfill the requirement specified by ExactNumTopBlobs() or* MinTopBlobs().*/
// 判断layer所需的的top blobs是否需要由Net::Init来创建virtual inline bool AutoTopBlobs() const { return false; }/*** @brief Return whether to allow force_backward for a given bottom blob*        index.** If AllowForceBackward(i) == false, we will ignore the force_backward* setting and backpropagate to blob i only if it needs gradient information* (as is done when force_backward == false).*/
// 判断layer指定的bottom blob是否需要强制梯度返回，因为有些layer其实不需要梯度信息virtual inline bool AllowForceBackward(const int bottom_index) const { return true; }/*** @brief Specifies whether the layer should compute gradients w.r.t. a*        parameter at a particular index given by param_id.** You can safely ignore false values and always compute gradients* for all parameters, but possibly with wasteful computation.*/
// 判断layer指定的blob是否应该计算梯度inline bool param_propagate_down(const int param_id) {return (param_propagate_down_.size() > param_id) ?param_propagate_down_[param_id] : false;}/*** @brief Sets whether the layer should compute gradients w.r.t. a*        parameter at a particular index given by param_id.*/
// 设置layer指定的blob是否应该计算梯度inline void set_param_propagate_down(const int param_id, const bool value) {if (param_propagate_down_.size() <= param_id) {param_propagate_down_.resize(param_id + 1, true);}param_propagate_down_[param_id] = value;}protected:
// Caffe中类的成员变量名都带有后缀"_"，这样就容易区分临时变量和类成员变量/** The protobuf that stores the layer parameters */
// 配置的layer参数，创建layer对象时，通过调用构造函数从上层传入，
// 关于LayerParameter类的具体参数可参考caffe.proto中的message LayerParameterLayerParameter layer_param_;/** The phase: TRAIN or TEST */
// layer状态：指定参与网络的是train还是test,Phase phase_;/** The vector that stores the learnable parameters as a set of blobs. */
// 用于存储layer的学习的参数如权值和偏置vector<shared_ptr<Blob<Dtype> > > blobs_;/** Vector indicating whether to compute the diff of each param blob. */
// 标志是否为layer指定的blob计算梯度值vector<bool> param_propagate_down_;/** The vector that indicates whether each top blob has a non-zero weight in*  the objective function. */
// 标志layer指定的top blob是否有一个非0权值vector<Dtype> loss_;/** @brief Using the CPU device, compute the layer output. */
// CPU实现layer的前向传播virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,const vector<Blob<Dtype>*>& top) = 0;/*** @brief Using the GPU device, compute the layer output.*        Fall back to Forward_cpu() if unavailable.*/
// GPU实现layer的前向传播virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,const vector<Blob<Dtype>*>& top) {// LOG(WARNING) << "Using CPU code as backup.";return Forward_cpu(bottom, top);}/*** @brief Using the CPU device, compute the gradients for any parameters and*        for the bottom blobs if propagate_down is true.*/
// CPU实现layer的反向传播virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,const vector<bool>& propagate_down,const vector<Blob<Dtype>*>& bottom) = 0;/*** @brief Using the GPU device, compute the gradients for any parameters and*        for the bottom blobs if propagate_down is true.*        Fall back to Backward_cpu() if unavailable.*/
// GPU实现layer的反向传播virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,const vector<bool>& propagate_down,const vector<Blob<Dtype>*>& bottom) {// LOG(WARNING) << "Using CPU code as backup.";Backward_cpu(top, propagate_down, bottom);}/*** Called by the parent Layer's SetUp to check that the number of bottom* and top Blobs provided as input match the expected numbers specified by* the {ExactNum,Min,Max}{Bottom,Top}Blobs() functions.*/
// 检查bottom 和top blobs个数是否匹配virtual void CheckBlobCounts(const vector<Blob<Dtype>*>& bottom,const vector<Blob<Dtype>*>& top) {if (ExactNumBottomBlobs() >= 0) {CHECK_EQ(ExactNumBottomBlobs(), bottom.size())<< type() << " Layer takes " << ExactNumBottomBlobs()<< " bottom blob(s) as input.";}if (MinBottomBlobs() >= 0) {CHECK_LE(MinBottomBlobs(), bottom.size())<< type() << " Layer takes at least " << MinBottomBlobs()<< " bottom blob(s) as input.";}if (MaxBottomBlobs() >= 0) {CHECK_GE(MaxBottomBlobs(), bottom.size())<< type() << " Layer takes at most " << MaxBottomBlobs()<< " bottom blob(s) as input.";}if (ExactNumTopBlobs() >= 0) {CHECK_EQ(ExactNumTopBlobs(), top.size())<< type() << " Layer produces " << ExactNumTopBlobs()<< " top blob(s) as output.";}if (MinTopBlobs() >= 0) {CHECK_LE(MinTopBlobs(), top.size())<< type() << " Layer produces at least " << MinTopBlobs()<< " top blob(s) as output.";}if (MaxTopBlobs() >= 0) {CHECK_GE(MaxTopBlobs(), top.size())<< type() << " Layer produces at most " << MaxTopBlobs()<< " top blob(s) as output.";}if (EqualNumBottomTopBlobs()) {CHECK_EQ(bottom.size(), top.size())<< type() << " Layer produces one top blob as output for each "<< "bottom blob input.";}}/*** Called by SetUp to initialize the weights associated with any top blobs in* the loss function. Store non-zero loss weights in the diff blob.*/
// 设置top blobs中diff值inline void SetLossWeights(const vector<Blob<Dtype>*>& top) {const int num_loss_weights = layer_param_.loss_weight_size();if (num_loss_weights) {CHECK_EQ(top.size(), num_loss_weights) << "loss_weight must be ""unspecified or specified once per top blob.";for (int top_id = 0; top_id < top.size(); ++top_id) {const Dtype loss_weight = layer_param_.loss_weight(top_id);if (loss_weight == Dtype(0)) { continue; }this->set_loss(top_id, loss_weight);const int count = top[top_id]->count();Dtype* loss_multiplier = top[top_id]->mutable_cpu_diff();caffe_set(count, loss_weight, loss_multiplier);}}}private:/** Whether this layer is actually shared by other nets*/
//标志当前layer是否被其它net共享bool is_shared_;/** The mutex for sequential forward if this layer is shared */
// 声明boost::mutex对象,互斥锁变量shared_ptr<boost::mutex> forward_mutex_;/** Initialize forward_mutex_ */
// 初始化互斥锁void InitMutex();/** Lock forward_mutex_ if this layer is shared */
// 如果layer是共享的则加锁void Lock();/** Unlock forward_mutex_ if this layer is shared */
// 如果layer是共享的则解锁void Unlock();// 禁止使用Layer类的拷贝和赋值操作DISABLE_COPY_AND_ASSIGN(Layer);
};  // class Layer// Forward and backward wrappers. You should implement the cpu and
// gpu specific implementations instead, and should not change these
// functions.
// 前向传播，通过输入bottom blobs，计算输出top blobs和loss值
template <typename Dtype>
inline Dtype Layer<Dtype>::Forward(const vector<Blob<Dtype>*>& bottom,const vector<Blob<Dtype>*>& top) {// Lock during forward to ensure sequential forwardLock();Dtype loss = 0;Reshape(bottom, top);switch (Caffe::mode()) {case Caffe::CPU:Forward_cpu(bottom, top);for (int top_id = 0; top_id < top.size(); ++top_id) {if (!this->loss(top_id)) { continue; }const int count = top[top_id]->count();const Dtype* data = top[top_id]->cpu_data();const Dtype* loss_weights = top[top_id]->cpu_diff();loss += caffe_cpu_dot(count, data, loss_weights);}break;case Caffe::GPU:Forward_gpu(bottom, top);
#ifndef CPU_ONLYfor (int top_id = 0; top_id < top.size(); ++top_id) {if (!this->loss(top_id)) { continue; }const int count = top[top_id]->count();const Dtype* data = top[top_id]->gpu_data();const Dtype* loss_weights = top[top_id]->gpu_diff();Dtype blob_loss = 0;caffe_gpu_dot(count, data, loss_weights, &blob_loss);loss += blob_loss;}
#endifbreak;default:LOG(FATAL) << "Unknown caffe mode.";}Unlock();return loss;
}// 反向传播，通过给定top blob误差梯度，计算bottom blob误差梯度
template <typename Dtype>
inline void Layer<Dtype>::Backward(const vector<Blob<Dtype>*>& top,const vector<bool>& propagate_down,const vector<Blob<Dtype>*>& bottom) {switch (Caffe::mode()) {case Caffe::CPU:Backward_cpu(top, propagate_down, bottom);break;case Caffe::GPU:Backward_gpu(top, propagate_down, bottom);break;default:LOG(FATAL) << "Unknown caffe mode.";}
}// Serialize LayerParameter to protocol buffer
// 序列化函数，将layer参数写入protobuf文件
template <typename Dtype>
void Layer<Dtype>::ToProto(LayerParameter* param, bool write_diff) {param->Clear();param->CopyFrom(layer_param_);param->clear_blobs();for (int i = 0; i < blobs_.size(); ++i) {blobs_[i]->ToProto(param->add_blobs(), write_diff);}
}}  // namespace caffe#endif  // CAFFE_LAYER_H_

在caffe.proto文件中，主要 有一个message是与layer 相关的，如下：

enum Phase { // layer状态：train、testTRAIN = 0;TEST = 1;
}// NOTE
// Update the next available ID when you add a new LayerParameter field.
//
// LayerParameter next available layer-specific ID: 137 (last added: reduction_param)
message LayerParameter { // Layer参数optional string name = 1; // the layer name， layer名字，可由自己任意制定optional string type = 2; // the layer type， layer类型，在具体层中写定，可以通过type()函数获得repeated string bottom = 3; // the name of each bottom blob, bottom名字，可有多个repeated string top = 4; // the name of each top blob，top名字，可有多个// The train / test phase for computation.optional Phase phase = 10; // layer状态：enum Phase {TRAIN = 0; TEST = 1;}// The amount of weight to assign each top blob in the objective.// Each layer assigns a default value, usually of either 0 or 1,// to each top blob.repeated float loss_weight = 5; // 个数必须与top blob一致// Specifies training parameters (multipliers on global learning constants,// and the name and other settings used for weight sharing).repeated ParamSpec param = 6; // train时用到的参数// The blobs containing the numeric parameters of the layer.repeated BlobProto blobs = 7; // blobs个数// Specifies on which bottoms the backpropagation should be skipped.// The size must be either 0 or equal to the number of bottoms.repeated bool propagate_down = 11; // 长度或者是0或者与bottoms个数一致// Rules controlling whether and when a layer is included in the network,// based on the current NetState.  You may specify a non-zero number of rules// to include OR exclude, but not both.  If no include or exclude rules are// specified, the layer is always included.  If the current NetState meets// ANY (i.e., one or more) of the specified rules, the layer is// included/excluded.repeated NetStateRule include = 8; // net state rulerepeated NetStateRule exclude = 9; // net state rule// Parameters for data pre-processing.optional TransformationParameter transform_param = 100; // 对data进行预处理包括缩放、剪切等// Parameters shared by loss layers.optional LossParameter loss_param = 101; // loss parameters// Layer type-specific parameters.//// Note: certain layers may have more than one computational engine// for their implementation. These layers include an Engine type and// engine parameter for selecting the implementation.// The default for the engine is set by the ENGINE switch at compile-time.// 具体layer参数optional AccuracyParameter accuracy_param = 102;optional ArgMaxParameter argmax_param = 103;optional ConcatParameter concat_param = 104;optional ContrastiveLossParameter contrastive_loss_param = 105;optional ConvolutionParameter convolution_param = 106;optional DataParameter data_param = 107;optional DropoutParameter dropout_param = 108;optional DummyDataParameter dummy_data_param = 109;optional EltwiseParameter eltwise_param = 110;optional ExpParameter exp_param = 111;optional FlattenParameter flatten_param = 135;optional HDF5DataParameter hdf5_data_param = 112;optional HDF5OutputParameter hdf5_output_param = 113;optional HingeLossParameter hinge_loss_param = 114;optional ImageDataParameter image_data_param = 115;optional InfogainLossParameter infogain_loss_param = 116;optional InnerProductParameter inner_product_param = 117;optional LogParameter log_param = 134;optional LRNParameter lrn_param = 118;optional MemoryDataParameter memory_data_param = 119;optional MVNParameter mvn_param = 120;optional PoolingParameter pooling_param = 121;optional PowerParameter power_param = 122;optional PReLUParameter prelu_param = 131;optional PythonParameter python_param = 130;optional ReductionParameter reduction_param = 136;optional ReLUParameter relu_param = 123;optional ReshapeParameter reshape_param = 133;optional SigmoidParameter sigmoid_param = 124;optional SoftmaxParameter softmax_param = 125;optional SPPParameter spp_param = 132;optional SliceParameter slice_param = 126;optional TanHParameter tanh_param = 127;optional ThresholdParameter threshold_param = 128;optional WindowDataParameter window_data_param = 129;
}

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