[转]caffe源码解析 — caffe.proto

港控/mmm° 2022-05-13 07:44 170阅读 0赞

[原文地址][Link 1]

## 引言 ##

要看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 的使用和原理][Google Protocol Buffer]  
**强烈推荐另外一篇极好的博文是：**[Protocol Buffer技术详解(C++实例) ][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][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

### **关于简单例子的描述** ###

我打算使用 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

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

命令将生成两个文件：  
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

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

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

\>writer 
    \>reader 
    101 
    Hello
     
      
       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

**<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> 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

**<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

**<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

**<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

### **三、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 snapshots
    message 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 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
      optional uint32 concat_dim = 1 [default = 1];
    }
    
    // Message that stores parameters used by ConvolutionLayer
    message 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 DataLayer
    message 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 DropoutLayer
    message DropoutParameter {
      optional float dropout_ratio = 1 [default = 0.5]; // dropout ratio
    }
    
    // Message that stores parameters used by HDF5DataLayer
    message HDF5DataParameter {
      // Specify the data source.
      optional string source = 1;
      // Specify the batch size.
      optional uint32 batch_size = 2;
    }
    
    // Message that stores parameters used by HDF5OutputLayer
    message HDF5OutputParameter {
      optional string file_name = 1;
    }
    
    // Message that stores parameters used by ImageDataLayer
    message 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 InfogainLossLayer
    message InfogainLossParameter {
      // Specify the infogain matrix source.
      optional string source = 1;
    }
    
    // Message that stores parameters used by InnerProductLayer
    message 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 LRNLayer
    message 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 MemoryDataLayer
    message MemoryDataParameter {
      optional uint32 batch_size = 1;
      optional uint32 channels = 2;
      optional uint32 height = 3;
      optional uint32 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
      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 PowerLayer
    message 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 WindowDataLayer
    message 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

[Link 1]: https://blog.csdn.net/qq_16055159/article/details/45115359
[Google Protocol Buffer]: http://www.ibm.com/developerworks/cn/linux/l-cn-gpb/
[Protocol Buffer_C_]: http://www.cnblogs.com/stephen-liu74/archive/2013/01/04/2842533.html
[http_code.google.com_p_protobuf_downloads_list]: http://code.google.com/p/protobuf/downloads/list