syntax = "proto2";

package caffe;

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

message BlobShape {

repeated int64 dim = 1 [packed = true];

}

message BlobProto {

optional BlobShape shape = 7;

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.

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.

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

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

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

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

// DEPRECATED. See InputParameter. The input blobs to the network.

repeated string input = 3;

// DEPRECATED. See InputParameter. The shape of the input blobs.

repeated BlobShape input_shape = 8;

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

// If specified, 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];

// The current "state" of the network, including the phase, level, and 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.

// The configuration of memory optimization

optional MemoryOptimizationParameter mem_param = 200;

// DEPRECATED: use 'layer' instead.

repeated V1LayerParameter layers = 2;

}

// NOTE

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

//

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

message SolverParameter {

//////////////////////////////////////////////////////////////////////////////

// Specifying the train and test networks

//

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

// train_net_param, train_net, net_param, net

// One or more test 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.

// A test_iter must be specified for each test_net.

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

//////////////////////////////////////////////////////////////////////////////

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

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.

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.

optional int32 display = 6;

// Display the loss averaged over the last average_loss iterations

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 return base_lr.

// - step: return base_lr * gamma ^ (floor(iter / step))

// - exp: return base_lr * gamma ^ iter

// - inv: return base_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. return base_lr (1 - iter/max_iter) ^ (power)

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

// return base_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

optional string regularization_type = 29 [default = "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.

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

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

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

optional string type = 40 [default = "SGD"];

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

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

// parameters for the Adam solver

optional float momentum2 = 39 [default = 0.999];

// RMSProp decay value

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

enum SolverType {

SGD = 0;

NESTEROV = 1;

ADAGRAD = 2;

RMSPROP = 3;

ADADELTA = 4;

ADAM = 5;

}

// DEPRECATED: use type instead of solver_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

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;

}

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.

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.

// (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.

optional string name = 1;

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

// count -- defaults to STRICT if unspecified.

optional DimCheckMode share_mode = 2;

enum DimCheckMode {

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

STRICT = 0;

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

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.

//

// LayerParameter next available layer-specific ID: 151 (last added: psroi_region_pooling_param)

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.

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.

repeated BlobProto blobs = 7;

// Specifies whether to backpropagate to each bottom. If unspecified,

// Caffe will automatically infer whether each input needs backpropagation

// to compute parameter gradients. If set to true for some inputs,

// backpropagation to those inputs is forced; if set false for some inputs,

// backpropagation to those inputs is skipped.

//

// The size must be either 0 or equal to the number of 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.

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.

optional AccuracyParameter accuracy_param = 102;

optional ArgMaxParameter argmax_param = 103;

optional BatchNormParameter batch_norm_param = 139;

optional BoxAnnotatorOHEMParameter box_annotator_ohem_param = 10000;

optional BiasParameter bias_param = 141;

optional BatchPoolParameter batch_pool_param = 11149;

optional BNParameter bn_param = 146;

optional BNHKParameter bnhk_param = 148;

optional CenterLossParameter center_loss_param = 111213;

optional ConcatParameter concat_param = 104;

optional ContrastiveLossParameter contrastive_loss_param = 105;

optional ConvolutionParameter convolution_param = 106;

optional CropParameter crop_param = 144;

optional DataParameter data_param = 107;

optional DeltaToCoordinateParameter delta_to_coordinate_param = 200;

optional DropoutParameter dropout_param = 108;

optional DummyDataParameter dummy_data_param = 109;

optional EltwiseParameter eltwise_param = 110;

optional ELUParameter elu_param = 140;

optional EmbedParameter embed_param = 137;

optional ExpParameter exp_param = 111;

optional FlattenParameter flatten_param = 135;

optional GateParameter gate_param = 123321;

optional SampleParameter sample_param = 123322;

optional HDF5DataParameter hdf5_data_param = 112;

optional HDF5OutputParameter hdf5_output_param = 113;

optional HingeLossParameter hinge_loss_param = 114;

optional ImageDataParameter image_data_param = 115;

optional InfogainLossParameter infogain_loss_param = 116;

optional InnerProductParameter inner_product_param = 117;

optional InputParameter input_param = 143;

optional LogParameter log_param = 134;

optional LRNParameter lrn_param = 118;

optional MemoryDataParameter memory_data_param = 119;

optional MVNParameter mvn_param = 120;

optional NormalizationParameter normalization_param = 111150;

optional NormalizeParameter normalize_param = 147;

optional ParameterParameter parameter_param = 145;

optional PointFocusParameter point_focus_param = 201;

optional PointPoolingParameter point_pooling_param = 149;

optional PoolingParameter pooling_param = 121;

optional PowerParameter power_param = 122;

optional PReLUParameter prelu_param = 131;

optional PSROIPoolingParameter psroi_pooling_param = 10001;

optional PSROIRegionPoolingParameter psroi_region_pooling_param = 151;

optional PythonParameter python_param = 130;

optional RegionPoolingParameter region_pooling_param = 150;

optional ReductionParameter reduction_param = 136;

optional ReLUParameter relu_param = 123;

optional ReshapeParameter reshape_param = 133;

optional ROIPoolingParameter roi_pooling_param = 8266711;

optional ScaleParameter scale_param = 142;

optional SigmoidParameter sigmoid_param = 124;

optional SmoothL1LossParameter smooth_l1_loss_param = 8266712;

optional SoftmaxParameter softmax_param = 125;

optional SPPParameter spp_param = 132;

optional SliceParameter slice_param = 126;

optional TanHParameter tanh_param = 127;

optional ThresholdParameter threshold_param = 128;

optional TileParameter tile_param = 138;

optional TripletLossParameter triplet_loss_param = 160;

optional UpsampleParameter upsample_param = 12345;

optional WindowDataParameter window_data_param = 129;

optional CenterProjectionParameter center_projection_param = 11092;

optional ClsOHEMParameter cls_ohem_param = 10947;

optional UnpoolingParameter unpooling_param = 12155;

optional MarginInnerProductParameter margin_inner_product_param = 161;

optional FocalLossParameter focal_loss_param = 10632;

}

message FocalLossParameter {

optional float alpha = 1 [default = 0.25]; // The scale

optional float gamma = 2 [default = 2]; // The exponent

}

message MarginInnerProductParameter {

optional uint32 num_output = 1; // The number of outputs for the layer

enum MarginType {

SINGLE = 0;

DOUBLE = 1;

TRIPLE = 2;

QUADRUPLE = 3;

}

optional MarginType type = 2 [default = SINGLE]; //

// add the parameter for the norm of each column of the weight matrix

optional FillerParameter weight_filler = 3; // The filler for the weight

// The first axis to be lumped into a single inner product computation;

// all preceding axes are retained in the output.

// May be negative to index from the end (e.g., -1 for the last axis).

optional int32 axis = 4 [default = 1];

optional float base = 5 [default = 1];

optional float gamma = 6 [default = 0];

optional float power = 7 [default = 1];

optional int32 iteration = 8 [default = 0];

optional float lambda_min = 9 [default = 0];

}

message UnpoolingParameter {

enum UnpoolMethod {

MAX = 0;

AVE = 1;

TILE= 2;

}

optional UnpoolMethod unpool = 1 [default = MAX]; // The pooling method

// Pad, kernel size, and stride are all given as a single value for equal

// dimensions in height and width or as Y, X pairs.

optional uint32 pad = 4 [default = 0]; // The padding size (equal in Y, X)

optional uint32 pad_h = 9 [default = 0]; // The padding height

optional uint32 pad_w = 10 [default = 0]; // The padding width

optional uint32 kernel_size = 2; // The kernel size (square)

optional uint32 kernel_h = 5; // The kernel height

optional uint32 kernel_w = 6; // The kernel width

optional uint32 stride = 3 [default = 1]; // The stride (equal in Y, X)

optional uint32 stride_h = 7; // The stride height

optional uint32 stride_w = 8; // The stride width

optional uint32 unpool_size = 12; // destined unpooled map size

optional uint32 unpool_h = 13; // destined unpooled map height

optional uint32 unpool_w = 14; // destined unpooled map width

enum Engine {

DEFAULT = 0;

CAFFE = 1;

}

optional Engine engine = 11 [default = DEFAULT];

}

message CenterLossParameter {

optional uint32 num_output = 1; // The number of outputs for the layer

optional FillerParameter center_filler = 2; // The filler for the centers

// The first axis to be lumped into a single inner product computation;

// all preceding axes are retained in the output.

// May be negative to index from the end (e.g., -1 for the last axis).

optional int32 axis = 3 [default = 1];

}

message ClsOHEMParameter {

optional int32 topk = 1 [default = 128];

optional int32 ignore_label = 2 [default = -1];

}

message SampleParameter {

optional uint32 number = 1 [default = 1];

optional float decay = 2 [default = 0.99];

optional FillerParameter scale_filler = 3; // The filler for the scale

optional FillerParameter shift_filler = 4; // The filler for the shift

optional float scale = 5 [default = 1.0];

}

message GateParameter {

optional uint32 active_val = 1 [default = 1];

}

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

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.

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.

VALID = 1;

// Divide by the batch size.

BATCH_SIZE = 2;

// Divide by pre-fixed normalizer

PRE_FIXED = 3;

// Do not normalize the loss.

NONE = 4;

}

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.

optional bool normalize = 2;

//pre-fixed normalizer

optional float pre_fixed_normalizer = 4 [default = 1];

}

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

// alphabetical order.

message TripletLossParameter {

//margin for negative triplet

optional float margin = 1 [default = 1.0];

}

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).

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}.

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)

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).

// By default ArgMaxLayer maximizes over the flattened trailing dimensions

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

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).

optional int32 axis = 2 [default = 1];

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

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.

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

}

message BoxAnnotatorOHEMParameter {

required uint32 roi_per_img = 1; // number of rois for training

optional int32 ignore_label = 2 [default = -1]; // ignore_label in scoring

}

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).

//

// 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):

// (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.

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.)

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

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.

optional FillerParameter filler = 3;

}

message BNHKParameter {

optional FillerParameter slope_filler = 1;

optional FillerParameter bias_filler = 2;

optional float momentum = 3 [default = 0.9];

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

// If true, will use the moving average mean and std for training and tes t.

// Will override the lr_param and freeze all the parameters.

// Make sure to initialize the layer properly with pretrained parameters.

optional bool frozen = 5 [default = false];

enum Engine {

DEFAULT = 0;

CAFFE = 1;

CUDNN = 2;

}

optional Engine engine = 6 [default = DEFAULT];

}

// Message that stores parameters used by BNLayer

message BNParameter {

optional FillerParameter scale_filler = 1; // The filler for the scale

optional FillerParameter shift_filler = 2; // The filler for the shift

optional float var_eps = 3 [default = 1e-10]; // The epsilon added to variance

optional bool moving_average = 4 [default = true]; // whether or not using moving average for inference

optional float decay = 5 [default = 0.95]; // The decay factor for moving average

optional bool sync_forward = 6 [default = false]; // The flag for statistic (mean/var) sync at forward proceeding

}

message ContrastiveLossParameter {

// margin for dissimilar pair

optional float margin = 1 [default = 1.0];

// The first implementation of this cost did not exactly match the cost of

// Hadsell et al 2006 -- using (margin - d^2) instead of (margin - d)^2.

// legacy_version = false (the default) uses (margin - d)^2 as proposed in the

// Hadsell paper. New models should probably use this version.

// legacy_version = true uses (margin - d^2). This is kept to support /

// reproduce existing models and results

optional bool legacy_version = 2 [default = false];

}

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

// Pad, kernel size, and stride are all given as a single value for equal

// dimensions in all spatial dimensions, or once per spatial dimension.

repeated uint32 pad = 3; // The padding size; defaults to 0

repeated uint32 kernel_size = 4; // The kernel size

repeated uint32 stride = 6; // The stride; defaults to 1

// Factor used to dilate the kernel, (implicitly) zero-filling the resulting

// holes. (Kernel dilation is sometimes referred to by its use in the

// algorithme à trous from Holschneider et al. 1987.)

repeated uint32 dilation = 18; // The dilation; defaults to 1

// For 2D convolution only, the *_h and *_w versions may also be used to

// specify both spatial dimensions.

optional uint32 pad_h = 9 [default = 0]; // The padding height (2D only)

optional uint32 pad_w = 10 [default = 0]; // The padding width (2D only)

optional uint32 kernel_h = 11; // The kernel height (2D only)

optional uint32 kernel_w = 12; // The kernel width (2D only)

optional uint32 stride_h = 13; // The stride height (2D only)

optional uint32 stride_w = 14; // The stride width (2D only)

optional uint32 group = 5 [default = 1]; // The group size for group conv

optional FillerParameter weight_filler = 7; // The filler for the weight

optional FillerParameter bias_filler = 8; // The filler for the bias

enum Engine {

DEFAULT = 0;

CAFFE = 1;

CUDNN = 2;

}

optional Engine engine = 15 [default = DEFAULT];

// The axis to interpret as "channels" when performing convolution.

// Preceding dimensions are treated as independent inputs;

// succeeding dimensions are treated as "spatial".

// With (N, C, H, W) inputs, and axis == 1 (the default), we perform

// N independent 2D convolutions, sliding C-channel (or (C/g)-channels, for

// groups g>1) filters across the spatial axes (H, W) of the input.

// With (N, C, D, H, W) inputs, and axis == 1, we perform

// N independent 3D convolutions, sliding (C/g)-channels

// filters across the spatial axes (D, H, W) of the input.

optional int32 axis = 16 [default = 1];

// Whether to force use of the general ND convolution, even if a specific

// implementation for blobs of the appropriate number of spatial dimensions

// is available. (Currently, there is only a 2D-specific convolution

// implementation; for input blobs with num_axes != 2, this option is

// ignored and the ND implementation will be used.)

optional bool force_nd_im2col = 17 [default = false];

}

message UpsampleParameter {

optional uint32 scale = 1;

optional uint32 scale_h = 2;

optional uint32 scale_w = 3;

}

message CropParameter {

// To crop, elements of the first bottom are selected to fit the dimensions

// of the second, reference bottom. The crop is configured by

// - the crop `axis` to pick the dimensions for cropping

// - the crop `offset` to set the shift for all/each dimension

// to align the cropped bottom with the reference bottom.

// All dimensions up to but excluding `axis` are preserved, while

// the dimensions including and trailing `axis` are cropped.

// If only one `offset` is set, then all dimensions are offset by this amount.

// Otherwise, the number of offsets must equal the number of cropped axes to

// shift the crop in each dimension accordingly.

// Note: standard dimensions are N,C,H,W so the default is a spatial crop,

// and `axis` may be negative to index from the end (e.g., -1 for the last

// axis).

optional int32 axis = 1 [default = 2];

repeated uint32 offset = 2;

}

message DataParameter {

enum DB {

LEVELDB = 0;

LMDB = 1;

}

// Specify the data source.

optional string source = 1;

// Specify the batch size.

optional uint32 batch_size = 4;

// 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 database.

// DEPRECATED. Each solver accesses a different subset of the database.

optional uint32 rand_skip = 7 [default = 0];

optional DB backend = 8 [default = LEVELDB];

// DEPRECATED. See 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 = 2 [default = 1];

optional string mean_file = 3;

// DEPRECATED. See TransformationParameter. Specify if we would like to randomly

// crop an image.

optional uint32 crop_size = 5 [default = 0];

// DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror

// data.

optional bool mirror = 6 [default = false];

// Force the encoded image to have 3 color channels

optional bool force_encoded_color = 9 [default = false];

// Prefetch queue (Number of batches to prefetch to host memory, increase if

// data access bandwidth varies).

optional uint32 prefetch = 10 [default = 4];

}

message DropoutParameter {

optional float dropout_ratio = 1 [default = 0.5]; // dropout ratio

optional bool scale_train = 2 [default = true]; // scale train or test phase

}

// DummyDataLayer fills any number of arbitrarily shaped blobs with random

// (or constant) data generated by "Fillers" (see "message FillerParameter").

message DummyDataParameter {

// This layer produces N >= 1 top blobs. DummyDataParameter must specify 1 or N

// shape fields, and 0, 1 or N data_fillers.

//

// If 0 data_fillers are specified, ConstantFiller with a value of 0 is used.

// If 1 data_filler is specified, it is applied to all top blobs. If N are

// specified, the ith is applied to the ith top blob.

repeated FillerParameter data_filler = 1;

repeated BlobShape shape = 6;

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

repeated uint32 num = 2;

repeated uint32 channels = 3;

repeated uint32 height = 4;

repeated uint32 width = 5;

}

message EltwiseParameter {

enum EltwiseOp {

PROD = 0;

SUM = 1;

MAX = 2;

}

optional EltwiseOp operation = 1 [default = SUM]; // element-wise operation

repeated float coeff = 2; // blob-wise coefficient for SUM operation

// Whether to use an asymptotically slower (for >2 inputs) but stabler method

// of computing the gradient for the PROD operation. (No effect for SUM op.)

optional bool stable_prod_grad = 3 [default = true];

}

// Message that stores parameters used by ELULayer

message ELUParameter {

// Described in:

// Clevert, D.-A., Unterthiner, T., & Hochreiter, S. (2015). Fast and Accurate

// Deep Network Learning by Exponential Linear Units (ELUs). arXiv

optional float alpha = 1 [default = 1];

}

// Message that stores parameters used by EmbedLayer

message EmbedParameter {

optional uint32 num_output = 1; // The number of outputs for the layer

// The input is given as integers to be interpreted as one-hot

// vector indices with dimension num_input. Hence num_input should be

// 1 greater than the maximum possible input value.

optional uint32 input_dim = 2;

optional bool bias_term = 3 [default = true]; // Whether to use a bias term

optional FillerParameter weight_filler = 4; // The filler for the weight

optional FillerParameter bias_filler = 5; // The filler for the bias

}

// Message that stores parameters used by ExpLayer

message ExpParameter {

// ExpLayer computes outputs y = base ^ (shift + scale * x), for base > 0.

// Or if base is set to the default (-1), base is set to e,

// so y = exp(shift + scale * x).

optional float base = 1 [default = -1.0];

optional float scale = 2 [default = 1.0];

optional float shift = 3 [default = 0.0];

}

/// Message that stores parameters used by FlattenLayer

message FlattenParameter {

// The first axis to flatten: all preceding axes are retained in the output.

// May be negative to index from the end (e.g., -1 for the last axis).

optional int32 axis = 1 [default = 1];

// The last axis to flatten: all following axes are retained in the output.

// May be negative to index from the end (e.g., the default -1 for the last

// axis).

optional int32 end_axis = 2 [default = -1];

}

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

// Specify whether to shuffle the data.

// If shuffle == true, the ordering of the HDF5 files is shuffled,

// and the ordering of data within any given HDF5 file is shuffled,

// but data between different files are not interleaved; all of a file's

// data are output (in a random order) before moving onto another file.

optional bool shuffle = 3 [default = false];

}

message HDF5OutputParameter {

optional string file_name = 1;

}

message HingeLossParameter {

enum Norm {

L1 = 1;

L2 = 2;

}

// Specify the Norm to use L1 or L2

optional Norm norm = 1 [default = L1];

}

message PointFocusParameter {

optional uint32 stride = 2 [default = 8];

optional float anchor_bias = 3 [default = 3.5];

}

message DeltaToCoordinateParameter {

optional float threshold_cls = 1 [default = 0.0];

optional uint32 stride = 2 [default = 8];

optional float anchor_bias = 3 [default = 3.5];

optional float threshold_reg = 4 [default = 0.2];

}

message ImageDataParameter {

// Specify the data source.

optional string source = 1;

// Specify the batch size.

optional uint32 batch_size = 4 [default = 1];

// 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 database.

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

// Specify if the images are color or gray

optional bool is_color = 11 [default = true];

// DEPRECATED. See 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 = 2 [default = 1];

optional string mean_file = 3;

// DEPRECATED. See TransformationParameter. Specify if we would like to randomly

// crop an image.

optional uint32 crop_size = 5 [default = 0];

// DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror

// data.

optional bool mirror = 6 [default = false];

optional string root_folder = 12 [default = ""];

}

message InfogainLossParameter {

// Specify the infogain matrix source.

optional string source = 1;

}

message CenterProjectionParameter {

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

// The first axis to be lumped into a single inner product computation;

// all preceding axes are retained in the output.

// May be negative to index from the end (e.g., -1 for the last axis).

optional int32 axis = 5 [default = 1];

// Specify whether to transpose the weight matrix or not.

// If transpose == true, any operations will be performed on the transpose

// of the weight matrix. The weight matrix itself is not going to be transposed

// but rather the transfer flag of operations will be toggled accordingly.

optional bool transpose = 6 [default = false];

optional float scale = 7 [default = 1.0];

}

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