caffe源码解析 — caffe.proto

引言

要看caffe源码，我认为首先应该看的就是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

正文

一、什么是protocol buffer

以下内容摘自：Google Protocol Buffer 的使用和原理
强烈推荐另外一篇极好的博文是：Protocol Buffer技术详解(C++实例)

简介

什么是 Google Protocol Buffer？ 假如您在网上搜索，应该会得到类似这样的文字介绍：
Google Protocol Buffer( 简称 Protobuf) 是 Google 公司内部的混合语言数据标准，目前已经正在使用的有超过 48,162 种报文格式定义和超过 12,183 个 .proto 文件。他们用于 RPC 系统和持续数据存储系统。
Protocol Buffers 是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或 RPC 数据交换格式。可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。目前提供了 C++、Java、Python 三种语言的 API。
或许您和我一样，在第一次看完这些介绍后还是不明白 Protobuf 究竟是什么，那么我想一个简单的例子应该比较有助于理解它。

一个简单的例子

安装 Google Protocol Buffer
在网站http://code.google.com/p/protobuf/downloads/list上可以下载 Protobuf 的源代码。然后解压编译安装便可以使用它了。
安装步骤如下所示：

 tar -xzf protobuf-2.1.0.tar.gz 
 cd protobuf-2.1.0 
 ./configure --prefix=$INSTALL_DIRmakemake checkmake install

关于简单例子的描述

我打算使用 Protobuf 和 C++ 开发一个十分简单的例子程序。
该程序由两部分组成。第一部分被称为 Writer，第二部分叫做 Reader。
Writer 负责将一些结构化的数据写入一个磁盘文件，Reader 则负责从该磁盘文件中读取结构化数据并打印到屏幕上。
准备用于演示的结构化数据是 HelloWorld，它包含两个基本数据：

• ID，为一个整数类型的数据
• Str，这是一个字符串

书写 .proto 文件

首先我们需要编写一个 proto 文件，定义我们程序中需要处理的结构化数据，在 protobuf 的术语中，结构化数据被称为 Message。proto 文件非常类似 java 或者 C 语言的数据定义。代码清单 1 显示了例子应用中的 proto 文件内容。
清单 1. proto 文件

package lm; 
 message helloworld 
 { 
    requiredint32     id = 1;// ID
    requiredstring    str = 2;// str
    optionalint32     opt = 3;//optional field
 }

一个比较好的习惯是认真对待 proto 文件的文件名。比如将命名规则定于
packageName.MessageName.proto
在上例中，package 名字叫做 lm，定义了一个消息 helloworld，该消息有三个成员，类型为 int32 的 id，另一个为类型为 string 的成员 str。opt 是一个可选的成员，即消息中可以不包含该成员。

编译 .proto 文件

写好 proto 文件之后就可以用 Protobuf 编译器将该文件编译成目标语言了。本例中我们将使用 C++。
假设您的 proto 文件存放在 $SRC_DIR 下面，您也想把生成的文件放在同一个目录下，则可以使用如下命令：

protoc-I=$SRC_DIR--cpp_out=$DST_DIR$SRC_DIR/addressbook.proto

命令将生成两个文件：
lm.helloworld.pb.h ， 定义了 C++ 类的头文件
lm.helloworld.pb.cc ， C++ 类的实现文件
在生成的头文件中，定义了一个 C++ 类 helloworld，后面的 Writer 和 Reader 将使用这个类来对消息进行操作。诸如对消息的成员进行赋值，将消息序列化等等都有相应的方法。

编写 writer 和 Reader

如前所述，Writer将把一个结构化数据写入磁盘，以便其他人来读取。假如我们不使用 Protobuf，其实也有许多的选择。一个可能的方法是将数据转换为字符串，然后将字符串写入磁盘。转换为字符串的方法可以使用sprintf()，这非常简单。数字123可以变成字符串“123”。
这样做似乎没有什么不妥，但是仔细考虑一下就会发现，这样的做法对写 Reader 的那个人的要求比较高，Reader 的作者必须了 Writer 的细节。比如”123”可以是单个数字 123，但也可以是三个数字 1,2 和 3，等等。这么说来，我们还必须让 Writer 定义一种分隔符一样的字符，以便 Reader 可以正确读取。但分隔符也许还会引起其他的什么问题。最后我们发现一个简单的 Helloworld 也需要写许多处理消息格式的代码。
如果使用 Protobuf，那么这些细节就可以不需要应用程序来考虑了。
使用 Protobuf，Writer 的工作很简单，需要处理的结构化数据由 .proto 文件描述，经过上一节中的编译过程后，该数据化结构对应了一个 C++ 的类，并定义在 lm.helloworld.pb.h 中。对于本例，类名为 lm::helloworld。
Writer 需要 include 该头文件，然后便可以使用这个类了。
现在，在 Writer 代码中，将要存入磁盘的结构化数据由一个 lm::helloworld 类的对象表示，它提供了一系列的 get/set 函数用来修改和读取结构化数据中的数据成员，或者叫 field。
当我们需要将该结构化数据保存到磁盘上时，类 lm::helloworld 已经提供相应的方法来把一个复杂的数据变成一个字节序列，我们可以将这个字节序列写入磁盘。
对于想要读取这个数据的程序来说，也只需要使用类 lm::helloworld 的相应反序列化方法来将这个字节序列重新转换会结构化数据。这同我们开始时那个“123”的想法类似，不过 Protobuf 想的远远比我们那个粗糙的字符串转换要全面，因此，我们不如放心将这类事情交给 Protobuf 吧。
程序清单 2 演示了 Writer 的主要代码，您一定会觉得很简单吧？
清单 2. Writer 的主要代码

#include"lm.helloworld.pb.h"
…

 int main(void) 
 { 

  lm::helloworld msg1; 
  msg1.set_id(101); 
  msg1.set_str(“hello”);// Write the new address book back to disk.
  fstream output("./log", ios::out| ios::trunc| ios::binary);if (!msg1.SerializeToOstream(&output)) { 
      cerr<<"Failed to write msg."<< endl;return-1; 
  }return0; 
 }

Msg1 是一个 helloworld 类的对象，set_id() 用来设置 id 的值。SerializeToOstream 将对象序列化后写入一个 fstream 流。
代码清单 3 列出了 reader 的主要代码。
清单 3. Reader

#include "lm.helloworld.pb.h"
…void ListMsg(const lm::helloworld & msg) {cout << msg.id() << endl;cout << msg.str() << endl; 
 }int main(int argc,char* argv[]) { 

  lm::helloworld msg1; 

  { 
    fstream input("./log", ios::in | ios::binary);if (!msg1.ParseFromIstream(&input)) {cerr <<"Failed to parse address book." << endl;return -1; 
    } 
  } 

  ListMsg(msg1); 
  … 
 }

同样，Reader 声明类 helloworld 的对象 msg1，然后利用 ParseFromIstream 从一个 fstream 流中读取信息并反序列化。此后，ListMsg 中采用 get 方法读取消息的内部信息，并进行打印输出操作。
运行结果
运行 Writer 和 Reader 的结果如下：

\>writer\>reader 
101 
Hello

Reader 读取文件 log 中的序列化信息并打印到屏幕上。本文中所有的例子代码都可以在附件中下载。您可以亲身体验一下。
这个例子本身并无意义，但只要您稍加修改就可以将它变成更加有用的程序。比如将磁盘替换为网络 socket，那么就可以实现基于网络的数据交换任务。而存储和交换正是 Protobuf 最有效的应用领域。

二、caffe.proto中的几个重要数据类型

看完了上面关于protocol buffer的介绍，大家应该可以知道其实caffe.pb.cc里面的东西都是从caffe.proto编译而来的，无非就是一些关于这些数据结构（类）的标准化操作，比如

void CopyFrom();void MergeFrom();void CopyFrom();void MergeFrom;void Clear();bool IsInitialized()const;int ByteSize()const;bool MergePartialFromCodedStream();void SerializeWithCachedSizes()const;
  SerializeWithCachedSizesToArray()const;int GetCachedSize()void SharedCtor();void SharedDtor();void SetCachedSize()const;

<0> BlobProto

message BlobProto {//blob的属性以及blob中的数据(data\diff)
  optionalint32 num =1 [default =0];
  optionalint32 channels =2 [default =0];
  optionalint32 height =3 [default =0];
  optionalint32 width =4 [default =0];
  repeatedfloat data =5 [packed =true];
  repeatedfloat diff =6 [packed =true];
}

<1> Datum

  message Datum {
  optionalint32 channels =1;
  optionalint32 height =2;
  optionalint32 width =3;
  optional bytes data =4;//真实的图像数据，以字节存储(bytes)
  optionalint32 label =5;
  repeatedfloat float_data =6;//datum也能存float类型的数据(float)
}

<2> LayerParameter

message LayerParameter {
  repeatedstring bottom =2;//输入的blob的名字(string)
  repeatedstring top =3;//输出的blob的名字(string)
  optionalstring name =4;//层的名字enum LayerType {//层的枚举（enum，和c++中的enum一样）
    NONE =0;
    ACCURACY =1;
    BNLL =2;
    CONCAT =3;
    CONVOLUTION =4;
    DATA =5;
    DROPOUT =6;
    EUCLIDEAN_LOSS =7;
    ELTWISE_PRODUCT =25;
    FLATTEN =8;
    HDF5_DATA =9;
    HDF5_OUTPUT =10;
    HINGE_LOSS =28;
    IM2COL =11;
    IMAGE_DATA =12;
    INFOGAIN_LOSS =13;
    INNER_PRODUCT =14;
    LRN =15;
    MEMORY_DATA =29;
    MULTINOMIAL_LOGISTIC_LOSS =16;
    POOLING =17;
    POWER =26;
    RELU =18;
    SIGMOID =19;
    SIGMOID_CROSS_ENTROPY_LOSS =27;
    SOFTMAX =20;
    SOFTMAX_LOSS =21;
    SPLIT =22;
    TANH =23;
    WINDOW_DATA =24;
  }
  optional LayerType type =5;// 层的类型
  repeated BlobProto blobs =6;//blobs的数值参数
  repeatedfloat blobs_lr =7;//学习速率(repeated)，如果你想那个设置一个blob的学习速率，你需要设置所有blob的学习速率。
  repeatedfloat weight_decay =8;//权值衰减(repeated)// 相对于某一特定层的参数(optional)
  optional ConcatParameter concat_param =9;
  optional ConvolutionParameter convolution_param =10;
  optional DataParameter data_param =11;
  optional DropoutParameter dropout_param =12;
  optional HDF5DataParameter hdf5_data_param =13;
  optional HDF5OutputParameter hdf5_output_param =14;
  optional ImageDataParameter image_data_param =15;
  optional InfogainLossParameter infogain_loss_param =16;
  optional InnerProductParameter inner_product_param =17;
  optional LRNParameter lrn_param =18;
  optional MemoryDataParameter memory_data_param =22;
  optional PoolingParameter pooling_param =19;
  optional PowerParameter power_param =21;
  optional WindowDataParameter window_data_param =20;
  optional V0LayerParameter layer =1;
}

<3> NetParameter

message NetParameter {
  optionalstring name =1;//网络的名字
  repeated LayerParameter layers =2;//repeated类似于数组
  repeatedstring input =3;//输入层blob的名字
  repeatedint32 input_dim =4;//输入层blob的维度，应该等于(4*#input)
  optionalbool force_backward =5 [default =false];//网络是否进行反向传播。如果设置为否，则由网络的结构和学习速率来决定是否进行反向传播。
}

<4> SolverParameter

message SolverParameter {
  optionalstring train_net =1;// 训练网络的proto file
  optionalstring test_net =2;// 测试网络的proto file
  optionalint32 test_iter =3 [default =0];// 每次测试时的迭代次数
  optionalint32 test_interval =4 [default =0];// 两次测试的间隔迭代次数
  optionalbool test_compute_loss =19 [default =false];
  optionalfloat base_lr =5;// 基本学习率
  optionalint32 display =6;// 两次显示的间隔迭代次数
  optionalint32 max_iter =7;// 最大迭代次数
  optionalstring lr_policy =8;// 学习速率衰减方式
  optionalfloat gamma =9;// 关于梯度下降的一个参数
  optionalfloat power =10;// 计算学习率的一个参数
  optionalfloat momentum =11;// 动量
  optionalfloat weight_decay =12;// 权值衰减
  optionalint32 stepsize =13;// 学习速率的衰减步长
  optionalint32 snapshot =14 [default =0];// snapshot的间隔
  optionalstring snapshot_prefix =15;// snapshot的前缀
  optionalbool snapshot_diff =16 [default =false];// 是否对于 diff 进行 snapshotenum SolverMode { CPU=0; GPU=1;
  }
  optional SolverMode solver_mode =17 [default = GPU];// solver的模式，默认为GPU
  optionalint32 device_id =18 [default =0];// GPU的ID
  optionalint64 random_seed =20 [default = -1];// 随机数种子
}

三、caffe.proto源码

// Copyright 2014 BVLC and contributors.
package caffe;

message BlobProto {
  optionalint32 num =1 [default =0];
  optionalint32 channels =2 [default =0];
  optionalint32 height =3 [default =0];
  optionalint32 width =4 [default =0];
  repeatedfloat data =5 [packed =true];
  repeatedfloat diff =6 [packed =true];
}// The BlobProtoVector is simply a way to pass multiple blobproto instances// around.
message BlobProtoVector {
  repeated BlobProto blobs =1;
}

message Datum {
  optionalint32 channels =1;
  optionalint32 height =2;
  optionalint32 width =3;// the actual image data, in bytes
  optional bytes data =4;
  optionalint32 label =5;// Optionally, the datum could also hold float data.
  repeatedfloat float_data =6;
}

message FillerParameter {// The filler type.
  optionalstring type =1 [default ='constant'];
  optionalfloat value =2 [default =0];// the value in constant filler
  optionalfloat min =3 [default =0];// the min value in uniform filler
  optionalfloat max =4 [default =1];// the max value in uniform filler
  optionalfloat mean =5 [default =0];// the mean value in Gaussian filler
  optionalfloat std =6 [default =1];// the std value in Gaussian filler// The expected number of non-zero input weights for a given output in// Gaussian filler -- the default -1 means don't perform sparsification.
  optionalint32 sparse =7 [default = -1];
}

message NetParameter {
  optionalstring name =1;// consider giving the network a name
  repeated LayerParameter layers =2;// a bunch of layers.// The input blobs to the network.
  repeatedstring input =3;// The dim of the input blobs. For each input blob there should be four// values specifying the num, channels, height and width of the input blob.// Thus, there should be a total of (4 * #input) numbers.
  repeatedint32 input_dim =4;// Whether the network will force every layer to carry out backward operation.// If set False, then whether to carry out backward is determined// automatically according to the net structure and learning rates.
  optionalbool force_backward =5 [default =false];
}

message SolverParameter {
  optionalstring train_net =1;// The proto file for the training net.
  optionalstring test_net =2;// The proto file for the testing net.// The number of iterations for each testing phase.
  optionalint32 test_iter =3 [default =0];// The number of iterations between two testing phases.
  optionalint32 test_interval =4 [default =0];
  optionalbool test_compute_loss =19 [default =false];
  optionalfloat base_lr =5;// The base learning rate// the number of iterations between displaying info. If display = 0, no info// will be displayed.
  optionalint32 display =6;
  optionalint32 max_iter =7;// the maximum number of iterations
  optionalstring lr_policy =8;// The learning rate decay policy.
  optionalfloat gamma =9;// The parameter to compute the learning rate.
  optionalfloat power =10;// The parameter to compute the learning rate.
  optionalfloat momentum =11;// The momentum value.
  optionalfloat weight_decay =12;// The weight decay.
  optionalint32 stepsize =13;// the stepsize for learning rate policy "step"
  optionalint32 snapshot =14 [default =0];// The snapshot interval
  optionalstring snapshot_prefix =15;// The prefix for the snapshot.// whether to snapshot diff in the results or not. Snapshotting diff will help// debugging but the final protocol buffer size will be much larger.
  optionalbool snapshot_diff =16 [default =false];// the mode solver will use: 0 for CPU and 1 for GPU. Use GPU in default.enum SolverMode { CPU=0; GPU=1;
  }
  optional SolverMode solver_mode =17 [default = GPU];// the device_id will that be used in GPU mode. Use device_id = 0 in default.
  optionalint32 device_id =18 [default =0];// If non-negative, the seed with which the Solver will initialize the Caffe// random number generator -- useful for reproducible results. Otherwise,// (and by default) initialize using a seed derived from the system clock.
  optionalint64 random_seed =20 [default = -1];
}// A message that stores the solver snapshots
message SolverState {
  optionalint32 iter =1;// The current iteration
  optionalstring learned_net =2;// The file that stores the learned net.
  repeated BlobProto history =3;// The history for sgd solvers
}// Update the next available ID when you add a new LayerParameter field.//// LayerParameter next available ID: 23 (last added: memory_data_param)
message LayerParameter {
  repeatedstring bottom =2;// the name of the bottom blobs
  repeatedstring top =3;// the name of the top blobs
  optionalstring name =4;// the layer name// Add new LayerTypes to the enum below in lexicographical order (other than// starting with NONE), starting with the next available ID in the comment// line above the enum. Update the next available ID when you add a new// LayerType.//// LayerType next available ID: 30 (last added: MEMORY_DATA)enum LayerType {// "NONE" layer type is 0th enum element so that we don't cause confusion// by defaulting to an existent LayerType (instead, should usually error if// the type is unspecified). NONE=0; ACCURACY=1; BNLL=2; CONCAT=3; CONVOLUTION=4; DATA=5; DROPOUT=6; EUCLIDEAN_LOSS=7; ELTWISE_PRODUCT=25; FLATTEN=8;
    HDF5_DATA =9;
    HDF5_OUTPUT =10; HINGE_LOSS=28;
    IM2COL =11; IMAGE_DATA=12; INFOGAIN_LOSS=13; INNER_PRODUCT=14; LRN=15; MEMORY_DATA=29; MULTINOMIAL_LOGISTIC_LOSS=16; POOLING=17; POWER=26; RELU=18; SIGMOID=19; SIGMOID_CROSS_ENTROPY_LOSS=27; SOFTMAX=20; SOFTMAX_LOSS=21; SPLIT=22; TANH=23; WINDOW_DATA=24;
  }
  optional LayerType type =5;// the layer type from the enum above// The blobs containing the numeric parameters of the layer
  repeated BlobProto blobs =6;// The ratio that is multiplied on the global learning rate. If you want to// set the learning ratio for one blob, you need to set it for all blobs.
  repeatedfloat blobs_lr =7;// The weight decay that is multiplied on the global weight decay.
  repeatedfloat weight_decay =8;// Parameters for particular layer types.
  optional ConcatParameter concat_param =9;
  optional ConvolutionParameter convolution_param =10;
  optional DataParameter data_param =11;
  optional DropoutParameter dropout_param =12;
  optional HDF5DataParameter hdf5_data_param =13;
  optional HDF5OutputParameter hdf5_output_param =14;
  optional ImageDataParameter image_data_param =15;
  optional InfogainLossParameter infogain_loss_param =16;
  optional InnerProductParameter inner_product_param =17;
  optional LRNParameter lrn_param =18;
  optional MemoryDataParameter memory_data_param =22;
  optional PoolingParameter pooling_param =19;
  optional PowerParameter power_param =21;
  optional WindowDataParameter window_data_param =20;// DEPRECATED: The layer parameters specified as a V0LayerParameter.// This should never be used by any code except to upgrade to the new// LayerParameter specification.
  optional V0LayerParameter layer =1;
}// Message that stores parameters used by ConcatLayer
message ConcatParameter {// Concat Layer needs to specify the dimension along the concat will happen,// the other dimensions must be the same for all the bottom blobs// By default it will concatenate blobs along channels dimension
  optionaluint32 concat_dim =1 [default =1];
}// Message that stores parameters used by ConvolutionLayer
message ConvolutionParameter {
  optionaluint32 num_output =1;// The number of outputs for the layer
  optionalbool bias_term =2 [default =true];// whether to have bias terms
  optionaluint32 pad =3 [default =0];// The padding size
  optionaluint32 kernel_size =4;// The kernel size
  optionaluint32 group =5 [default =1];// The group size for group conv
  optionaluint32 stride =6 [default =1];// The stride
  optional FillerParameter weight_filler =7;// The filler for the weight
  optional FillerParameter bias_filler =8;// The filler for the bias
}// Message that stores parameters used by DataLayer
message DataParameter {// Specify the data source.
  optionalstring source =1;// For data pre-processing, we can do simple scaling and subtracting the// data mean, if provided. Note that the mean subtraction is always carried// out before scaling.
  optionalfloat scale =2 [default =1];
  optionalstring mean_file =3;// Specify the batch size.
  optionaluint32 batch_size =4;// Specify if we would like to randomly crop an image.
  optionaluint32 crop_size =5 [default =0];// Specify if we want to randomly mirror data.
  optionalbool mirror =6 [default =false];// The rand_skip variable is for the data layer to skip a few data points// to avoid all asynchronous sgd clients to start at the same point. The skip// point would be set as rand_skip * rand(0,1). Note that rand_skip should not// be larger than the number of keys in the leveldb.
  optionaluint32 rand_skip =7 [default =0];
}// Message that stores parameters used by DropoutLayer
message DropoutParameter {
  optionalfloat dropout_ratio =1 [default =0.5];// dropout ratio
}// Message that stores parameters used by HDF5DataLayer
message HDF5DataParameter {// Specify the data source.
  optionalstring source =1;// Specify the batch size.
  optionaluint32 batch_size =2;
}// Message that stores parameters used by HDF5OutputLayer
message HDF5OutputParameter {
  optionalstring file_name =1;
}// Message that stores parameters used by ImageDataLayer
message ImageDataParameter {// Specify the data source.
  optionalstring source =1;// For data pre-processing, we can do simple scaling and subtracting the// data mean, if provided. Note that the mean subtraction is always carried// out before scaling.
  optionalfloat scale =2 [default =1];
  optionalstring mean_file =3;// Specify the batch size.
  optionaluint32 batch_size =4;// Specify if we would like to randomly crop an image.
  optionaluint32 crop_size =5 [default =0];// Specify if we want to randomly mirror data.
  optionalbool mirror =6 [default =false];// The rand_skip variable is for the data layer to skip a few data points// to avoid all asynchronous sgd clients to start at the same point. The skip// point would be set as rand_skip * rand(0,1). Note that rand_skip should not// be larger than the number of keys in the leveldb.
  optionaluint32 rand_skip =7 [default =0];// Whether or not ImageLayer should shuffle the list of files at every epoch.
  optionalbool shuffle =8 [default =false];// It will also resize images if new_height or new_width are not zero.
  optionaluint32 new_height =9 [default =0];
  optionaluint32 new_width =10 [default =0];
}// Message that stores parameters InfogainLossLayer
message InfogainLossParameter {// Specify the infogain matrix source.
  optionalstring source =1;
}// Message that stores parameters used by InnerProductLayer
message InnerProductParameter {
  optionaluint32 num_output =1;// The number of outputs for the layer
  optionalbool bias_term =2 [default =true];// whether to have bias terms
  optional FillerParameter weight_filler =3;// The filler for the weight
  optional FillerParameter bias_filler =4;// The filler for the bias
}// Message that stores parameters used by LRNLayer
message LRNParameter {
  optionaluint32 local_size =1 [default =5];
  optionalfloat alpha =2 [default =1.];
  optionalfloat beta =3 [default =0.75];enum NormRegion { ACROSS_CHANNELS=0; WITHIN_CHANNEL=1;
  }
  optional NormRegion norm_region =4 [default = ACROSS_CHANNELS];
}// Message that stores parameters used by MemoryDataLayer
message MemoryDataParameter {
  optionaluint32 batch_size =1;
  optionaluint32 channels =2;
  optionaluint32 height =3;
  optionaluint32 width =4;
}// Message that stores parameters used by PoolingLayer
message PoolingParameter {enum PoolMethod { MAX=0; AVE=1; STOCHASTIC=2;
  }
  optional PoolMethod pool =1 [default = MAX];// The pooling method
  optionaluint32 kernel_size =2;// The kernel size
  optionaluint32 stride =3 [default =1];// The stride// The padding size -- currently implemented only for average pooling.
  optionaluint32 pad =4 [default =0];
}// Message that stores parameters used by PowerLayer
message PowerParameter {// PowerLayer computes outputs y = (shift + scale * x) ^ power.
  optionalfloat power =1 [default =1.0];
  optionalfloat scale =2 [default =1.0];
  optionalfloat shift =3 [default =0.0];
}// Message that stores parameters used by WindowDataLayer
message WindowDataParameter {// Specify the data source.
  optionalstring source =1;// For data pre-processing, we can do simple scaling and subtracting the// data mean, if provided. Note that the mean subtraction is always carried// out before scaling.
  optionalfloat scale =2 [default =1];
  optionalstring mean_file =3;// Specify the batch size.
  optionaluint32 batch_size =4;// Specify if we would like to randomly crop an image.
  optionaluint32 crop_size =5 [default =0];// Specify if we want to randomly mirror data.
  optionalbool mirror =6 [default =false];// Foreground (object) overlap threshold
  optionalfloat fg_threshold =7 [default =0.5];// Background (non-object) overlap threshold
  optionalfloat bg_threshold =8 [default =0.5];// Fraction of batch that should be foreground objects
  optionalfloat fg_fraction =9 [default =0.25];// Amount of contextual padding to add around a window// (used only by the window_data_layer)
  optionaluint32 context_pad =10 [default =0];// Mode for cropping out a detection window// warp: cropped window is warped to a fixed size and aspect ratio// square: the tightest square around the window is cropped
  optionalstring crop_mode =11 [default ="warp"];
}// DEPRECATED: V0LayerParameter is the old way of specifying layer parameters// in Caffe.  We keep this message type around for legacy support.
message V0LayerParameter {
  optionalstring name =1;// the layer name
  optionalstring type =2;// the string to specify the layer type// Parameters to specify layers with inner products.
  optionaluint32 num_output =3;// The number of outputs for the layer
  optionalbool biasterm =4 [default =true];// whether to have bias terms
  optional FillerParameter weight_filler =5;// The filler for the weight
  optional FillerParameter bias_filler =6;// The filler for the bias

  optionaluint32 pad =7 [default =0];// The padding size
  optionaluint32 kernelsize =8;// The kernel size
  optionaluint32 group =9 [default =1];// The group size for group conv
  optionaluint32 stride =10 [default =1];// The strideenum PoolMethod { MAX=0; AVE=1; STOCHASTIC=2;
  }
  optional PoolMethod pool =11 [default = MAX];// The pooling method
  optionalfloat dropout_ratio =12 [default =0.5];// dropout ratio

  optionaluint32 local_size =13 [default =5];// for local response norm
  optionalfloat alpha =14 [default =1.];// for local response norm
  optionalfloat beta =15 [default =0.75];// for local response norm// For data layers, specify the data source
  optionalstring source =16;// For data pre-processing, we can do simple scaling and subtracting the// data mean, if provided. Note that the mean subtraction is always carried// out before scaling.
  optionalfloat scale =17 [default =1];
  optionalstring meanfile =18;// For data layers, specify the batch size.
  optionaluint32 batchsize =19;// For data layers, specify if we would like to randomly crop an image.
  optionaluint32 cropsize =20 [default =0];// For data layers, specify if we want to randomly mirror data.
  optionalbool mirror =21 [default =false];// The blobs containing the numeric parameters of the layer
  repeated BlobProto blobs =50;// The ratio that is multiplied on the global learning rate. If you want to// set the learning ratio for one blob, you need to set it for all blobs.
  repeatedfloat blobs_lr =51;// The weight decay that is multiplied on the global weight decay.
  repeatedfloat weight_decay =52;// The rand_skip variable is for the data layer to skip a few data points// to avoid all asynchronous sgd clients to start at the same point. The skip// point would be set as rand_skip * rand(0,1). Note that rand_skip should not// be larger than the number of keys in the leveldb.
  optionaluint32 rand_skip =53 [default =0];// Fields related to detection (det_*)// foreground (object) overlap threshold
  optionalfloat