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_DIR  make  make check  make install
1
2
3
4
5
6
1
2
3
4
5
6

关于简单例子的描述

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

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

书写 .proto 文件

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

package lm;  message helloworld  {     required int32     id = 1;  // ID     required string    str = 2;  // str     optional int32     opt = 3;  //optional field  }
1
2
3
4
5
6
7
1
2
3
4
5
6
7

一个比较好的习惯是认真对待 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
1
1

命令将生成两个文件： 
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;   }           return 0;  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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);   …  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

\>writer \>reader 101 Hello
1
2
3
4
1
2
3
4

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;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14

<0> BlobProto

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

<1> Datum

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

<2> LayerParameter

message LayerParameter {  repeated string bottom = 2; //输入的blob的名字(string)  repeated string top = 3; //输出的blob的名字(string)  optional string 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的数值参数  repeated float blobs_lr = 7; //学习速率(repeated)，如果你想那个设置一个blob的学习速率，你需要设置所有blob的学习速率。  repeated float 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;}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

<3> NetParameter

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

<4> SolverParameter

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

三、caffe.proto源码

// Copyright 2014 BVLC and contributors.package caffe;message BlobProto {  optional int32 num = 1 [default = 0];  optional int32 channels = 2 [default = 0];  optional int32 height = 3 [default = 0];  optional int32 width = 4 [default = 0];  repeated float data = 5 [packed = true];  repeated float diff = 6 [packed = true];}// The BlobProtoVector is simply a way to pass multiple blobproto instances// around.message BlobProtoVector {  repeated BlobProto blobs = 1;}message Datum {  optional int32 channels = 1;  optional int32 height = 2;  optional int32 width = 3;  // the actual image data, in bytes  optional bytes data = 4;  optional int32 label = 5;  // Optionally, the datum could also hold float data.  repeated float float_data = 6;}message FillerParameter {  // The filler type.  optional string type = 1 [default = 'constant'];  optional float value = 2 [default = 0]; // the value in constant filler  optional float min = 3 [default = 0]; // the min value in uniform filler  optional float max = 4 [default = 1]; // the max value in uniform filler  optional float mean = 5 [default = 0]; // the mean value in Gaussian filler  optional float 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.  optional int32 sparse = 7 [default = -1];}message NetParameter {  optional string name = 1; // consider giving the network a name  repeated LayerParameter layers = 2; // a bunch of layers.  // The input blobs to the network.  repeated string 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.  repeated int32 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.  optional bool force_backward = 5 [default = false];}message SolverParameter {  optional string train_net = 1; // The proto file for the training net.  optional string test_net = 2; // The proto file for the testing net.  // The number of iterations for each testing phase.  optional int32 test_iter = 3 [default = 0];  // The number of iterations between two testing phases.  optional int32 test_interval = 4 [default = 0];  optional bool test_compute_loss = 19 [default = false];  optional float base_lr = 5; // The base learning rate  // the number of iterations between displaying info. If display = 0, no info  // will be displayed.  optional int32 display = 6;  optional int32 max_iter = 7; // the maximum number of iterations  optional string lr_policy = 8; // The learning rate decay policy.  optional float gamma = 9; // The parameter to compute the learning rate.  optional float power = 10; // The parameter to compute the learning rate.  optional float momentum = 11; // The momentum value.  optional float weight_decay = 12; // The weight decay.  optional int32 stepsize = 13; // the stepsize for learning rate policy "step"  optional int32 snapshot = 14 [default = 0]; // The snapshot interval  optional string 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.  optional bool 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.  optional int32 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.  optional int64 random_seed = 20 [default = -1];}// A message that stores the solver snapshotsmessage SolverState {  optional int32 iter = 1; // The current iteration  optional string 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 {  repeated string bottom = 2; // the name of the bottom blobs  repeated string top = 3; // the name of the top blobs  optional string 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.  repeated float blobs_lr = 7;  // The weight decay that is multiplied on the global weight decay.  repeated float 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 ConcatLayermessage 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  optional uint32 concat_dim = 1 [default = 1];}// Message that stores parameters used by ConvolutionLayermessage ConvolutionParameter {  optional uint32 num_output = 1; // The number of outputs for the layer  optional bool bias_term = 2 [default = true]; // whether to have bias terms  optional uint32 pad = 3 [default = 0]; // The padding size  optional uint32 kernel_size = 4; // The kernel size  optional uint32 group = 5 [default = 1]; // The group size for group conv  optional uint32 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 DataLayermessage DataParameter {  // Specify the data source.  optional string 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.  optional float scale = 2 [default = 1];  optional string mean_file = 3;  // Specify the batch size.  optional uint32 batch_size = 4;  // Specify if we would like to randomly crop an image.  optional uint32 crop_size = 5 [default = 0];  // Specify if we want to randomly mirror data.  optional bool 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.  optional uint32 rand_skip = 7 [default = 0];}// Message that stores parameters used by DropoutLayermessage DropoutParameter {  optional float dropout_ratio = 1 [default = 0.5]; // dropout ratio}// Message that stores parameters used by HDF5DataLayermessage HDF5DataParameter {  // Specify the data source.  optional string source = 1;  // Specify the batch size.  optional uint32 batch_size = 2;}// Message that stores parameters used by HDF5OutputLayermessage HDF5OutputParameter {  optional string file_name = 1;}// Message that stores parameters used by ImageDataLayermessage ImageDataParameter {  // Specify the data source.  optional string 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.  optional float scale = 2 [default = 1];  optional string mean_file = 3;  // Specify the batch size.  optional uint32 batch_size = 4;  // Specify if we would like to randomly crop an image.  optional uint32 crop_size = 5 [default = 0];  // Specify if we want to randomly mirror data.  optional bool 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.  optional uint32 rand_skip = 7 [default = 0];  // Whether or not ImageLayer should shuffle the list of files at every epoch.  optional bool shuffle = 8 [default = false];  // It will also resize images if new_height or new_width are not zero.  optional uint32 new_height = 9 [default = 0];  optional uint32 new_width = 10 [default = 0];}// Message that stores parameters InfogainLossLayermessage InfogainLossParameter {  // Specify the infogain matrix source.  optional string source = 1;}// Message that stores parameters used by InnerProductLayermessage InnerProductParameter {  optional uint32 num_output = 1; // The number of outputs for the layer  optional bool 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 LRNLayermessage LRNParameter {  optional uint32 local_size = 1 [default = 5];  optional float alpha = 2 [default = 1.];  optional float 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 MemoryDataLayermessage MemoryDataParameter {  optional uint32 batch_size = 1;  optional uint32 channels = 2;  optional uint32 height = 3;  optional uint32 width = 4;}// Message that stores parameters used by PoolingLayermessage PoolingParameter {  enum PoolMethod {    MAX = 0;    AVE = 1;    STOCHASTIC = 2;  }  optional PoolMethod pool = 1 [default = MAX]; // The pooling method  optional uint32 kernel_size = 2; // The kernel size  optional uint32 stride = 3 [default = 1]; // The stride  // The padding size -- currently implemented only for average pooling.  optional uint32 pad = 4 [default = 0];}// Message that stores parameters used by PowerLayermessage PowerParameter {  // PowerLayer computes outputs y = (shift + scale * x) ^ power.  optional float power = 1 [default = 1.0];  optional float scale = 2 [default = 1.0];  optional float shift = 3 [default = 0.0];}// Message that stores parameters used by WindowDataLayermessage WindowDataParameter {  // Specify the data source.  optional string 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.  optional float scale = 2 [default = 1];  optional string mean_file = 3;  // Specify the batch size.  optional uint32 batch_size = 4;  // Specify if we would like to randomly crop an image.  optional uint32 crop_size = 5 [default = 0];  // Specify if we want to randomly mirror data.  optional bool mirror = 6 [default = false];  // Foreground (object) overlap threshold  optional float fg_threshold = 7 [default = 0.5];  // Background (non-object) overlap threshold  optional float bg_threshold = 8 [default = 0.5];  // Fraction of batch that should be foreground objects  optional float fg_fraction = 9 [default = 0.25];  // Amount of contextual padding to add around a window  // (used only by the window_data_layer)  optional uint32 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  optional string 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 {  optional string name = 1; // the layer name  optional string type = 2; // the string to specify the layer type  // Parameters to specify layers with inner products.  optional uint32 num_output = 3; // The number of outputs for the layer  optional bool 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  optional uint32 pad = 7 [default = 0]; // The padding size  optional uint32 kernelsize = 8; // The kernel size  optional uint32 group = 9 [default = 1]; // The group size for group conv  optional uint32 stride = 10 [default = 1]; // The stride  enum PoolMethod {    MAX = 0;    AVE = 1;    STOCHASTIC = 2;  }  optional PoolMethod pool = 11 [default = MAX]; // The pooling method  optional float dropout_ratio = 12 [default = 0.5]; // dropout ratio  optional uint32 local_size = 13 [default = 5]; // for local response norm  optional float alpha = 14 [default = 1.]; // for local response norm  optional float beta = 15 [default = 0.75]; // for local response norm  // For data layers, specify the data source  optional string 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.  optional float scale = 17 [default = 1];  optional string meanfile = 18;  // For data layers, specify the batch size.  optional uint32 batchsize = 19;  // For data layers, specify if we would like to randomly crop an image.  optional uint32 cropsize = 20 [default = 0];  // For data layers, specify if we want to randomly mirror data.  optional bool 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.  repeated float blobs_lr = 51;  // The weight decay that is multiplied on the global weight decay.  repeated float 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.  optional uint32 rand_skip = 53 [default = 0];  // Fields related to detection (det_*)  // foreground (object) overlap threshold  optional float det_fg_threshold = 54 [default = 0.5];  // background (non-object) overlap threshold  optional float det_bg_threshold = 55 [default = 0.5];  // Fraction of batch that should be foreground objects  optional float det_fg_fraction = 56 [default = 0.25];  // optional bool OBSOLETE_can_clobber = 57 [default = true];  // Amount of contextual padding to add around a window  // (used only by the window_data_layer)  optional uint32 det_context_pad = 58 [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  optional string det_crop_mode = 59 [default = "warp"];  // For ReshapeLayer, one needs to specify the new dimensions.  optional int32 new_num = 60 [default = 0];  optional int32 new_channels = 61 [default = 0];  optional int32 new_height = 62 [default = 0];  optional int32 new_width = 63 [default = 0];  // Whether or not ImageLayer should shuffle the list of files at every epoch.  // It will also resize images if new_height or new_width are not zero.  optional bool shuffle_images = 64 [default = false];  // For ConcatLayer, one needs to specify the dimension for concatenation, and  // the other dimensions must be the same for all the bottom blobs.  // By default it will concatenate blobs along the channels dimension.  optional uint32 concat_dim = 65 [default = 1];  optional HDF5OutputParameter hdf5_output_param = 1001;}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448