package caffe
Get desktop application:
View/edit binary Protocol Buffers messages
message
caffe.proto:773Used in: ,
optional uint32 top_k = 1
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 int32 axis = 2
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 ignore_label = 3
If specified, ignore instances with the given label.
message
caffe.proto:790Used in: ,
optional bool out_max_val = 1
If true produce pairs (argmax, maxval)
optional uint32 top_k = 2
optional int32 axis = 3
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.
message
caffe.proto:494Message storing the actual coefficients of a transformation IMPORTANT: default values should be 0 or 1
optional float mirror = 1
Spatial
optional float dx = 2
optional float dy = 3
optional float angle = 4
optional float zoom_x = 5
optional float zoom_y = 6
optional float gamma = 100
Chromatic
optional float brightness = 101
optional float contrast = 102
optional float color1 = 103
optional float color2 = 104
optional float color3 = 105
optional float pow_nomean0 = 10
Chromatic-Eigen
optional float pow_nomean1 = 11
optional float pow_nomean2 = 12
optional float add_nomean0 = 13
optional float add_nomean1 = 14
optional float add_nomean2 = 15
optional float mult_nomean0 = 16
optional float mult_nomean1 = 17
optional float mult_nomean2 = 18
optional float pow_withmean0 = 19
optional float pow_withmean1 = 20
optional float pow_withmean2 = 21
optional float add_withmean0 = 22
optional float add_withmean1 = 23
optional float add_withmean2 = 24
optional float mult_withmean0 = 25
optional float mult_withmean1 = 26
optional float mult_withmean2 = 27
optional float lmult_pow = 28
optional float lmult_add = 29
optional float lmult_mult = 30
optional float col_angle = 31
optional float fog_amount = 38
Effect
optional float fog_size = 39
optional float motion_blur_angle = 40
optional float motion_blur_size = 41
optional float shadow_angle = 42
optional float shadow_distance = 43
optional float shadow_strength = 44
optional float noise = 45
message
caffe.proto:547Message describing distribution of augmentation parameters
Used in: ,
optional uint32 crop_width = 33
optional uint32 crop_height = 34
optional string write_augmented = 2
optional float max_multiplier = 3
optional bool augment_during_test = 4
optional uint32 recompute_mean = 5
number of iterations to recompute mean (0 - do not recompute)
optional string write_mean = 6
optional bool mean_per_pixel = 7
if the mean is computed for each pixel or for the whole channel
repeated float mean = 18
Eddy: Per pixel RGB mean to subtract
optional string mode = 8
can be "add" or "replace" or "regenerate"
optional uint32 bottomwidth = 80
optional uint32 bottomheight = 81
optional uint32 num = 82
repeated float chromatic_eigvec = 83
optional mirror = 10
Spatial
optional translate = 11
optional rotate = 12
optional zoom = 13
optional squeeze = 14
optional translate_x = 15
optional translate_y = 16
optional gamma = 35
Chromatic
optional brightness = 36
optional contrast = 37
optional color = 38
optional lmult_pow = 20
Chromatic-Eigen
optional lmult_mult = 21
optional lmult_add = 22
optional sat_pow = 23
optional sat_mult = 24
optional sat_add = 25
optional col_pow = 26
optional col_mult = 27
optional col_add = 28
optional ladd_pow = 29
optional ladd_mult = 30
optional ladd_add = 31
optional col_rotate = 32
optional fog_amount = 100
Effect
optional fog_size = 101
optional motion_blur_angle = 102
optional motion_blur_size = 103
optional shadow_angle = 104
optional shadow_distance = 105
optional shadow_strength = 106
optional noise = 107
message
caffe.proto:812Used in:
optional bool use_global_stats = 1
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 float moving_average_fraction = 2
How much does the moving average decay each iteration?
optional float eps = 3
Small value to add to the variance estimate so that we don't divide by zero.
message
caffe.proto:824Used in:
optional int32 axis = 1
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 num_axes = 2
(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 filler = 3
(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.
message
caffe.proto:10Used in: , , , ,
optional shape = 7
repeated float data = 5
repeated float diff = 6
repeated double double_data = 8
repeated double double_diff = 9
optional int32 num = 1
4D dimensions -- deprecated. Use "shape" instead.
optional int32 channels = 2
optional int32 height = 3
optional int32 width = 4
message
caffe.proto:26The BlobProtoVector is simply a way to pass multiple blobproto instances around.
repeated blobs = 1
message
caffe.proto:6Specifies the shape (dimensions) of a Blob.
Used in: , , , , ,
repeated int64 dim = 1
message
caffe.proto:1778Charbonnier loss
Used in:
optional float alpha = 1
optional float epsilon = 2
optional float beta = 3
message
caffe.proto:692Used in:
optional float half_life = 1
optional float initial_coeff = 2
optional float final_coeff = 3
message
caffe.proto:801Used in: ,
optional int32 axis = 2
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 uint32 concat_dim = 1
DEPRECATED: alias for "axis" -- does not support negative indexing.
message
caffe.proto:856Used in: ,
optional float margin = 1
margin for dissimilar pair
optional bool legacy_version = 2
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
message
caffe.proto:868Used in: ,
optional uint32 num_output = 1
The number of outputs for the layer
optional bool bias_term = 2
whether to have bias terms
repeated uint32 pad = 3
Pad, kernel size, and stride are all given as a single value for equal dimensions in all spatial dimensions, or once per spatial dimension.
The padding size; defaults to 0
repeated uint32 kernel_size = 4
The kernel size
repeated uint32 stride = 6
The stride; defaults to 1
repeated uint32 dilation = 18
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.)
The dilation; defaults to 1
optional uint32 pad_h = 9
For 2D convolution only, the *_h and *_w versions may also be used to specify both spatial dimensions.
The padding height (2D only)
optional uint32 pad_w = 10
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
The group size for group conv
optional weight_filler = 7
The filler for the weight
optional bias_filler = 8
The filler for the bias
optional ConvolutionParameter.Engine engine = 15
optional int32 axis = 16
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 bool force_nd_im2col = 17
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.)
Used in:
DEFAULT = 0
CAFFE = 1
CUDNN = 2
message
caffe.proto:628Message that stores parameters used by CorrelationLayer
Used in:
optional uint32 pad = 2
The padding size (equal in Y, X)
optional uint32 kernel_size = 3
The kernel size (square)
optional uint32 max_displacement = 4
The maximum displacement (square)
optional uint32 stride_1 = 5
The stride in blob 1 (equal in Y, X)
optional uint32 stride_2 = 6
The stride in blob 2 (equal in Y, X)
optional int32 single_direction = 8
For Correlation1D:
Correlate only to the left (-1) or right (1)
optional bool do_abs = 7
Use absolute value of result
optional CorrelationParameter.CorrelationType correlation_type = 15
Multiplicative is normal correlation
Used in:
MULTIPLY = 0
SUBTRACT = 1
message
caffe.proto:921Used in:
optional int32 axis = 1
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).
repeated uint32 offset = 2
message
caffe.proto:939Used in: ,
optional string source = 1
Specify the data source.
optional uint32 batch_size = 4
Specify the batch size.
optional uint32 rand_skip = 7
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 DataParameter.DB backend = 8
optional float scale = 2
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 string mean_file = 3
optional uint32 crop_size = 5
DEPRECATED. See TransformationParameter. Specify if we would like to randomly crop an image.
optional bool mirror = 6
DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror data.
optional bool force_encoded_color = 9
Force the encoded image to have 3 color channels
optional uint32 prefetch = 10
Prefetch queue (Number of batches to prefetch to host memory, increase if data access bandwidth varies).
optional uint32 disk_reader_threads = 4001
Read data from BinaryDB files using multiple threads. If this parameter is set to ZERO, each top blob will get a separate thread.
optional bool huge_video_dataset = 7000
If set to true, BinaryDB uses a pretty fast method for initializing the source data. Without this BinaryDB practically fails to load huge datasets.
optional int32 limit_samples = 7001
Use a non-negative value, to load only this number of dataset samples in binarydb_*
optional string preselection_file = 3001
Load a text file which specifies a label for each data sample. Use preselection_label to filter the data for one specific label.
optional int32 preselection_label = 3002
optional int32 range_start = 3003
0 = start with first
optional int32 range_end = 3004
-1 = go until end
optional bool rand_permute = 3005
optional DataParameter.RANDPERMORDER rand_permute_order = 3006
permute indices first, then extract range (or other way around)
optional uint32 rand_permute_seed = 3007
In BinaryDB (and webp), 0 means using timer randomization!
repeated uint32 slice_point = 3008
repeated DataParameter.CHANNELENCODING encoding = 3009
optional bool verbose = 3010
repeated float subtract = 3011
optional uint32 permute_every_iter = 3012
optional uint32 block_size = 3013
Used in:
UINT8 = 1
UINT16FLOW = 2
BOOL1 = 3
Used in:
LEVELDB = 0
LMDB = 1
Used in:
FIRST_PERMUTE_THEN_RANGE = 0
FIRST_RANGE_THEN_PERMUTE = 1
message
caffe.proto:30optional int32 channels = 1
optional int32 height = 2
optional int32 width = 3
optional bytes data = 4
the actual image data, in bytes
optional int32 label = 5
repeated float float_data = 6
Optionally, the datum could also hold float data.
optional bool encoded = 7
If true data contains an encoded image that need to be decoded
message
caffe.proto:646Used in: ,
optional uint32 top_height = 1
The output height
optional uint32 top_width = 2
The output width
message
caffe.proto:1009Used in: ,
optional float dropout_ratio = 1
dropout ratio
message
caffe.proto:1015DummyDataLayer fills any number of arbitrarily shaped blobs with random (or constant) data generated by "Fillers" (see "message FillerParameter").
Used in: ,
repeated data_filler = 1
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 shape = 6
repeated uint32 num = 2
4D dimensions -- deprecated. Use "shape" instead.
repeated uint32 channels = 3
repeated uint32 height = 4
repeated uint32 width = 5
message
caffe.proto:1047Message that stores parameters used by ELULayer
Used in:
optional float alpha = 1
Described in: Clevert, D.-A., Unterthiner, T., & Hochreiter, S. (2015). Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs). arXiv
message
caffe.proto:1032Used in: ,
optional EltwiseParameter.EltwiseOp operation = 1
element-wise operation
repeated float coeff = 2
blob-wise coefficient for SUM operation
optional bool stable_prod_grad = 3
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.)
Used in:
PROD = 0
SUM = 1
MAX = 2
message
caffe.proto:1055Message that stores parameters used by EmbedLayer
Used in:
optional uint32 num_output = 1
The number of outputs for the layer
optional uint32 input_dim = 2
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 bool bias_term = 3
Whether to use a bias term
optional weight_filler = 4
The filler for the weight
optional bias_filler = 5
The filler for the bias
message
caffe.proto:1069Message that stores parameters used by ExpLayer
Used in: ,
optional float base = 1
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 scale = 2
optional float shift = 3
message
caffe.proto:43Used in: , , , , , , , ,
optional string type = 1
The filler type.
optional float value = 2
the value in constant filler
optional float min = 3
the min value in uniform filler
optional float max = 4
the max value in uniform filler
optional float mean = 5
the mean value in Gaussian filler
optional float std = 6
the std value in Gaussian filler
optional int32 sparse = 7
The expected number of non-zero output weights for a given input in Gaussian filler -- the default -1 means don't perform sparsification.
optional FillerParameter.VarianceNorm variance_norm = 8
repeated float diag_val = 9
optional string file = 10
added by Kaichun Mo
optional float border_ratio = 11
border filler
Normalize the filler variance by fan_in, fan_out, or their average. Applies to 'xavier' and 'msra' fillers.
Used in:
FAN_IN = 0
FAN_OUT = 1
AVERAGE = 2
message
caffe.proto:1079/ Message that stores parameters used by FlattenLayer
Used in:
optional int32 axis = 1
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 end_axis = 2
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).
message
caffe.proto:1773flow transformer
Used in:
(message has no fields)
message
caffe.proto:1091Message that stores parameters used by HDF5DataLayer
Used in: ,
optional string source = 1
Specify the data source.
optional uint32 batch_size = 2
Specify the batch size.
optional bool shuffle = 3
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.
message
caffe.proto:1105Used in: , ,
optional string file_name = 1
message
caffe.proto:1109Used in: ,
optional HingeLossParameter.Norm norm = 1
Specify the Norm to use L1 or L2
Used in:
L1 = 1
L2 = 2
message
caffe.proto:1118Used in: ,
optional string source = 1
Specify the data source.
optional uint32 batch_size = 4
Specify the batch size.
optional uint32 rand_skip = 7
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 bool shuffle = 8
Whether or not ImageLayer should shuffle the list of files at every epoch.
optional uint32 new_height = 9
It will also resize images if new_height or new_width are not zero.
optional uint32 new_width = 10
optional bool is_color = 11
Specify if the images are color or gray
optional float scale = 2
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 string mean_file = 3
optional uint32 crop_size = 5
DEPRECATED. See TransformationParameter. Specify if we would like to randomly crop an image.
optional bool mirror = 6
DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror data.
optional string root_folder = 12
message
caffe.proto:1149Used in: ,
optional string source = 1
Specify the infogain matrix source.
message
caffe.proto:1154Used in: ,
optional uint32 num_output = 1
The number of outputs for the layer
optional bool bias_term = 2
whether to have bias terms
optional weight_filler = 3
The filler for the weight
optional bias_filler = 4
The filler for the bias
optional int32 axis = 5
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 bool transpose = 6
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.
message
caffe.proto:1171Used in:
repeated shape = 1
This layer produces N >= 1 top blob(s) to be assigned manually. Define N shapes to set a shape for each top. Define 1 shape to set the same shape for every top. Define no shape to defer to reshaping manually.
message
caffe.proto:619Message that stores parameters used by L1LossLayer
Used in: ,
optional bool l2_per_location = 1
optional bool l2_prescale_by_channels = 2
Old style
optional bool normalize_by_num_entries = 3
if we want to normalize not by batch size, but by the number of non-NaN entries
optional float epsilon = 4
constant for smoothing near zero
optional float plateau = 3001
L1 Errors smaller than plateau-value will result in zero loss and no gradient
message
caffe.proto:1190Message that stores parameters used by LRNLayer
Used in: ,
optional uint32 local_size = 1
optional float alpha = 2
optional float beta = 3
optional LRNParameter.NormRegion norm_region = 4
optional float k = 5
optional LRNParameter.Engine engine = 6
Used in:
DEFAULT = 0
CAFFE = 1
CUDNN = 2
Used in:
ACROSS_CHANNELS = 0
WITHIN_CHANNEL = 1
message
caffe.proto:362NOTE Update the next available ID when you add a new LayerParameter field. LayerParameter next available layer-specific ID: 187 (last added layer param: SSIMLossParameter)
Used in:
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
optional Phase phase = 10
The train / test phase for computation.
repeated float loss_weight = 5
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 param = 6
Specifies training parameters (multipliers on global learning constants, and the name and other settings used for weight sharing).
repeated blobs = 7
The blobs containing the numeric parameters of the layer.
repeated bool propagate_down = 11
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 include = 8
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 exclude = 9
optional transform_param = 100
Parameters for data pre-processing.
optional loss_param = 101
Parameters shared by loss layers.
optional accuracy_param = 102
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 argmax_param = 103
optional batch_norm_param = 139
optional bias_param = 141
optional concat_param = 104
optional contrastive_loss_param = 105
optional convolution_param = 106
optional crop_param = 144
optional data_param = 107
optional dropout_param = 108
optional dummy_data_param = 109
optional eltwise_param = 110
optional elu_param = 140
optional embed_param = 137
optional exp_param = 111
optional flatten_param = 135
optional hdf5_data_param = 112
optional hdf5_output_param = 113
optional hinge_loss_param = 114
optional image_data_param = 115
optional infogain_loss_param = 116
optional inner_product_param = 117
optional input_param = 143
optional log_param = 134
optional lrn_param = 118
optional memory_data_param = 119
optional mvn_param = 120
optional parameter_param = 145
optional pooling_param = 121
optional power_param = 122
optional prelu_param = 131
optional python_param = 130
optional recurrent_param = 146
optional reduction_param = 136
optional relu_param = 123
optional reshape_param = 133
optional scale_param = 142
optional sigmoid_param = 124
optional softmax_param = 125
optional spp_param = 132
optional slice_param = 126
optional tanh_param = 127
optional threshold_param = 128
optional tile_param = 138
optional window_data_param = 129
optional sin_param = 147
optional coeff_schedule_param = 148
optional augmentation_param = 149
optional correlation_param = 150
optional l1_loss_param = 151
optional writer_param = 152
optional reader_param = 153
optional mean_param = 154
optional resample_param = 155
optional downsample_param = 156
optional bool reshape_every_iter = 157
If should run reshape every iteration
optional st_param = 160
Fusion
optional st_loss_param = 161
optional power_file_param = 162
optional loc_loss_param = 163
optional flow_transformer_param = 170
flow transformer
optional charbonnier_loss_param = 171
Charbonnier loss
optional random_affine_param = 172
random affine transformation generator
optional photometric_augmentation_param = 173
photometric augmentation
optional video_data_param = 180
added from yuanjun caffe
optional rgb_flow_data_param = 181
optional multi_frame_data_param = 182
optional ssim_loss_param = 186
message
caffe.proto:328added by Kaichun Mo
Used in:
required double threshold = 1
message
caffe.proto:1180Message that stores parameters used by LogLayer
Used in:
optional float base = 1
LogLayer computes outputs y = log_base(shift + scale * x), for base > 0. Or if base is set to the default (-1), base is set to e, so y = ln(shift + scale * x) = log_e(shift + scale * x)
optional float scale = 2
optional float shift = 3
message
caffe.proto:744Message that stores parameters shared by loss layers
Used in: ,
optional int32 ignore_label = 1
If specified, ignore instances with the given label.
optional LossParameter.NormalizationMode normalization = 3
optional bool normalize = 2
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.
How to normalize the loss for loss layers that aggregate across batches, spatial dimensions, or other dimensions. Currently only implemented in SoftmaxWithLoss layer.
Used in:
FULL = 0
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.
VALID = 1
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.
BATCH_SIZE = 2
Divide by the batch size.
NONE = 3
Do not normalize the loss.
message
caffe.proto:1215Used in: ,
optional bool normalize_variance = 1
This parameter can be set to false to normalize mean only
optional bool across_channels = 2
This parameter can be set to true to perform DNN-like MVN
optional float eps = 3
Epsilon for not dividing by zero while normalizing variance
message
caffe.proto:678Used in:
required MeanParameter.MeanOperation operation = 1
optional string file = 2
repeated float value = 3
optional float mean_scale = 4
optional float input_scale = 5
optional float output_scale = 6
Used in:
ADD = 1
SUBTRACT = 4
message
caffe.proto:1208Used in: ,
optional uint32 batch_size = 1
optional uint32 channels = 2
optional uint32 height = 3
optional uint32 width = 4
message
caffe.proto:1884New data layer for loading multi-frames video clips
Used in:
optional string source = 1
Specify the data source.
optional uint32 batch_size = 4
Specify the batch size.
optional uint32 rand_skip = 7
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 bool shuffle = 8
Whether or not ImageLayer should shuffle the list of files at every epoch.
optional uint32 new_height = 9
It will also resize images if new_height or new_width are not zero.
optional uint32 new_width = 10
optional uint32 new_length = 11
optional uint32 num_segments = 12
optional float scale = 2
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 string mean_file = 3
optional uint32 crop_size = 5
DEPRECATED. See TransformationParameter. Specify if we would like to randomly crop an image.
optional bool mirror = 6
DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror data.
message
caffe.proto:72Used in:
optional string name = 1
consider giving the network a name
repeated string input = 3
DEPRECATED. See InputParameter. The input blobs to the network.
repeated input_shape = 8
DEPRECATED. See InputParameter. The shape of the input blobs.
repeated int32 input_dim = 4
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.
optional bool force_backward = 5
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 state = 6
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 bool debug_info = 7
Print debugging information about results while running Net::Forward, Net::Backward, and Net::Update.
repeated layer = 100
The layers that make up the net. Each of their configurations, including connectivity and behavior, is specified as a LayerParameter.
ID 100 so layers are printed last.
repeated layers = 2
DEPRECATED: use 'layer' instead.
message
caffe.proto:265Used in: ,
optional Phase phase = 1
optional int32 level = 2
repeated string stage = 3
message
caffe.proto:271Used in: ,
optional Phase phase = 1
Set phase to require the NetState have a particular phase (TRAIN or TEST) to meet this rule.
optional int32 min_level = 2
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 max_level = 3
repeated string stage = 4
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 not_stage = 5
message
caffe.proto:1762Parametric ReLU described in K. He et al, Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification, 2015.
Used in:
optional filler = 1
Initial value of a_i. Default is a_i=0.25 for all i.
optional bool channel_shared = 2
Whether or not slope paramters are shared across channels.
message
caffe.proto:335Specifies training parameters (multipliers on global learning constants, and the name and other settings used for weight sharing).
Used in:
optional string name = 1
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 ParamSpec.DimCheckMode share_mode = 2
Whether to require shared weights to have the same shape, or just the same count -- defaults to STRICT if unspecified.
optional float lr_mult = 3
The multiplier on the global learning rate for this parameter.
optional float decay_mult = 4
The multiplier on the global weight decay for this parameter.
Used in:
STRICT = 0
STRICT (default) requires that num, channels, height, width each match.
PERMISSIVE = 1
PERMISSIVE requires only the count (num*channels*height*width) to match.
message
caffe.proto:1226Used in:
optional shape = 1
enum Phase
caffe.proto:260Used in: , ,
TRAIN = 0
TEST = 1
message
caffe.proto:1796photometric augmentation
Used in:
optional float contrast_min = 1
optional float contrast_max = 2
optional float brightness_sigma = 3
optional float colour_min = 4
optional float colour_max = 5
optional float gamma_min = 6
optional float gamma_max = 7
optional float noise_sigma = 8
repeated float mean_subtraction = 9
message
caffe.proto:1230Used in: ,
optional PoolingParameter.PoolMethod pool = 1
The pooling method
optional uint32 pad = 4
Pad, kernel size, and stride are all given as a single value for equal dimensions in height and width or as Y, X pairs.
The padding size (equal in Y, X)
optional uint32 pad_h = 9
The padding height
optional uint32 pad_w = 10
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
The stride (equal in Y, X)
optional uint32 stride_h = 7
The stride height
optional uint32 stride_w = 8
The stride width
optional PoolingParameter.Engine engine = 11
optional bool global_pooling = 12
If global_pooling then it will pool over the size of the bottom by doing kernel_h = bottom->height and kernel_w = bottom->width
Used in:
DEFAULT = 0
CAFFE = 1
CUDNN = 2
Used in:
MAX = 0
AVE = 1
STOCHASTIC = 2
message
caffe.proto:314added by Kaichun Mo
Used in:
optional string shift_file = 1
message
caffe.proto:1266Used in: ,
optional float power = 1
PowerLayer computes outputs y = (shift + scale * x) ^ power.
optional float scale = 2
optional float shift = 3
message
caffe.proto:1273Used in:
optional string module = 1
optional string layer = 2
optional string param_str = 3
This value is set to the attribute `param_str` of the `PythonLayer` object in Python before calling the `setup()` method. This could be a number, string, dictionary in Python dict format, JSON, etc. You may parse this string in `setup` method and use it in `forward` and `backward`.
optional bool share_in_parallel = 4
Whether this PythonLayer is shared among worker solvers during data parallelism. If true, each worker solver sequentially run forward from this layer. This value should be set true if you are using it as a data layer.
message
caffe.proto:1785random affine
Used in:
optional uint32 batch_size = 1
optional float max_translation_x = 2
optional float max_translation_y = 3
optional float max_rotation = 4
optional float min_scale = 5
optional float max_scale = 6
optional bool horizontal_flipping = 7
message
caffe.proto:607Message used by AugmentationParameter for describing how to generate augmentation parameters
Used in:
optional string rand_type = 1
can be uniform, gaussian, bernoulli
optional bool exp = 2
after generating the random number, exponentiate it or not
optional float mean = 4
mean of the random variable
optional float spread = 5
half of interval length for uniform; standard deviation for gaussian
optional float prob = 6
optional bool apply_schedule = 7
optional bool discretize = 8
Discretize (Round) value from rng to INT
optional float multiplier = 9
Final random value will be multiplied by this. (Useful for discrete distributions)
message
caffe.proto:1336Message that stores parameters used by ReLULayer
Used in: ,
optional float negative_slope = 1
Allow non-zero slope for negative inputs to speed up optimization Described in: Maas, A. L., Hannun, A. Y., & Ng, A. Y. (2013). Rectifier nonlinearities improve neural network acoustic models. In ICML Workshop on Deep Learning for Audio, Speech, and Language Processing.
optional ReLUParameter.Engine engine = 2
Used in:
DEFAULT = 0
CAFFE = 1
CUDNN = 2
message
caffe.proto:651Used in:
required string file = 1
optional uint32 num = 2
message
caffe.proto:1288Message that stores parameters used by RecurrentLayer
Used in:
optional uint32 num_output = 1
The dimension of the output (and usually hidden state) representation -- must be explicitly set to non-zero.
optional weight_filler = 2
The filler for the weight
optional bias_filler = 3
The filler for the bias
optional bool debug_info = 4
Whether to enable displaying debug_info in the unrolled recurrent net.
optional bool expose_hidden = 5
Whether to add as additional inputs (bottoms) the initial hidden state blobs, and add as additional outputs (tops) the final timestep hidden state blobs. The number of additional bottom/top blobs required depends on the recurrent architecture -- e.g., 1 for RNNs, 2 for LSTMs.
message
caffe.proto:1307Message that stores parameters used by ReductionLayer
Used in:
optional ReductionParameter.ReductionOp operation = 1
reduction operation
optional int32 axis = 2
The first axis to reduce to a scalar -- may be negative to index from the end (e.g., -1 for the last axis). (Currently, only reduction along ALL "tail" axes is supported; reduction of axis M through N, where N < num_axes - 1, is unsupported.) Suppose we have an n-axis bottom Blob with shape: (d0, d1, d2, ..., d(m-1), dm, d(m+1), ..., d(n-1)). If axis == m, the output Blob will have shape (d0, d1, d2, ..., d(m-1)), and the ReductionOp operation is performed (d0 * d1 * d2 * ... * d(m-1)) times, each including (dm * d(m+1) * ... * d(n-1)) individual data. If axis == 0 (the default), the output Blob always has the empty shape (count 1), performing reduction across the entire input -- often useful for creating new loss functions.
optional float coeff = 3
coefficient for output
Used in:
SUM = 1
ASUM = 2
SUMSQ = 3
MEAN = 4
message
caffe.proto:665Used in:
optional bool antialias = 4
optional uint32 width = 1
optional uint32 height = 2
optional ResampleParameter.ResampleType type = 3
Used in:
NEAREST = 1
LINEAR = 2
CUBIC = 3
AREA = 4
message
caffe.proto:1351Used in:
optional shape = 1
Specify the output dimensions. If some of the dimensions are set to 0, the corresponding dimension from the bottom layer is used (unchanged). Exactly one dimension may be set to -1, in which case its value is inferred from the count of the bottom blob and the remaining dimensions. For example, suppose we want to reshape a 2D blob "input" with shape 2 x 8: layer { type: "Reshape" bottom: "input" top: "output" reshape_param { ... } } If "input" is 2D with shape 2 x 8, then the following reshape_param specifications are all equivalent, producing a 3D blob "output" with shape 2 x 2 x 4: reshape_param { shape { dim: 2 dim: 2 dim: 4 } } reshape_param { shape { dim: 0 dim: 2 dim: 4 } } reshape_param { shape { dim: 0 dim: 2 dim: -1 } } reshape_param { shape { dim: 0 dim:-1 dim: 4 } }
optional int32 axis = 2
axis and num_axes control the portion of the bottom blob's shape that are replaced by (included in) the reshape. By default (axis == 0 and num_axes == -1), the entire bottom blob shape is included in the reshape, and hence the shape field must specify the entire output shape. axis may be non-zero to retain some portion of the beginning of the input shape (and may be negative to index from the end; e.g., -1 to begin the reshape after the last axis, including nothing in the reshape, -2 to include only the last axis, etc.). For example, suppose "input" is a 2D blob with shape 2 x 8. Then the following ReshapeLayer specifications are all equivalent, producing a blob "output" with shape 2 x 2 x 4: reshape_param { shape { dim: 2 dim: 2 dim: 4 } } reshape_param { shape { dim: 2 dim: 4 } axis: 1 } reshape_param { shape { dim: 2 dim: 4 } axis: -3 } num_axes specifies the extent of the reshape. If num_axes >= 0 (and axis >= 0), the reshape will be performed only on input axes in the range [axis, axis+num_axes]. num_axes may also be -1, the default, to include all remaining axes (starting from axis). For example, suppose "input" is a 2D blob with shape 2 x 8. Then the following ReshapeLayer specifications are equivalent, producing a blob "output" with shape 1 x 2 x 8. reshape_param { shape { dim: 1 dim: 2 dim: 8 } } reshape_param { shape { dim: 1 dim: 2 } num_axes: 1 } reshape_param { shape { dim: 1 } num_axes: 0 } On the other hand, these would produce output blob shape 2 x 1 x 8: reshape_param { shape { dim: 2 dim: 1 dim: 8 } } reshape_param { shape { dim: 1 } axis: 1 num_axes: 0 }
optional int32 num_axes = 3
message
caffe.proto:1853New data layer for loading multi-frames and optical flow together
Used in:
optional string source = 1
Specify the data source.
optional uint32 batch_size = 4
Specify the batch size.
optional uint32 rand_skip = 7
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 bool shuffle = 8
Whether or not ImageLayer should shuffle the list of files at every epoch.
optional uint32 new_height = 9
It will also resize images if new_height or new_width are not zero.
optional uint32 new_width = 10
optional uint32 new_length = 11
optional uint32 num_segments = 12
optional float scale = 2
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 string mean_file = 3
optional uint32 crop_size = 5
DEPRECATED. See TransformationParameter. Specify if we would like to randomly crop an image.
optional bool mirror = 6
DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror data.
message
caffe.proto:1551Used in:
optional uint32 pyramid_height = 1
optional SPPParameter.PoolMethod pool = 2
The pooling method
optional SPPParameter.Engine engine = 6
Used in:
DEFAULT = 0
CAFFE = 1
CUDNN = 2
Used in:
MAX = 0
AVE = 1
STOCHASTIC = 2
message
caffe.proto:1259Used in:
optional uint32 kernel_size = 1
The kernel size (square)
optional uint32 stride = 2
The stride (equal in Y, X)
optional float c1 = 3
C1
optional float c2 = 4
C2
message
caffe.proto:320added by Kaichun Mo
Used in:
required int32 output_H = 1
Indicate the resolution of the output images after ST transformation
required int32 output_W = 2
message
caffe.proto:1415Used in:
optional int32 axis = 1
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 multiplier.
optional int32 num_axes = 2
(num_axes is ignored unless just one bottom is given and the scale 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 scale parameter, or -1 to cover all axes of bottom[0] starting from `axis`. Set num_axes := 0, to multiply with a zero-axis Blob: a scalar.
optional filler = 3
(filler is ignored unless just one bottom is given and the scale is a learned parameter of the layer.) The initialization for the learned scale parameter. Default is the unit (1) initialization, resulting in the ScaleLayer initially performing the identity operation.
optional bool bias_term = 4
Whether to also learn a bias (equivalent to a ScaleLayer+BiasLayer, but may be more efficient). Initialized with bias_filler (defaults to 0).
optional bias_filler = 5
message
caffe.proto:1452Used in: ,
optional SigmoidParameter.Engine engine = 1
Used in:
DEFAULT = 0
CAFFE = 1
CUDNN = 2
message
caffe.proto:1496Used in: ,
optional SinParameter.Engine engine = 1
Used in:
DEFAULT = 0
CAFFE = 1
message
caffe.proto:1461Used in: ,
optional int32 axis = 3
The axis along which to slice -- may be negative to index from the end (e.g., -1 for the last axis). By default, SliceLayer concatenates blobs along the "channels" axis (1).
repeated uint32 slice_point = 2
optional uint32 slice_dim = 1
DEPRECATED: alias for "axis" -- does not support negative indexing.
message
caffe.proto:1473Message that stores parameters used by SoftmaxLayer, SoftmaxWithLossLayer
Used in: ,
optional SoftmaxParameter.Engine engine = 1
optional int32 axis = 2
The axis along which to perform the softmax -- may be negative to index from the end (e.g., -1 for the last axis). Any other axes will be evaluated as independent softmaxes.
Used in:
DEFAULT = 0
CAFFE = 1
CUDNN = 2
message
caffe.proto:110NOTE Update the next available ID when you add a new SolverParameter field. SolverParameter next available ID: 41 (last added: type)
//////////////////////////////////////////////////////////////////////////// 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. ////////////////////////////////////////////////////////////////////////////
optional string net = 24
Proto filename for the train net, possibly combined with one or more test nets.
optional net_param = 25
Inline train net param, possibly combined with one or more test nets.
optional string train_net = 1
Proto filename for the train net.
repeated string test_net = 2
Proto filenames for the test nets.
optional train_net_param = 21
Inline train net params.
repeated test_net_param = 22
Inline test net params.
optional train_state = 26
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.
repeated test_state = 27
repeated int32 test_iter = 3
The number of iterations for each test net.
optional int32 test_interval = 4
The number of iterations between two testing phases.
optional bool test_compute_loss = 19
optional bool test_initialization = 32
If true, run an initial test pass before the first iteration, ensuring memory availability and printing the starting value of the loss.
optional float base_lr = 5
The base learning rate
optional int32 display = 6
the number of iterations between displaying info. If display = 0, no info will be displayed.
optional int32 average_loss = 33
Display the loss averaged over the last average_loss iterations
optional int32 max_iter = 7
the maximum number of iterations
optional int32 iter_size = 36
accumulate gradients over `iter_size` x `batch_size` instances
optional string lr_policy = 8
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 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 string regularization_type = 29
regularization types supported: L1 and L2 controlled by weight_decay
optional int32 stepsize = 13
the stepsize for learning rate policy "step"
repeated int32 stepvalue = 34
the stepsize for learning rate policy "multistep"
optional float clip_gradients = 35
Set clip_gradients to >= 0 to clip parameter gradients to that L2 norm, whenever their actual L2 norm is larger.
optional int32 snapshot = 14
The snapshot interval
optional string snapshot_prefix = 15
The prefix for the snapshot.
optional bool snapshot_diff = 16
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 SolverParameter.SnapshotFormat snapshot_format = 37
optional SolverParameter.SolverMode solver_mode = 17
optional int32 device_id = 18
the device_id will that be used in GPU mode. Use device_id = 0 in default.
optional int64 random_seed = 20
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 string type = 40
type of the solver
optional float delta = 31
numerical stability for RMSProp, AdaGrad and AdaDelta and Adam
optional float momentum2 = 39
parameters for the Adam solver
optional float rms_decay = 38
RMSProp decay value MeanSquare(t) = rms_decay*MeanSquare(t-1) + (1-rms_decay)*SquareGradient(t)
optional bool debug_info = 23
If true, print information about the state of the net that may help with debugging learning problems.
optional bool snapshot_after_train = 28
If false, don't save a snapshot after training finishes.
optional SolverParameter.SolverType solver_type = 30
DEPRECATED: use type instead of solver_type
Used in:
HDF5 = 0
BINARYPROTO = 1
the mode solver will use: 0 for CPU and 1 for GPU. Use GPU in default.
Used in:
CPU = 0
GPU = 1
DEPRECATED: old solver enum types, use string instead
Used in:
SGD = 0
NESTEROV = 1
ADAGRAD = 2
RMSPROP = 3
ADADELTA = 4
ADAM = 5
message
caffe.proto:253A message that stores the solver snapshots
optional int32 iter = 1
The current iteration
optional string learned_net = 2
The file that stores the learned net.
repeated history = 3
The history for sgd solvers
optional int32 current_step = 4
The current step for learning rate
message
caffe.proto:290added by Kaichun Mo
Used in:
optional string transform_type = 1
How to use the parameter passed by localisation network
optional string sampler_type = 2
What is the sampling technique
optional int32 output_H = 3
If not set,stay same with the input dimension H and W
optional int32 output_W = 4
optional bool to_compute_dU = 5
If false, only compute dTheta, DO NOT compute dU
optional double theta_1_1 = 6
The default value for some parameters
optional double theta_1_2 = 7
optional double theta_1_3 = 8
optional double theta_2_1 = 9
optional double theta_2_2 = 10
optional double theta_2_3 = 11
message
caffe.proto:1487Used in: ,
optional TanHParameter.Engine engine = 1
Used in:
DEFAULT = 0
CAFFE = 1
CUDNN = 2
message
caffe.proto:1514Message that stores parameters used by ThresholdLayer
Used in: ,
optional float threshold = 1
Strictly positive values
message
caffe.proto:1505Message that stores parameters used by TileLayer
Used in:
optional int32 axis = 1
The index of the axis to tile.
optional int32 tiles = 2
The number of copies (tiles) of the blob to output.
message
caffe.proto:700Message that stores parameters used to apply transformation to the data layer's data
Used in: ,
optional float scale = 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 bool mirror = 2
Specify if we want to randomly mirror data.
optional uint32 crop_size = 3
Specify if we would like to randomly crop an image.
optional string mean_file = 4
mean_file and mean_value cannot be specified at the same time
repeated float mean_value = 5
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)
optional bool force_color = 6
Force the decoded image to have 3 color channels.
optional bool force_gray = 7
Force the decoded image to have 1 color channels.
optional uint32 crop_size_h = 8
non square crops
optional uint32 crop_size_w = 9
optional bool fix_crop = 10
if set to true, instead using a fixed position cropping (center, left-up, left-down, right-up, right-down)
optional bool more_fix_crop = 15
turn on to use stronger augmentation
optional bool multi_scale = 11
if set to true, use multi-scale data augmentation
repeated float scale_ratios = 12
a list of float numbers less than 1 for multiple scales
optional int32 max_distort = 13
maximal tolerated aspect ratio mismatch in the ratio list
optional bool is_flow = 14
if set to true, it is optical flow field
message
caffe.proto:1670DEPRECATED: V0LayerParameter is the old way of specifying layer parameters in Caffe. We keep this message type around for legacy support.
Used in:
optional string name = 1
the layer name
optional string type = 2
the string to specify the layer type
optional uint32 num_output = 3
Parameters to specify layers with inner products.
The number of outputs for the layer
optional bool biasterm = 4
whether to have bias terms
optional weight_filler = 5
The filler for the weight
optional bias_filler = 6
The filler for the bias
optional uint32 pad = 7
The padding size
optional uint32 kernelsize = 8
The kernel size
optional uint32 group = 9
The group size for group conv
optional uint32 stride = 10
The stride
optional V0LayerParameter.PoolMethod pool = 11
The pooling method
optional float dropout_ratio = 12
dropout ratio
optional uint32 local_size = 13
for local response norm
optional float alpha = 14
for local response norm
optional float beta = 15
for local response norm
optional float k = 22
optional string source = 16
For data layers, specify the data source
optional float scale = 17
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 string meanfile = 18
optional uint32 batchsize = 19
For data layers, specify the batch size.
optional uint32 cropsize = 20
For data layers, specify if we would like to randomly crop an image.
optional bool mirror = 21
For data layers, specify if we want to randomly mirror data.
repeated blobs = 50
The blobs containing the numeric parameters of the layer
repeated float blobs_lr = 51
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 weight_decay = 52
The weight decay that is multiplied on the global weight decay.
optional uint32 rand_skip = 53
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 float det_fg_threshold = 54
Fields related to detection (det_*) foreground (object) overlap threshold
optional float det_bg_threshold = 55
background (non-object) overlap threshold
optional float det_fg_fraction = 56
Fraction of batch that should be foreground objects
optional uint32 det_context_pad = 58
Amount of contextual padding to add around a window (used only by the window_data_layer)
optional string det_crop_mode = 59
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 int32 new_num = 60
For ReshapeLayer, one needs to specify the new dimensions.
optional int32 new_channels = 61
optional int32 new_height = 62
optional int32 new_width = 63
optional bool shuffle_images = 64
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 uint32 concat_dim = 65
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 hdf5_output_param = 1001
Used in:
MAX = 0
AVE = 1
STOCHASTIC = 2
message
caffe.proto:1568DEPRECATED: use LayerParameter.
Used in:
repeated string bottom = 2
repeated string top = 3
optional string name = 4
repeated include = 32
repeated exclude = 33
optional V1LayerParameter.LayerType type = 5
repeated blobs = 6
repeated string param = 1001
repeated V1LayerParameter.DimCheckMode blob_share_mode = 1002
repeated float blobs_lr = 7
repeated float weight_decay = 8
repeated float loss_weight = 35
optional accuracy_param = 27
optional argmax_param = 23
optional concat_param = 9
optional contrastive_loss_param = 40
optional convolution_param = 10
optional data_param = 11
optional dropout_param = 12
optional dummy_data_param = 26
optional eltwise_param = 24
optional exp_param = 41
optional hdf5_data_param = 13
optional hdf5_output_param = 14
optional hinge_loss_param = 29
optional image_data_param = 15
optional infogain_loss_param = 16
optional inner_product_param = 17
optional lrn_param = 18
optional memory_data_param = 22
optional mvn_param = 34
optional pooling_param = 19
optional power_param = 21
optional relu_param = 30
optional sigmoid_param = 38
optional softmax_param = 39
optional slice_param = 31
optional tanh_param = 37
optional threshold_param = 25
optional window_data_param = 20
optional transform_param = 36
optional loss_param = 42
optional layer = 1
optional sin_param = 50
optional aug_param = 51
optional l1_loss_param = 52
optional downsample_param = 53
Used in:
STRICT = 0
PERMISSIVE = 1
Used in:
NONE = 0
ABSVAL = 35
ACCURACY = 1
ARGMAX = 30
AUGMENTATION = 42
BNLL = 2
CONCAT = 3
CONTRASTIVE_LOSS = 37
CONVOLUTION = 4
DATA = 5
DECONVOLUTION = 39
DOWNSAMPLE = 43
DROPOUT = 6
DUMMY_DATA = 32
EUCLIDEAN_LOSS = 7
ELTWISE = 25
EXP = 38
FLATTEN = 8
HDF5_DATA = 9
HDF5_OUTPUT = 10
HINGE_LOSS = 28
IM2COL = 11
IMAGE_DATA = 12
INFOGAIN_LOSS = 13
INNER_PRODUCT = 14
L1LOSS = 44
LRN = 15
MEMORY_DATA = 29
MULTINOMIAL_LOGISTIC_LOSS = 16
MVN = 34
POOLING = 17
POWER = 26
RELU = 18
SIGMOID = 19
SIGMOID_CROSS_ENTROPY_LOSS = 27
SILENCE = 36
SIN = 41
SOFTMAX = 20
SOFTMAX_LOSS = 21
SPLIT = 22
SLICE = 33
TANH = 23
WINDOW_DATA = 24
THRESHOLD = 31
message
caffe.proto:1810Used in:
optional string source = 1
Specify the data source.
optional uint32 batch_size = 4
Specify the batch size.
optional uint32 rand_skip = 7
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 bool shuffle = 8
Whether or not ImageLayer should shuffle the list of files at every epoch.
optional uint32 new_height = 9
It will also resize images if new_height or new_width are not zero.
optional uint32 new_width = 10
optional uint32 new_length = 11
optional uint32 num_segments = 12
optional float scale = 2
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 string mean_file = 3
optional uint32 crop_size = 5
DEPRECATED. See TransformationParameter. Specify if we would like to randomly crop an image.
optional bool mirror = 6
DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror data.
optional VideoDataParameter.Modality modality = 13
optional string name_pattern = 14
the name pattern for frame images, for RGB modality it is default to "img_%04d.jpg", for FLOW "flow_x_%04d" and "flow_y_%04d"
optional bool encoded = 15
The type of input
Used in:
RGB = 0
FLOW = 1
message
caffe.proto:1518Used in: ,
optional string source = 1
Specify the data source.
optional float scale = 2
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 string mean_file = 3
optional uint32 batch_size = 4
Specify the batch size.
optional uint32 crop_size = 5
Specify if we would like to randomly crop an image.
optional bool mirror = 6
Specify if we want to randomly mirror data.
optional float fg_threshold = 7
Foreground (object) overlap threshold
optional float bg_threshold = 8
Background (non-object) overlap threshold
optional float fg_fraction = 9
Fraction of batch that should be foreground objects
optional uint32 context_pad = 10
Amount of contextual padding to add around a window (used only by the window_data_layer)
optional string crop_mode = 11
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 bool cache_images = 12
cache_images: will load all images in memory for faster access
optional string root_folder = 13
append root_folder to locate images
message
caffe.proto:656Used in:
optional string file = 1
optional string folder = 2
optional string prefix = 3
optional string suffix = 4
optional bool normalize = 5
optional float scale = 6