Caffe源码解读（一）：caffe.proto（上）

caffe.proto文件位于 ..\caffe-fast-rcnn\src\caffe\proto文件目录下 ，根目录为 py_faster_rcnn文件夹

syntax = "proto2";

package caffe;

//   repeated  required  optional 

//    类似数组     必要的      可选的

// Specifies the shape (dimensions) of a Blob.

message BlobShape {

  repeated int64 dim = 1 [packed = true];

}

message BlobProto {

  optional BlobShape shape = 7; //下文中替代4D描述符的结构

  repeated float data = 5 [packed = true];

  repeated float diff = 6 [packed = true];

  repeated double double_data = 8 [packed = true];

  repeated double double_diff = 9 [packed = true];

  // 4D dimensions -- deprecated.  Use "shape" instead.

  // 4维的描述方式舍弃掉，改用"BlobShape"结构替代

  optional int32 num = 1 [default = 0];

  optional int32 channels = 2 [default = 0];

  optional int32 height = 3 [default = 0];

  optional int32 width = 4 [default = 0];

}

// 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;

  // If true data contains an encoded image that need to be decoded

  optional bool encoded = 7 [default = false];

}

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 output weights for a given input in

  // Gaussian filler -- the default -1 means don't perform sparsification.

  //非零的输出值以高斯滤波系数值的方式填充

  //默认值为-1，不进行稀疏化

  optional int32 sparse = 7 [default = -1];

  // Normalize the filler variance by fan_in, fan_out, or their average.

  // Applies to 'xavier' and 'msra' fillers.

  //Protocol Buffer中的枚举和C++中类似

  enum VarianceNorm {

    FAN_IN = 0;

    FAN_OUT = 1;

    AVERAGE = 2;

  }

  optional VarianceNorm variance_norm = 8 [default = FAN_IN];

}

//网络参数

message NetParameter {

  optional string name = 1; // consider giving the network a name

  // The input blobs to the network.

  repeated string input = 3;

  // The shape of the input blobs.

  repeated BlobShape input_shape = 8;

  // 4D input dimensions -- deprecated.  Use "shape" instead.

  // If specified, for each input blob there should be four

  // values specifying thenum, 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.

  //网络是否会迫使每一层都进行反向操作。

  //如果设置为False，则根据网络结构和学习速率自动确定是否执行向后。

  optional bool force_backward = 5 [default = false];

  // The current "state" of the network, including thephase, level, and stage.

  //当前的网络状态有phase，level，stage三种状态。

  // Some layers may be included/excluded depending on this state and the states

  // specified in the layers' include and exclude fields.

  //根据此状态和图层的包含和非包含字段中指定的状态，可以包括/排除某些网络层。

  optional NetState state = 6;

  // Print debugging information about results while running Net::Forward,

  // Net::Backward, and Net::Update.

  //当运行前向网络，后向网络，更新网络的时候打印 调试信息，默认不打印

  optional bool debug_info = 7 [default = false];

  // The layers that make up the net.  Each of their configurations, including

  // connectivity and behavior, is specified as a LayerParameter.

  //很多层就构成了网. 连接性和行为等配置参数构成了 层参数.最后打印出来

  repeated LayerParameter layer = 100;  // ID 100 so layers are printed last.

  // DEPRECATED: use 'layer' instead.

  //此后改用'layer'结构

  repeated V1LayerParameter layers = 2;

}

// NOTE

// Update the next available ID when you add a new SolverParameter field.

//注意

// 当你添加新的求解器参数对象时, 更新了新的可用ID ，为 ID 41  type

//

// SolverParameter next available ID: 41 (last added: type)

//求解器参数

message SolverParameter {

  //

  // Specifying the train and test networks

  //

  // Exactly onetrain net must be specified using one of the following fields:

  //     train_net_param, train_net, net_param, net

  // One or moretest nets may be specified using any of the following fields:

  //    test_net_param, test_net, net_param, net

  // If more than one test net field is specified (e.g., both net and

  // test_net are specified), they will be evaluated in the field order given

  // above: (1) test_net_param, (2) test_net, (3) net_param/net.

  //如果指定了多个测试网络字段（例如，指定了net和test_net），则将以上面给出的字段顺序对它们求值：

  //（1）test_net_param，（2）test_net，（3）net_param / net。

  // A test_iter must be specified for each test_net.

  // 必须为每个test_net 指定 test_iter

  // A test_level and/or a test_stage may also be specified for each test_net.

  // 还可以为每个test_net指定test_level和/或test_stage

  //

  // Proto filename for the train net, possibly combined with one or more

  // test nets.

  //对于训练网络的原型文件名可能由一个或者多个训练网络组成。

  optional string net = 24;

  // Inline train net param, possibly combined with one or more test nets.

  // 内联训练网络参数可能含有一个或者多个测试网络

  optional NetParameter net_param = 25;

  

  optional string train_net = 1; // Proto filename for the train net.

  repeated string test_net = 2; // Proto filenames for the test nets.

  optional NetParameter train_net_param = 21; // Inline train net params.

  repeated NetParameter test_net_param = 22; // Inline test net params.

  // The states for the train/test nets. Must be unspecified or

  // specified once per net.

  //要么确定，要么不确定，一旦确定，要么全是测试网络要么 全是 训练网络

  //

  // By default, all states will have solver = true;

  // train_state will have phase = TRAIN,

  // and all test_state's will have phase = TEST.

  // Other defaults are set according to the NetState defaults.

  //默认的，所有求解器的状态为真.训练网络  phase =  TRAIN，测试网络 phase = TEST，

  //其他情况有网络状态的默认值决定

  

  optional NetState train_state = 26;

  repeated NetState test_state = 27;

  // The number of iterations for each test net.

  repeated int32 test_iter = 3;

  // The number of iterations between two testing phases.

  // 两个测试阶段之间的迭代次数。

  optional int32 test_interval = 4 [default = 0];

  optional bool test_compute_loss = 19 [default = false];

  // If true, run an initial test pass before the first iteration,

  // ensuring memory availability and printing the starting value of the loss.

  // 若为真，在执行第一次迭代之前，先得运行初始化测试通过来确保有足够存储资源和打印初始值的loss信息

  optional bool test_initialization = 32 [default = true];

  optional float base_lr = 5; // The base learning rate //基准学习率

  // the number of iterations between displaying info. If display = 0, no info

  // will be displayed.

  // 显示迭代之间 展示 信息，如果display = 0，则没有信息显示

  optional int32 display = 6;

  // Display the loss averaged over the last average_loss iterations

  // 显示上次average_loss迭代的平均损失

  optional int32 average_loss = 33 [default = 1];

  optional int32 max_iter = 7; // the maximum number of iterations

  // accumulate gradients over `iter_size` x `batch_size` instances

  optional int32 iter_size = 36 [default = 1];

  // The learning rate decay policy. The currently implemented learning rate

  // policies are as follows:

  //    - fixed: always returnbase_lr.

  //    - step: returnbase_lr *gamma ^ (floor(iter / step))

  //    - exp: returnbase_lr *gamma ^ iter

  //    - inv: returnbase_lr * (1 +gamma * iter) ^ (- power)

  //    - multistep: similar to step but it allows non uniform steps defined by

  //      stepvalue

  //    - poly: the effective learning rate follows a polynomial decay, to be

  //      zero by the max_iter. returnbase_lr (1 -iter/max_iter) ^ (power)

  //    - sigmoid: the effective learning rate follows a sigmod decay

  //      returnbase_lr ( 1/(1 + exp(-gamma * (iter - stepsize))))

  //

  // where base_lr, max_iter, gamma, step, stepvalue and power are defined

  // in the solver parameter protocol buffer, and iter is the current iteration.

  optional string lr_policy = 8;

  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. //权重衰减

  // regularization types supported: L1 and L2

  // controlled by weight_decay

  //正则化方式支持：L1 和 L2

  //由权值衰减变量控制

  optional string regularization_type = 29 [default = "L2"]; //默认正则化方式为L2

  // the stepsize for learning rate policy "step"

  optional int32 stepsize = 13;

  // the stepsize for learning rate policy "multistep"

  repeated int32 stepvalue = 34;

  // Set clip_gradients to >= 0 to clip parameter gradients to that L2 norm,

  // whenever their actual L2 norm is larger.

  // 设置 clip_gradients 大于零，只要它比实际的L2范数大，那么它就等于L2范数 

  optional float clip_gradients = 35 [default = -1];

  optional int32 snapshot = 14 [default = 0]; // The snapshot interval  //snapshot：快照

  optional string snapshot_prefix = 15; // The prefix for the snapshot. //prefix：字首

  // whether to snapshot diff in the results or not. Snapshotting diff will help

  // debugging but the final protocol buffer size will be much larger.

  // 无论快照在结果中有无差值，快照的差值将会有助于调试，但是最终的protocol buffer的尺寸会大很多

  //

  optional bool snapshot_diff = 16 [default = false];

  enum SnapshotFormat {

    HDF5 = 0;

    BINARYPROTO = 1;

  }

  optional SnapshotFormat snapshot_format = 37 [default = BINARYPROTO];

  // 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];

  // type of the solver

  //求解器的类型 默认类型为SGD

  optional string type = 40 [default = "SGD"]; //string 类型

  // numerical stability for RMSProp, AdaGrad and AdaDelta and Adam

  // 对于 RMSProp, AdaGrad and AdaDelta and Adam的数值稳定性默认阈值为 1e-8

  optional float delta = 31 [default = 1e-8];

  // parameters for the Adam solver

  // 自适应动量求解器的衰减的默认取值为0.999

  optional float momentum2 = 39 [default = 0.999];

  // RMSProp decay value

  // RMSProp的衰减值

  // MeanSquare(t) = rms_decay*MeanSquare(t-1) + (1-rms_decay)*SquareGradient(t)

  // 均方差的迭代求解关系

  // MeanSquare(t) = rms_decay*MeanSquare(t-1) + (1-rms_decay)*SquareGradient(t)

  optional float rms_decay = 38;

  // If true, print information about the state of the net that may help with

  // debugging learning problems.

  // 是否打印调试信息，默认设置为否

  optional bool debug_info = 23 [default = false];

  // If false, don't save a snapshot after training finishes.

  //如何设置为否，则不保存每次训练结束后的快照

  optional bool snapshot_after_train = 28 [default = true];

  // DEPRECATED: old solver enum types, use string instead

  //舍弃旧的求解器枚举类型,使用string代替

  enum SolverType {

    SGD = 0;

    NESTEROV = 1;

    ADAGRAD = 2;

    RMSPROP = 3;

    ADADELTA = 4;

    ADAM = 5;

  }

  // DEPRECATED: use type instead of solver_type

  // 舍弃solver_type, 改用 type

  optional SolverType solver_type = 30 [default = SGD];

}

// 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 //sgd求解器的历史记录

  optional int32 current_step = 4 [default = 0]; // The current step for learning rate //当前学习率的步进

}

//状态枚举：训练或者测试

enum Phase { 

   TRAIN = 0;

   TEST = 1;

}

//网络状态

message NetState {

  optional Phase phase = 1 [default = TEST];

  optional int32 level = 2 [default = 0];

  repeated string stage = 3;

}

//Rule网络状态

message NetStateRule {

  // Set phase to require the NetState have a particular phase (TRAIN or TEST)

  // to meet this rule.

  optional Phase phase = 1;

  // Set the minimum and/or maximum levels in which the layer should be used.

  // Leave undefined to meet the rule regardless of level.

  //设置Rule层需使用的最大与/或最小层，其他未定义的层需满足rule规则。

  optional int32 min_level = 2;

  optional int32 max_level = 3;

  // Customizable sets of stages to include or exclude.

  //包含或排除用户自定义集的状态

  // The net must have ALL of the specified stages and NONE of the specified

  // "not_stage"s to meet the rule.

  //网络必须含有所有具体的状态，使用多层网络Rlue用于连接特定状态

  // (Use multiple NetStateRules to specify conjunctions of stages.)

  repeated string stage = 4;

  repeated string not_stage = 5;

}

// Specifies training parameters (multipliers on global learning constants,

// and the name and other settings used for weight sharing).

// 指定训练参数（多层网络的全局学习常数，以及用于权重分配的名称和其他设置）。

message ParamSpec {

  // The names of the parameter blobs -- useful for sharing parameters among

  // layers, but never required otherwise.  To share a parameter between two

  // layers, give it a (non-empty) name.

  //  blobs参数的名称-用于在图层之间共享参数，但从不需要。为了共享一个参数给两层网络，给它一个名字

  optional string name = 1;

  // Whether to require shared weights to have the same shape, or just the same

  // count -- defaults to STRICT if unspecified.

  // 无论是为了相同的shape而共享权值，或者仅仅只是计数。默认情况下如果未指定则为STRICT（限制）

  // 

  optional DimCheckMode share_mode = 2;

  enum DimCheckMode {

    // STRICT (default) requires thatnum, channels, height, width each match.

    // STRICT 限制 (默认) num, channels, height, width 为shape的四个参数，对应一一匹配

    STRICT = 0;

    // PERMISSIVE requires only the count (num*channels*height*width) to match.

    //  PERMISSIVE 允许 仅需要 num*channels*height*width的数相同即可

    PERMISSIVE = 1;

  }

  // The multiplier on the global learning rate for this parameter.

  //该参数在全局上的学习率的乘数

  optional float lr_mult = 3 [default = 1.0];

  // The multiplier on the global weight decay for this parameter.

  // 该参数在全局上的权值衰减的乘数

  optional float decay_mult = 4 [default = 1.0];

}

// NOTE

// Update the next available ID when you add a new LayerParameter field.

//注意

//当你增加新的网络参数字段时，更新新的可用ID

// LayerParameter next available layer-specific ID: 143 (last added: scale_param)

//   新的可用字段号为143

message LayerParameter {

  optional string name = 1; // the layer name

  optional string type = 2; // the layer type

  repeated string bottom = 3; // the name of each bottom blob

  repeated string top = 4; // the name of each top blob

  // The train / test phase for computation.

  optional Phase phase = 10;

  // The amount of weight to assign each top blob in the objective.

  // Each layer assigns a default value, usually of either 0 or 1,

  // to each top blob.

  // 在目标中分配每个顶部blob的权重量。每个图层为每个顶部blob分配一个默认值，通常为0或1。

  repeated float loss_weight = 5;

  // Specifies training parameters (multipliers on global learning constants,

  // and the name and other settings used for weight sharing).

  // 指定训练参数（全局学习常数的乘数，以及用于权值共享的名称和其他设置）。

  repeated ParamSpec param = 6;

  // The blobs containing the numeric parameters of the layer.

  // blob包含层的数值参数。

  repeated BlobProto blobs = 7;

  // Specifies on which bottoms the backpropagation should be skipped.

  //反向传播中 指定应该跳过哪些 bottoms

  // The size must be either 0 or equal to the number of bottoms.

  //  大小为0或者等于 bottoms的个数

  repeated bool propagate_down = 11;

  // Rules controlling whether and when a layer is included in the network,

  // based on the current NetState.  You may specify a non-zero number of rules

  // to include OR exclude, but not both.  If no include or exclude rules are

  // specified, the layer is always included.  If the current NetState meets

  // ANY (i.e., one or more) of the specified rules, the layer is

  // included/excluded.

  // Rules 基于当前的网络状态控制该层是否包含在网络中，您可以指定非零数量的规则以包括或排除，但不能同时包含两者。

  // 如果未指定包含或排除规则，则始终包括该层。如果当前网络状态满足指定规则中的任意（即一个或多个），则包括/排除该层。

  repeated NetStateRule include = 8;

  repeated NetStateRule exclude = 9;

  // Parameters for data pre-processing.

  // 数据预处理的参数

  optional TransformationParameter transform_param = 100;

  // Parameters shared by loss layers.

  // 损耗层共享的参数。

  optional LossParameter loss_param = 101;

  // Layer type-specific parameters.

  // 层的各种具体类型的参数

  // Note: certain layers may have more than one computational engine

  // for their implementation. These layers include an Engine type and

  // engine parameter for selecting the implementation.

  // The default for the engine is set by the ENGINE switch at compile-time.

  // 注意：某些图层可能有多个计算引擎用于实现。

  // 这些层包括用于选择实现的引擎类型和引擎参数。

  // 引擎的默认值由编译时的ENGINE开关设置。

  optional AccuracyParameter accuracy_param = 102;//准确率

  optional ArgMaxParameter argmax_param = 103;//极大值

  optional BatchNormParameter batch_norm_param = 139;//块归一化

  optional BiasParameter bias_param = 141;//偏置

  optional ConcatParameter concat_param = 104;//连续

  optional ContrastiveLossParameter contrastive_loss_param = 105;//对比损失

  optional ConvolutionParameter convolution_param = 106;//卷积

  optional DataParameter data_param = 107;//数据

  optional DropoutParameter dropout_param = 108;//退出

  optional DummyDataParameter dummy_data_param = 109;// 填充数据

  optional EltwiseParameter eltwise_param = 110;// eltwise

  optional ELUParameter elu_param = 140;//elu

  optional EmbedParameter embed_param = 137;//嵌入

  optional ExpParameter exp_param = 111;

  optional FlattenParameter flatten_param = 135;

  optional HDF5DataParameter hdf5_data_param = 112; //hdf5 数据参数

  optional HDF5OutputParameter hdf5_output_param = 113; //hdf5 数据输出参数

  optional HingeLossParameter hinge_loss_param = 114;//合并损失

  optional ImageDataParameter image_data_param = 115;//图像数据

  optional InfogainLossParameter infogain_loss_param = 116;//信息获取？infogain

  optional InnerProductParameter inner_product_param = 117;//内部参数

  optional LogParameter log_param = 134;//对数参数

  optional LRNParameter lrn_param = 118;//逻辑回归参数？

  optional MemoryDataParameter memory_data_param = 119;//内存数据?

  optional MVNParameter mvn_param = 120;//mvn?

  optional PoolingParameter pooling_param = 121;池化参数

  optional PowerParameter power_param = 122;//能量参数

  optional PReLUParameter prelu_param = 131;//预Relu参数

  optional PythonParameter python_param = 130;//python参数

  optional ReductionParameter reduction_param = 136;//减少参数

  optional ReLUParameter relu_param = 123;//relu

  optional ReshapeParameter reshape_param = 133;//更改形状

  optional ROIPoolingParameter roi_pooling_param = 8266711;//感兴趣区域池化参数

  optional ScaleParameter scale_param = 142;//尺度化参数

  optional SigmoidParameter sigmoid_param = 124;//simgmoid参数

  optional SmoothL1LossParameter smooth_l1_loss_param = 8266712;//平滑l1损失参数

  optional SoftmaxParameter softmax_param = 125;//softmax参数

  optional SPPParameter spp_param = 132;//SPP参数

  optional SliceParameter slice_param = 126;//切片参数

  optional TanHParameter tanh_param = 127;//反正切参数

  optional ThresholdParameter threshold_param = 128;//阈值参数

  optional TileParameter tile_param = 138;tile参数

  optional WindowDataParameter window_data_param = 129;//数据窗参数

}

// Message that stores parameters used to apply transformation

// to the data layer's data

// 存储将数据转换应用到数据层的消息结构

message TransformationParameter {

  // 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 = 1 [default = 1];

  // Specify if we want to randomly mirror data.

  optional bool mirror = 2 [default = false];

  // Specify if we would like to randomly crop an image.

  optional uint32 crop_size = 3 [default = 0];

  // mean_file and mean_value cannot be specified at the same time

  // 不能同时制定 mean_file 和  mean_value

  optional string mean_file = 4;

  // if specified can be repeated once (would substract it from all the channels)

  // or can be repeated the same number of times as channels

  // (would subtract them from the corresponding channel)

    //  强如果制定可以重复一次（从所有信道中减去它）

   // 或者每个信道单独减去它们

  repeated float mean_value = 5;

  // Force the decoded image to have 3 color channels.

  // 强制解码成三通道 颜色

  optional bool force_color = 6 [default = false];

  // Force the decoded image to have 1 color channels.

  // 强制解码成单通道颜色

  optional bool force_gray = 7 [default = false];

}

// Message that stores parameters shared by loss layers

// 存储有损耗层共享的消息结构

message LossParameter {

  // If specified, ignore instances with the given label.

  // 如果指定，忽略给定标签的实例

  optional int32 ignore_label = 1;

  // How to normalize the loss for loss layers that aggregate across batches,

  // spatial dimensions, or other dimensions.  Currently only implemented in

  // SoftmaxWithLoss layer.

  // 如何归一化在不同批次之间聚合的损失层的损失，空间尺寸或其他尺寸。

  // 目前仅实现了SoftmaxWithLoss层

  enum NormalizationMode {

    // Divide by the number of examples in the batch times spatial dimensions.

    // Outputs that receive the ignore label will NOT be ignored in computing

    // the normalization factor.

    // 除以例子中批次时域尺寸的数目

    // 接受的输出中忽略的标签将会考虑在计算归一化因子的过程中

    FULL = 0;

    // Divide by the total number of output locations that do not take the

    // ignore_label.  If ignore_label is not set, this behaves like FULL.

    // 除以未采用ignore_label的输出位置的总数。 如果未设置ignore_label，则其行为类似于FULL。

    VALID = 1;

    // Divide by the batch size.

    // 除以批尺寸

    BATCH_SIZE = 2;

    // Do not normalize the loss.

    // 不归一化

    NONE = 3;

  }

  optional NormalizationMode normalization = 3 [default = VALID];

  // Deprecated.  Ignored if normalization is specified.  If normalization

  // is not specified, then setting this to false will be equivalent to

  // normalization = BATCH_SIZE to be consistent with previous behavior.

  // 已弃用。 如果指定了归一化，则忽略。 如果未指定规范化，则将其设置为false，

  // 将等同于规范化= BATCH_SIZE，以与以前的行为一致。

  optional bool normalize = 2;

}

// Messages that store parameters used by individual layer types follow, in

// alphabetical order.

message AccuracyParameter {

  // When computing accuracy, count as correct by comparing the true label to

  // the top k scoring classes.  By default, only compare to the top scoring

  // class (i.e. argmax).

  // 当计算准确性时，通过将真实标签与前k个评分类进行比较来计算为正确。

  // 默认情况下，只比较顶级评分类（即argmax）。

  optional uint32 top_k = 1 [default = 1];

  // The "label" axis of the prediction blob, whose argmax corresponds to the

  // predicted label -- may be negative to index from the end (e.g., -1 for the

  // last axis).  For example, if axis == 1 and the predictions are

  // (N x C x H x W), the label blob is expected to contain N*H*W ground truth

  // labels with integer values in {0, 1, ..., C-1}.

  // 预测斑点的“标签”轴（其argmax对应于预测标签）可以从末端开始索引（例如，对于最后一个轴为-1）。

  // 例如，如果axis == 1并且预测是（N×C×H×W），则期望标签blob包含具有{0,1，...，N}中的整数值的N * C-1}。

  optional int32 axis = 2 [default = 1];

  // If specified, ignore instances with the given label.

  // 如果指定，忽略给定标签的实例

  optional int32 ignore_label = 3;

}

message ArgMaxParameter {

  // If true produce pairs (argmax, maxval)

  // 如果为真，产生  (argmax, maxval)数据对，默认为假

  optional bool out_max_val = 1 [default = false];

  optional uint32 top_k = 2 [default = 1];

  // The axis along which to maximise -- may be negative to index from the

  // end (e.g., -1 for the last axis).

  // 沿其最大化的轴可以对从末端开始的索引为负（例如，对于最后一个轴为-1）。

  // By default ArgMaxLayer maximizes over the flattened trailing dimensions

  // for each index of the first / num dimension.

  // 默认情况下，ArgMaxLayer最大化第一个/num维度的每个索引的展平拖尾尺寸。

  optional int32 axis = 3;

}

message ConcatParameter {

  // The axis along which to concatenate -- may be negative to index from the

  // end (e.g., -1 for the last axis).  Other axes must have the

  // same dimension for all the bottom blobs.

  // By default, ConcatLayer concatenates blobs along the "channels" axis (1).

  // 沿着其连接的轴 - 可以从末尾开始索引（例如，对于最后一个轴为-1）。 其他轴必须有

  // 相同尺寸的所有底部斑点。

  // 默认情况下，ConcatLayer沿着“通道”轴 （1） 连接blob。

  optional int32 axis = 2 [default = 1];

  // DEPRECATED: alias for "axis" -- does not support negative indexing.

  // DEPRECATED：“axis”的别名 - 不支持负索引。

  optional uint32 concat_dim = 1 [default = 1];

}

message BatchNormParameter {

  // If false, accumulate global mean/variance values via a moving average. If

  // true, use those accumulated values instead of computing mean/variance

  // across the batch.

  // 如果为假，则通过移动平均值累积全局均值/方差值。

  // 如果为真，请使用这些累计值，而不是计算整个批次的均值/方差。

  optional bool use_global_stats = 1;

  // How much does the moving average decay each iteration?

  // 每次迭代 移动平均值衰减有多少？

  optional float moving_average_fraction = 2 [default = .999];

  // Small value to add to the variance estimate so that we don't divide by

  // zero.

  // 防止除0

  optional float eps = 3 [default = 1e-5];

}

message BiasParameter {

  // The first axis of bottom[0] (the first input Blob) along which to apply

  // bottom[1] (the second input Blob).  May be negative to index from the end

  // (e.g., -1 for the last axis).

  //

  // 底部[0]的第一个轴（第一个输入Blob），沿着它应用底部[1]（第二个输入Blob）。

  // 可以从末尾开始索引（例如，对于最后一个轴为-1）。

  // For example, if bottom[0] is 4D with shape 100x3x40x60, the output

  // top[0] will have the same shape, and bottom[1] may have any of the

  // following shapes (for the given value of axis):

  // 例如，如果底部[0]是具有形状100x3x40x60的4D，则为输出

  // 顶部[0]将具有相同的形状，底部[1]可具有任何的

  // 以下形状（对于给定的轴值）：

  //    (axis == 0 == -4) 100; 100x3; 100x3x40; 100x3x40x60

  //    (axis == 1 == -3)          3;     3x40;     3x40x60

  //    (axis == 2 == -2)                   40;       40x60

  //    (axis == 3 == -1)                                60

  // Furthermore, bottom[1] may have the empty shape (regardless of the value of

  // "axis") -- a scalar bias.

  // 此外，底部[1]可以具有空形状（不管“轴”的值） - 标量偏差。

  optional int32 axis = 1 [default = 1];

  // (num_axes is ignored unless just one bottom is given and the bias is

  // a learned parameter of the layer.  Otherwise, num_axes is determined by the

  // number of axes by the second bottom.)

  // （忽略num_axes，除非给定一个底部，偏差是层的学习参数，否则num_axes由第二个底部的轴数确定）。

  // The number of axes of the input (bottom[0]) covered by the bias

  // parameter, or -1 to cover all axes of bottom[0] starting from `axis`.

  // Set num_axes := 0, to add a zero-axis Blob: a scalar.

  // 由偏置参数覆盖的输入（底部[0]）的轴数，或从“轴”开始覆盖底部[0]的所有轴的-1。

  // 设置num_axes：= 0，以添加零轴Blob：标量。

  optional int32 num_axes = 2 [default = 1];

  // (filler is ignored unless just one bottom is given and the bias is

  // a learned parameter of the layer.)

  // The initialization for the learned bias parameter.

  // Default is the zero (0) initialization, resulting in the BiasLayer

  // initially performing the identity operation.

  // （填充被忽略，除非只给出一个底部，并且偏置是层的学习参数）。

  // 学习的偏置参数的初始化。

  // 默认是零（0）初始化，导致偏置层初始化执行识别操作。

  optional FillerParameter filler = 3;

}

限于能力有限，代码注释中定有错误和纰漏，望大家指正，后续持续修改ing......