Caffe各层的参数设置(在prototxt文件中设置)

caffe prototxt网络文件中参数含义 caffe中训练一个模型时,需要用到两个文件,一个是train.prototxt文件,里面定义了模型的网络结构;另一个是solver.prototxt文件,里面定义了训练模型时的一些参数配置。一些常用的参数的含义这里不做记录。 1.train.prototxt文件 (1)数据层 在层类型中,也就是“type”这个参数,一般都会写“Data”,这个类型说明数据来自于数据库(如LevelDB和L... 阅读详情

Caffe各层的参数设置(在prototxt文件中设置)

这些参数定义在include/caffe/proto/caffe.proto文件中

如果要查看某种层的参数,请展开本文的目录,点击相应的条目来跳转

 

syntax= "proto2";


packagecaffe;


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

messageBlobShape {

repeatedint64 dim = 1 [packed = true];

}


messageBlobProto {

optionalBlobShape shape = 7;

repeatedfloat data = 5 [packed = true];

repeatedfloat diff = 6 [packed = true];

repeateddouble double_data = 8 [packed = true];

repeateddouble double_diff = 9 [packed = true];


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

optionalint32 num = 1 [default = 0];

optionalint32 channels = 2 [default = 0];

optionalint32 height = 3 [default = 0];

optionalint32 width = 4 [default = 0];

}


//The BlobProtoVector is simply a way to pass multiple blobprotoinstances

//around.

messageBlobProtoVector {

repeatedBlobProto blobs = 1;

}


messageDatum {

optionalint32 channels = 1;

optionalint32 height = 2;

optionalint32 width = 3;

//the actual image data, in bytes

optionalbytes data = 4;

optionalint32 label = 5;

//Optionally, the datum could also hold float data.

repeatedfloat float_data = 6;

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

optionalbool encoded = 7 [default = false];

}


messageFillerParameter {

//The filler type.

optionalstring type = 1 [default = 'constant'];

optionalfloat value = 2 [default = 0]; // the value in constant filler

optionalfloat min = 3 [default = 0]; // the min value in uniform filler

optionalfloat max = 4 [default = 1]; // the max value in uniform filler

optionalfloat mean = 5 [default = 0]; // the mean value in Gaussian filler

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

optionalint32 sparse = 7 [default = -1];

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

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

enumVarianceNorm {

FAN_IN= 0;

FAN_OUT= 1;

AVERAGE= 2;

}

optionalVarianceNorm variance_norm = 8 [default = FAN_IN];

}


messageNetParameter {

optionalstring name = 1; // consider giving the network a name

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

repeatedstring input = 3;

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

repeatedBlobShape 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 inputblob.

//Thus, there should be a total of (4 * #input) numbers.

repeatedint32 input_dim = 4;


//Whether the network will force every layer to carry out backwardoperation.

//If set False, then whether to carry out backward is determined

//automatically according to the net structure and learning rates.

optionalbool 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 thestates

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

optionalNetState state = 6;


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

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

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

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


//DEPRECATED: use 'layer' instead.

repeatedV1LayerParameter layers = 2;

}


//NOTE

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

//

//SolverParameter next available ID: 42 (last added: layer_wise_reduce)

messageSolverParameter {

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

//Specifying the train and test networks

//

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

// train_net_param, train_net, net_param, net

//One or more test nets may be specified using any of the followingfields:

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

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

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


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

//test nets.

optionalstring net = 24;

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

optionalNetParameter net_param = 25;


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

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

optionalNetParameter train_net_param = 21; // Inline train net params.

repeatedNetParameter 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, train_state will have phase = TRAIN,

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

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

optionalNetState train_state = 26;

repeatedNetState test_state = 27;


//The number of iterations for each test net.

repeatedint32 test_iter = 3;


//The number of iterations between two testing phases.

optionalint32 test_interval = 4 [default = 0];

optionalbool 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 theloss.

optionalbool test_initialization = 32 [default = true];

optionalfloat base_lr = 5; // The base learning rate

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

//will be displayed.

optionalint32 display = 6;

//Display the loss averaged over the last average_loss iterations

optionalint32 average_loss = 33 [default = 1];

optionalint32 max_iter = 7; // the maximum number of iterations

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

optionalint32 iter_size = 36 [default = 1];


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

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

// stepvalue

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

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

optionalstring lr_policy = 8;

optionalfloat gamma = 9; // The parameter to compute the learning rate.

optionalfloat power = 10; // The parameter to compute the learning rate.

optionalfloat momentum = 11; // The momentum value.

optionalfloat weight_decay = 12; // The weight decay.

//regularization types supported: L1 and L2

//controlled by weight_decay

optionalstring regularization_type = 29 [default = "L2"];

//the stepsize for learning rate policy "step"

optionalint32 stepsize = 13;

//the stepsize for learning rate policy "multistep"

repeatedint32 stepvalue = 34;


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

//whenever their actual L2 norm is larger.

optionalfloat clip_gradients = 35 [default = -1];


optionalint32 snapshot = 14 [default = 0]; // The snapshot interval

optionalstring snapshot_prefix = 15; // The prefix for the snapshot.

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

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

optionalbool snapshot_diff = 16 [default = false];

enumSnapshotFormat {

HDF5= 0;

BINARYPROTO= 1;

}

optionalSnapshotFormat snapshot_format = 37 [default = BINARYPROTO];

//the mode solver will use: 0 for CPU and 1 for GPU. Use GPU indefault.

enumSolverMode {

CPU= 0;

GPU= 1;

}

optionalSolverMode solver_mode = 17 [default = GPU];

//the device_id will that be used in GPU mode. Use device_id = 0 indefault.

optionalint32 device_id = 18 [default = 0];

//If non-negative, the seed with which the Solver will initialize theCaffe

//random number generator -- useful for reproducible results.Otherwise,

//(and by default) initialize using a seed derived from the systemclock.

optionalint64 random_seed = 20 [default = -1];


//type of the solver

optionalstring type = 40 [default = "SGD"];


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

optionalfloat delta = 31 [default = 1e-8];

//parameters for the Adam solver

optionalfloat momentum2 = 39 [default = 0.999];


//RMSProp decay value

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

optionalfloat rms_decay = 38 [default = 0.99];


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

//debugging learning problems.

optionalbool debug_info = 23 [default = false];


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

optionalbool snapshot_after_train = 28 [default = true];


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

enumSolverType {

SGD= 0;

NESTEROV= 1;

ADAGRAD= 2;

RMSPROP= 3;

ADADELTA= 4;

ADAM= 5;

}

//DEPRECATED: use type instead of solver_type

optionalSolverType solver_type = 30 [default = SGD];


//Overlap compute and communication for data parallel training

optionalbool layer_wise_reduce = 41 [default = true];

}


//A message that stores the solver snapshots

messageSolverState {

optionalint32 iter = 1; // The current iteration

optionalstring learned_net = 2; // The file that stores the learned net.

repeatedBlobProto history = 3; // The history for sgd solvers

optionalint32 current_step = 4 [default = 0]; // The current step forlearning rate

}


enumPhase {

TRAIN= 0;

TEST= 1;

}


messageNetState {

optionalPhase phase = 1 [default = TEST];

optionalint32 level = 2 [default = 0];

repeatedstring stage = 3;

}


messageNetStateRule {

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

//to meet this rule.

optionalPhase phase = 1;


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

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

optionalint32 min_level = 2;

optionalint32 max_level = 3;


//Customizable sets of stages to include or exclude.

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

//"not_stage"s to meet the rule.

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

repeatedstring stage = 4;

repeatedstring not_stage = 5;

}


//Specifies training parameters (multipliers on global learningconstants,

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

messageParamSpec {

//The names of the parameter blobs -- useful for sharing parametersamong

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

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

optionalstring name = 1;


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

//count -- defaults to STRICT if unspecified.

optionalDimCheckMode share_mode = 2;

enumDimCheckMode {

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

STRICT= 0;

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

PERMISSIVE= 1;

}


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

optionalfloat lr_mult = 3 [default = 1.0];


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

optionalfloat 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: 147 (last added:recurrent_param)

messageLayerParameter {

optionalstring name = 1; // the layer name

optionalstring type = 2; // the layer type

repeatedstring bottom = 3; // the name of each bottom blob

repeatedstring top = 4; // the name of each top blob


//The train / test phase for computation.

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

repeatedfloat loss_weight = 5;


//Specifies training parameters (multipliers on global learningconstants,

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

repeatedParamSpec param = 6;


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

repeatedBlobProto blobs = 7;


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

//Caffe will automatically infer whether each input needsbackpropagation

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

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

//backpropagation to those inputs is skipped.

//

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

repeatedbool propagate_down = 11;


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

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

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

//specified, the layer is always included. If the current NetStatemeets

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

//included/excluded.

repeatedNetStateRule include = 8;

repeatedNetStateRule exclude = 9;


//Parameters for data pre-processing.

optionalTransformationParameter transform_param = 100;


//Parameters shared by loss layers.

optionalLossParameter 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 atcompile-time.

optionalAccuracyParameter accuracy_param = 102;

optionalArgMaxParameter argmax_param = 103;

optionalBatchNormParameter batch_norm_param = 139;

optionalBiasParameter bias_param = 141;

optionalConcatParameter concat_param = 104;

optionalContrastiveLossParameter contrastive_loss_param = 105;

optionalConvolutionParameter convolution_param = 106;

optionalCropParameter crop_param = 144;

optionalDataParameter data_param = 107;

optionalDropoutParameter dropout_param = 108;

optionalDummyDataParameter dummy_data_param = 109;

optionalEltwiseParameter eltwise_param = 110;

optionalELUParameter elu_param = 140;

optionalEmbedParameter embed_param = 137;

optionalExpParameter exp_param = 111;

optionalFlattenParameter flatten_param = 135;

optionalHDF5DataParameter hdf5_data_param = 112;

optionalHDF5OutputParameter hdf5_output_param = 113;

optionalHingeLossParameter hinge_loss_param = 114;

optionalImageDataParameter image_data_param = 115;

optionalInfogainLossParameter infogain_loss_param = 116;

optionalInnerProductParameter inner_product_param = 117;

optionalInputParameter input_param = 143;

optionalLogParameter log_param = 134;

optionalLRNParameter lrn_param = 118;

optionalMemoryDataParameter memory_data_param = 119;

optionalMVNParameter mvn_param = 120;

optionalParameterParameter parameter_param = 145;

optionalPoolingParameter pooling_param = 121;

optionalPowerParameter power_param = 122;

optionalPReLUParameter prelu_param = 131;

optionalPythonParameter python_param = 130;

optionalRecurrentParameter recurrent_param = 146;

optionalReductionParameter reduction_param = 136;

optionalReLUParameter relu_param = 123;

optionalReshapeParameter reshape_param = 133;

optionalScaleParameter scale_param = 142;

optionalSigmoidParameter sigmoid_param = 124;

optionalSoftmaxParameter softmax_param = 125;

optionalSPPParameter spp_param = 132;

optionalSliceParameter slice_param = 126;

optionalTanHParameter tanh_param = 127;

optionalThresholdParameter threshold_param = 128;

optionalTileParameter tile_param = 138;

optionalWindowDataParameter window_data_param = 129;

}


//Message that stores parameters used to apply transformation

//to the data layer's data

messageTransformationParameter {

//For data pre-processing, we can do simple scaling and subtracting the

//data mean, if provided. Note that the mean subtraction is alwayscarried

//out before scaling.

optionalfloat scale = 1 [default = 1];

//Specify if we want to randomly mirror data.

optionalbool mirror = 2 [default = false];

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

optionaluint32 crop_size = 3 [default = 0];

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

optionalstring mean_file = 4;

//if specified can be repeated once (would subtract it from all thechannels)

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

//(would subtract them from the corresponding channel)

repeatedfloat mean_value = 5;

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

optionalbool force_color = 6 [default = false];

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

optionalbool force_gray = 7 [default = false];

}


//Message that stores parameters shared by loss layers

messageLossParameter {

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

optionalint32 ignore_label = 1;

//How to normalize the loss for loss layers that aggregate acrossbatches,

//spatial dimensions, or other dimensions. Currently only implementedin

//SoftmaxWithLoss and SigmoidCrossEntropyLoss layers.

enumNormalizationMode {

//Divide by the number of examples in the batch times spatialdimensions.

//Outputs that receive the ignore label will NOT be ignored incomputing

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

//Do not normalize the loss.

NONE= 3;

}

//For historical reasons, the default normalization for

//SigmoidCrossEntropyLoss is BATCH_SIZE and *not* VALID.

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

optionalbool normalize = 2;

}


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

//alphabetical order.


messageAccuracyParameter {

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

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

//class (i.e. argmax).

optionaluint32 top_k = 1 [default = 1];


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

//predicted label -- may be negative to index from the end (e.g., -1for 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 groundtruth

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

optionalint32 axis = 2 [default = 1];


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

optionalint32 ignore_label = 3;

}


messageArgMaxParameter {

//If true produce pairs (argmax, maxval)

optionalbool out_max_val = 1 [default = false];

optionaluint32 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 trailingdimensions

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

optionalint32 axis = 3;

}


messageConcatParameter {

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

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

optionalint32 axis = 2 [default = 1];


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

optionaluint32 concat_dim = 1 [default = 1];

}


messageBatchNormParameter {

//If false, normalization is performed over the current mini-batch

//and global statistics are accumulated (but not yet used) by a moving

//average.

//If true, those accumulated mean and variance values are used for the

//normalization.

//By default, it is set to false when the network is in the training

//phase and true when the network is in the testing phase.

optionalbool use_global_stats = 1;

//What fraction of the moving average remains each iteration?

//Smaller values make the moving average decay faster, giving more

//weight to the recent values.

//Each iteration updates the moving average @f$S_{t-1}@f$ with the

//current mean @f$ Y_t @f$ by

//@f$ S_t = (1-\beta)Y_t + \beta \cdot S_{t-1} @f$, where @f$ \beta @f$

//is the moving_average_fraction parameter.

optionalfloat moving_average_fraction = 2 [default = .999];

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

//zero.

optionalfloat eps = 3 [default = 1e-5];

}


messageBiasParameter {

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

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

//(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 thevalue of

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

optionalint32 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 determinedby 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.

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

optionalFillerParameter filler = 3;

}


messageContrastiveLossParameter {

//margin for dissimilar pair

optionalfloat margin = 1 [default = 1.0];

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

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

//legacy_version = false (the default) uses (margin - d)^2 as proposedin 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

optionalbool legacy_version = 2 [default = false];

}


messageConvolutionParameter {

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

optionalbool bias_term = 2 [default = true]; // whether to have bias terms


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

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

repeateduint32 pad = 3; // The padding size; defaults to 0

repeateduint32 kernel_size = 4; // The kernel size

repeateduint32 stride = 6; // The stride; defaults to 1

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

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

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

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

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

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

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

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

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

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


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


optionalFillerParameter weight_filler = 7; // The filler for the weight

optionalFillerParameter bias_filler = 8; // The filler for the bias

enumEngine {

DEFAULT= 0;

CAFFE= 1;

CUDNN= 2;

}

optionalEngine engine = 15 [default = DEFAULT];


//The axis to interpret as "channels" when performingconvolution.

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

optionalint32 axis = 16 [default = 1];


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

//implementation for blobs of the appropriate number of spatialdimensions

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

optionalbool force_nd_im2col = 17 [default = false];

}


messageCropParameter {

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

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

//Otherwise, the number of offsets must equal the number of croppedaxes to

//shift the crop in each dimension accordingly.

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

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

//axis).

optionalint32 axis = 1 [default = 2];

repeateduint32 offset = 2;

}


messageDataParameter {

enumDB {

LEVELDB= 0;

LMDB= 1;

}

//Specify the data source.

optionalstring source = 1;

//Specify the batch size.

optionaluint32 batch_size = 4;

//The rand_skip variable is for the data layer to skip a few datapoints

//to avoid all asynchronous sgd clients to start at the same point. Theskip

//point would be set as rand_skip * rand(0,1). Note that rand_skipshould not

//be larger than the number of keys in the database.

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

optionaluint32 rand_skip = 7 [default = 0];

optionalDB backend = 8 [default = LEVELDB];

//DEPRECATED. See TransformationParameter. For data pre-processing, wecan do

//simple scaling and subtracting the data mean, if provided. Note thatthe

//mean subtraction is always carried out before scaling.

optionalfloat scale = 2 [default = 1];

optionalstring mean_file = 3;

//DEPRECATED. See TransformationParameter. Specify if we would like torandomly

//crop an image.

optionaluint32 crop_size = 5 [default = 0];

//DEPRECATED. See TransformationParameter. Specify if we want torandomly mirror

//data.

optionalbool mirror = 6 [default = false];

//Force the encoded image to have 3 color channels

optionalbool force_encoded_color = 9 [default = false];

//Prefetch queue (Increase if data feeding bandwidth varies, within the

//limit of device memory for GPU training)

optionaluint32 prefetch = 10 [default = 4];

}


messageDropoutParameter {

optionalfloat dropout_ratio = 1 [default = 0.5]; // dropout ratio

}


//DummyDataLayer fills any number of arbitrarily shaped blobs withrandom

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

messageDummyDataParameter {

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

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

//

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

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

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

repeatedFillerParameter data_filler = 1;

repeatedBlobShape shape = 6;


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

repeateduint32 num = 2;

repeateduint32 channels = 3;

repeateduint32 height = 4;

repeateduint32 width = 5;

}


messageEltwiseParameter {

enumEltwiseOp {

PROD= 0;

SUM= 1;

MAX= 2;

}

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

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


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

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

optionalbool stable_prod_grad = 3 [default = true];

}


//Message that stores parameters used by ELULayer

messageELUParameter {

//Described in:

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

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

optionalfloat alpha = 1 [default = 1];

}


//Message that stores parameters used by EmbedLayer

messageEmbedParameter {

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

optionaluint32 input_dim = 2;


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

optionalFillerParameter weight_filler = 4; // The filler for the weight

optionalFillerParameter bias_filler = 5; // The filler for the bias


}


//Message that stores parameters used by ExpLayer

messageExpParameter {

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

optionalfloat base = 1 [default = -1.0];

optionalfloat scale = 2 [default = 1.0];

optionalfloat shift = 3 [default = 0.0];

}


///Message that stores parameters used by FlattenLayer

messageFlattenParameter {

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

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

optionalint32 axis = 1 [default = 1];


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

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

//axis).

optionalint32 end_axis = 2 [default = -1];

}


//Message that stores parameters used by HDF5DataLayer

messageHDF5DataParameter {

//Specify the data source.

optionalstring source = 1;

//Specify the batch size.

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

optionalbool shuffle = 3 [default = false];

}


messageHDF5OutputParameter {

optionalstring file_name = 1;

}


messageHingeLossParameter {

enumNorm {

L1= 1;

L2= 2;

}

//Specify the Norm to use L1 or L2

optionalNorm norm = 1 [default = L1];

}


messageImageDataParameter {

//Specify the data source.

optionalstring source = 1;

//Specify the batch size.

optionaluint32 batch_size = 4 [default = 1];

//The rand_skip variable is for the data layer to skip a few datapoints

//to avoid all asynchronous sgd clients to start at the same point. Theskip

//point would be set as rand_skip * rand(0,1). Note that rand_skipshould not

//be larger than the number of keys in the database.

optionaluint32 rand_skip = 7 [default = 0];

//Whether or not ImageLayer should shuffle the list of files at everyepoch.

optionalbool shuffle = 8 [default = false];

//It will also resize images if new_height or new_width are not zero.

optionaluint32 new_height = 9 [default = 0];

optionaluint32 new_width = 10 [default = 0];

//Specify if the images are color or gray

optionalbool is_color = 11 [default = true];

//DEPRECATED. See TransformationParameter. For data pre-processing, wecan do

//simple scaling and subtracting the data mean, if provided. Note thatthe

//mean subtraction is always carried out before scaling.

optionalfloat scale = 2 [default = 1];

optionalstring mean_file = 3;

//DEPRECATED. See TransformationParameter. Specify if we would like torandomly

//crop an image.

optionaluint32 crop_size = 5 [default = 0];

//DEPRECATED. See TransformationParameter. Specify if we want torandomly mirror

//data.

optionalbool mirror = 6 [default = false];

optionalstring root_folder = 12 [default = ""];

}


messageInfogainLossParameter {

//Specify the infogain matrix source.

optionalstring source = 1;

}


messageInnerProductParameter {

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

optionalbool bias_term = 2 [default = true]; // whether to have bias terms

optionalFillerParameter weight_filler = 3; // The filler for the weight

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

optionalint32 axis = 5 [default = 1];

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

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

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

//but rather the transfer flag of operations will be toggledaccordingly.

optionalbool transpose = 6 [default = false];

}


messageInputParameter {

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

repeatedBlobShape shape = 1;

}


//Message that stores parameters used by LogLayer

messageLogParameter {

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

optionalfloat base = 1 [default = -1.0];

optionalfloat scale = 2 [default = 1.0];

optionalfloat shift = 3 [default = 0.0];

}


//Message that stores parameters used by LRNLayer

messageLRNParameter {

optionaluint32 local_size = 1 [default = 5];

optionalfloat alpha = 2 [default = 1.];

optionalfloat beta = 3 [default = 0.75];

enumNormRegion {

ACROSS_CHANNELS= 0;

WITHIN_CHANNEL= 1;

}

optionalNormRegion norm_region = 4 [default = ACROSS_CHANNELS];

optionalfloat k = 5 [default = 1.];

enumEngine {

DEFAULT= 0;

CAFFE= 1;

CUDNN= 2;

}

optionalEngine engine = 6 [default = DEFAULT];

}


messageMemoryDataParameter {

optionaluint32 batch_size = 1;

optionaluint32 channels = 2;

optionaluint32 height = 3;

optionaluint32 width = 4;

}


messageMVNParameter {

//This parameter can be set to false to normalize mean only

optionalbool normalize_variance = 1 [default = true];


//This parameter can be set to true to perform DNN-like MVN

optionalbool across_channels = 2 [default = false];


//Epsilon for not dividing by zero while normalizing variance

optionalfloat eps = 3 [default = 1e-9];

}


messageParameterParameter {

optionalBlobShape shape = 1;

}


messagePoolingParameter {

enumPoolMethod {

MAX= 0;

AVE= 1;

STOCHASTIC= 2;

}

optionalPoolMethod pool = 1 [default = MAX]; // The pooling method

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

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

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

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

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

optionaluint32 kernel_size = 2; // The kernel size (square)

optionaluint32 kernel_h = 5; // The kernel height

optionaluint32 kernel_w = 6; // The kernel width

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

optionaluint32 stride_h = 7; // The stride height

optionaluint32 stride_w = 8; // The stride width

enumEngine {

DEFAULT= 0;

CAFFE= 1;

CUDNN= 2;

}

optionalEngine engine = 11 [default = DEFAULT];

//If global_pooling then it will pool over the size of the bottom bydoing

//kernel_h = bottom->height and kernel_w = bottom->width

optionalbool global_pooling = 12 [default = false];

}


messagePowerParameter {

//PowerLayer computes outputs y = (shift + scale * x) ^ power.

optionalfloat power = 1 [default = 1.0];

optionalfloat scale = 2 [default = 1.0];

optionalfloat shift = 3 [default = 0.0];

}


messagePythonParameter {

optionalstring module = 1;

optionalstring layer = 2;

//This value is set to the attribute `param_str` of the `PythonLayer`object

//in Python before calling the `setup()` method. This could be anumber,

//string, dictionary in Python dict format, JSON, etc. You may parsethis

//string in `setup` method and use it in `forward` and `backward`.

optionalstring param_str = 3 [default = ''];

//Whether this PythonLayer is shared among worker solvers during dataparallelism.

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

optionalbool share_in_parallel = 4 [default = false];

}


//Message that stores parameters used by RecurrentLayer

messageRecurrentParameter {

//The dimension of the output (and usually hidden state) representation--

//must be explicitly set to non-zero.

optionaluint32 num_output = 1 [default = 0];


optionalFillerParameter weight_filler = 2; // The filler for the weight

optionalFillerParameter bias_filler = 3; // The filler for the bias


//Whether to enable displaying debug_info in the unrolled recurrentnet.

optionalbool debug_info = 4 [default = false];


//Whether to add as additional inputs (bottoms) the initial hiddenstate

//blobs, and add as additional outputs (tops) the final timestep hiddenstate

//blobs. The number of additional bottom/top blobs required depends onthe

//recurrent architecture -- e.g., 1 for RNNs, 2 for LSTMs.

optionalbool expose_hidden = 5 [default = false];

}


//Message that stores parameters used by ReductionLayer

messageReductionParameter {

enumReductionOp {

SUM= 1;

ASUM= 2;

SUMSQ= 3;

MEAN= 4;

}


optionalReductionOp operation = 1 [default = SUM]; // reduction operation


//The first axis to reduce to a scalar -- may be negative to index fromthe

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

//(Currently, only reduction along ALL "tail" axes issupported; 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 emptyshape

//(count 1), performing reduction across the entire input --

//often useful for creating new loss functions.

optionalint32 axis = 2 [default = 0];


optionalfloat coeff = 3 [default = 1.0]; // coefficient for output

}


//Message that stores parameters used by ReLULayer

messageReLUParameter {

//Allow non-zero slope for negative inputs to speed up optimization

//Described in:

//Maas, A. L., Hannun, A. Y., & Ng, A. Y. (2013). Rectifiernonlinearities

//improve neural network acoustic models. In ICML Workshop on DeepLearning

//for Audio, Speech, and Language Processing.

optionalfloat negative_slope = 1 [default = 0];

enumEngine {

DEFAULT= 0;

CAFFE= 1;

CUDNN= 2;

}

optionalEngine engine = 2 [default = DEFAULT];

}


messageReshapeParameter {

//Specify the output dimensions. If some of the dimensions are set to0,

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

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

//

optionalBlobShape shape = 1;


//axis and num_axes control the portion of the bottom blob's shape thatare

//replaced by (included in) the reshape. By default (axis == 0 and

//num_axes == -1), the entire bottom blob shape is included in thereshape,

//and hence the shape field must specify the entire output shape.

//

//axis may be non-zero to retain some portion of the beginning of theinput

//shape (and may be negative to index from the end; e.g., -1 to beginthe

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

//

optionalint32 axis = 2 [default = 0];

optionalint32 num_axes = 3 [default = -1];

}


messageScaleParameter {

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

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

//(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 thevalue of

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

optionalint32 axis = 1 [default = 1];


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

//a learned parameter of the layer. Otherwise, num_axes is determinedby 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.

optionalint32 num_axes = 2 [default = 1];


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

optionalFillerParameter filler = 3;


//Whether to also learn a bias (equivalent to a ScaleLayer+BiasLayer,but

//may be more efficient). Initialized with bias_filler (defaults to0).

optionalbool bias_term = 4 [default = false];

optionalFillerParameter bias_filler = 5;

}


messageSigmoidParameter {

enumEngine {

DEFAULT= 0;

CAFFE= 1;

CUDNN= 2;

}

optionalEngine engine = 1 [default = DEFAULT];

}


messageSliceParameter {

//The axis along which to slice -- may be negative to index from theend

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

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

optionalint32 axis = 3 [default = 1];

repeateduint32 slice_point = 2;


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

optionaluint32 slice_dim = 1 [default = 1];

}


//Message that stores parameters used by SoftmaxLayer,SoftmaxWithLossLayer

messageSoftmaxParameter {

enumEngine {

DEFAULT= 0;

CAFFE= 1;

CUDNN= 2;

}

optionalEngine engine = 1 [default = DEFAULT];


//The axis along which to perform the softmax -- may be negative toindex

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

//Any other axes will be evaluated as independent softmaxes.

optionalint32 axis = 2 [default = 1];

}


messageTanHParameter {

enumEngine {

DEFAULT= 0;

CAFFE= 1;

CUDNN= 2;

}

optionalEngine engine = 1 [default = DEFAULT];

}


//Message that stores parameters used by TileLayer

messageTileParameter {

//The index of the axis to tile.

optionalint32 axis = 1 [default = 1];


//The number of copies (tiles) of the blob to output.

optionalint32 tiles = 2;

}


//Message that stores parameters used by ThresholdLayer

messageThresholdParameter {

optionalfloat threshold = 1 [default = 0]; // Strictly positive values

}


messageWindowDataParameter {

//Specify the data source.

optionalstring source = 1;

//For data pre-processing, we can do simple scaling and subtracting the

//data mean, if provided. Note that the mean subtraction is alwayscarried

//out before scaling.

optionalfloat scale = 2 [default = 1];

optionalstring mean_file = 3;

//Specify the batch size.

optionaluint32 batch_size = 4;

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

optionaluint32 crop_size = 5 [default = 0];

//Specify if we want to randomly mirror data.

optionalbool mirror = 6 [default = false];

//Foreground (object) overlap threshold

optionalfloat fg_threshold = 7 [default = 0.5];

//Background (non-object) overlap threshold

optionalfloat bg_threshold = 8 [default = 0.5];

//Fraction of batch that should be foreground objects

optionalfloat fg_fraction = 9 [default = 0.25];

//Amount of contextual padding to add around a window

//(used only by the window_data_layer)

optionaluint32 context_pad = 10 [default = 0];

//Mode for cropping out a detection window

//warp: cropped window is warped to a fixed size and aspect ratio

//square: the tightest square around the window is cropped

optionalstring crop_mode = 11 [default = "warp"];

//cache_images: will load all images in memory for faster access

optionalbool cache_images = 12 [default = false];

//append root_folder to locate images

optionalstring root_folder = 13 [default = ""];

}


messageSPPParameter {

enumPoolMethod {

MAX= 0;

AVE= 1;

STOCHASTIC= 2;

}

optionaluint32 pyramid_height = 1;

optionalPoolMethod pool = 2 [default = MAX]; // The pooling method

enumEngine {

DEFAULT= 0;

CAFFE= 1;

CUDNN= 2;

}

optionalEngine engine = 6 [default = DEFAULT];

}


//DEPRECATED: use LayerParameter.

messageV1LayerParameter {

repeatedstring bottom = 2;

repeatedstring top = 3;

optionalstring name = 4;

repeatedNetStateRule include = 32;

repeatedNetStateRule exclude = 33;

enumLayerType {

NONE= 0;

ABSVAL= 35;

ACCURACY= 1;

ARGMAX= 30;

BNLL= 2;

CONCAT= 3;

CONTRASTIVE_LOSS= 37;

CONVOLUTION= 4;

DATA= 5;

DECONVOLUTION= 39;

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;

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;

SOFTMAX= 20;

SOFTMAX_LOSS= 21;

SPLIT= 22;

SLICE= 33;

TANH= 23;

WINDOW_DATA= 24;

THRESHOLD= 31;

}

optionalLayerType type = 5;

repeatedBlobProto blobs = 6;

repeatedstring param = 1001;

repeatedDimCheckMode blob_share_mode = 1002;

enumDimCheckMode {

STRICT= 0;

PERMISSIVE= 1;

}

repeatedfloat blobs_lr = 7;

repeatedfloat weight_decay = 8;

repeatedfloat loss_weight = 35;

optionalAccuracyParameter accuracy_param = 27;

optionalArgMaxParameter argmax_param = 23;

optionalConcatParameter concat_param = 9;

optionalContrastiveLossParameter contrastive_loss_param = 40;

optionalConvolutionParameter convolution_param = 10;

optionalDataParameter data_param = 11;

optionalDropoutParameter dropout_param = 12;

optionalDummyDataParameter dummy_data_param = 26;

optionalEltwiseParameter eltwise_param = 24;

optionalExpParameter exp_param = 41;

optionalHDF5DataParameter hdf5_data_param = 13;

optionalHDF5OutputParameter hdf5_output_param = 14;

optionalHingeLossParameter hinge_loss_param = 29;

optionalImageDataParameter image_data_param = 15;

optionalInfogainLossParameter infogain_loss_param = 16;

optionalInnerProductParameter inner_product_param = 17;

optionalLRNParameter lrn_param = 18;

optionalMemoryDataParameter memory_data_param = 22;

optionalMVNParameter mvn_param = 34;

optionalPoolingParameter pooling_param = 19;

optionalPowerParameter power_param = 21;

optionalReLUParameter relu_param = 30;

optionalSigmoidParameter sigmoid_param = 38;

optionalSoftmaxParameter softmax_param = 39;

optionalSliceParameter slice_param = 31;

optionalTanHParameter tanh_param = 37;

optionalThresholdParameter threshold_param = 25;

optionalWindowDataParameter window_data_param = 20;

optionalTransformationParameter transform_param = 36;

optionalLossParameter loss_param = 42;

optionalV0LayerParameter layer = 1;

}


//DEPRECATED: V0LayerParameter is the old way of specifying layerparameters

//in Caffe. We keep this message type around for legacy support.

messageV0LayerParameter {

optionalstring name = 1; // the layer name

optionalstring type = 2; // the string to specify the layer type


//Parameters to specify layers with inner products.

optionaluint32 num_output = 3; // The number of outputs for the layer

optionalbool biasterm = 4 [default = true]; // whether to have bias terms

optionalFillerParameter weight_filler = 5; // The filler for the weight

optionalFillerParameter bias_filler = 6; // The filler for the bias


optionaluint32 pad = 7 [default = 0]; // The padding size

optionaluint32 kernelsize = 8; // The kernel size

optionaluint32 group = 9 [default = 1]; // The group size for group conv

optionaluint32 stride = 10 [default = 1]; // The stride

enumPoolMethod {

MAX= 0;

AVE= 1;

STOCHASTIC= 2;

}

optionalPoolMethod pool = 11 [default = MAX]; // The pooling method

optionalfloat dropout_ratio = 12 [default = 0.5]; // dropout ratio


optionaluint32 local_size = 13 [default = 5]; // for local response norm

optionalfloat alpha = 14 [default = 1.]; // for local response norm

optionalfloat beta = 15 [default = 0.75]; // for local response norm

optionalfloat k = 22 [default = 1.];


//For data layers, specify the data source

optionalstring source = 16;

//For data pre-processing, we can do simple scaling and subtracting the

//data mean, if provided. Note that the mean subtraction is alwayscarried

//out before scaling.

optionalfloat scale = 17 [default = 1];

optionalstring meanfile = 18;

//For data layers, specify the batch size.

optionaluint32 batchsize = 19;

//For data layers, specify if we would like to randomly crop an image.

optionaluint32 cropsize = 20 [default = 0];

//For data layers, specify if we want to randomly mirror data.

optionalbool mirror = 21 [default = false];


//The blobs containing the numeric parameters of the layer

repeatedBlobProto blobs = 50;

//The ratio that is multiplied on the global learning rate. If you wantto

//set the learning ratio for one blob, you need to set it for allblobs.

repeatedfloat blobs_lr = 51;

//The weight decay that is multiplied on the global weight decay.

repeatedfloat weight_decay = 52;


//The rand_skip variable is for the data layer to skip a few datapoints

//to avoid all asynchronous sgd clients to start at the same point. Theskip

//point would be set as rand_skip * rand(0,1). Note that rand_skipshould not

//be larger than the number of keys in the database.

optionaluint32 rand_skip = 53 [default = 0];


//Fields related to detection (det_*)

//foreground (object) overlap threshold

optionalfloat det_fg_threshold = 54 [default = 0.5];

//background (non-object) overlap threshold

optionalfloat det_bg_threshold = 55 [default = 0.5];

//Fraction of batch that should be foreground objects

optionalfloat det_fg_fraction = 56 [default = 0.25];


//optional bool OBSOLETE_can_clobber = 57 [default = true];


//Amount of contextual padding to add around a window

//(used only by the window_data_layer)

optionaluint32 det_context_pad = 58 [default = 0];


//Mode for cropping out a detection window

//warp: cropped window is warped to a fixed size and aspect ratio

//square: the tightest square around the window is cropped

optionalstring det_crop_mode = 59 [default = "warp"];


//For ReshapeLayer, one needs to specify the new dimensions.

optionalint32 new_num = 60 [default = 0];

optionalint32 new_channels = 61 [default = 0];

optionalint32 new_height = 62 [default = 0];

optionalint32 new_width = 63 [default = 0];


//Whether or not ImageLayer should shuffle the list of files at everyepoch.

//It will also resize images if new_height or new_width are not zero.

optionalbool shuffle_images = 64 [default = false];


//For ConcatLayer, one needs to specify the dimension forconcatenation, and

//the other dimensions must be the same for all the bottom blobs.

//By default it will concatenate blobs along the channels dimension.

optionaluint32 concat_dim = 65 [default = 1];


optionalHDF5OutputParameter hdf5_output_param = 1001;

}


messagePReLUParameter {

//Parametric ReLU described in K. He et al, Delving Deep intoRectifiers:

//Surpassing Human-Level Performance on ImageNet Classification, 2015.


//Initial value of a_i. Default is a_i=0.25 for all i.

optionalFillerParameter filler = 1;

//Whether or not slope parameters are shared across channels.

optionalbool channel_shared = 2 [default = false];

}



用Excel或WPS做两独立样本的T检验 一般情况下收集数据时常用的是Excel或者WPS,但统计时却用SPSS等软件进行统计学分析,经常很多人找不到SPSS的安装包,或者苦于正版激活或忘记教程,其实Excel或WPS自带函数就足够了,均数、标准差以及统计检验都是一个函数而已。解释:先做F检验,如果F>0.05就做T检验,Ttset里的数据为两组的数据的比较,结果如下。A组的均数计算 =AVERAGE(B2:B6)A组的标准差计算 =STDEV(B2:B6)B组的标准差计算=STDEV(B7:B19)分组 数值 A组均数 A组标准差 p值。 阅读详情

相关推荐

S7-1500与WinCC GroupDisplay组显示的高效配置指南

本文详细介绍了S7-1500 PLC与WinCC GroupDisplay组显示功能的高效配置方法,涵盖报警状态配置、WinCC端组显示控件设置及常见问题排查。通过实战案例和优化建议,帮助工程师快速掌握工业自动化项目中报警信息可视化的关键技术,提升生产线监控效率。

weixin_29292535的博客 441

Caffe 层级结构

文章目录一、层的基本数据结构三、数据层三、视觉层四、激活函数层五、损失及准确率层六、特殊层七、参考资料 一、层的基本数据结构 message LayerParameter { optional string name = 1; optional string type = 2; repeated string bottom = 3; repeated string top ............

Man 1844

【数字图像处理第四版课后习题答案】第2章 数字图像基础(含英文原版)

如图 P2.3 所示,视网膜图像中与点相对应的直径 x 是由类似的三角形得到的。即得出 x = 0.085d。根据第 2.1 节中的讨论,并结合一些自由解释,我们可以将眼窝视为一个方形传感器阵列,拥有大约 337,000 个元素,这相当于一个大约 580×580 个元素的阵列。假设元素间距相等,则在 1.5 毫米长的直线上有 580 个元素和 579 个空间,共计 1,159 个。换句话说,如果一个点的直径 d<1.3×10-6 m,或者 d<15.3×10 m,眼睛就无法检测到这个点。

weixin_56463218的博客 1万+

caffe常用网络层及参数说明

1.Normalize层 layer { name: "conv4_3_norm" type: "Normalize" bottom: "conv4_3" top: "conv4_3_norm" norm_param { across_spatial: false scale_filler { type: "constant" val...

CPFelix的博客 1069

数字后端CTS实战:从时钟信号原理到Innovus时钟树综合优化

在数字集成电路设计中,时钟信号是驱动所有时序逻辑的基准,其质量直接决定芯片能否稳定工作。理想时钟被视为完美方波,而真实芯片中的时钟因物理传播延迟会产生偏斜(clock skew)与延迟(latency),这是后端设计必须解决的核心矛盾。时钟树综合(CTS)作为布局与布线之间的关键步骤,通过插入缓冲器、反相器构建平衡的时钟分配网络,从而改善时序收敛并降低信号完整性风险。掌握时钟单元选型、SDC约束设置、useful skew应用以及Innovus工具的操作要点,是物理实现工程师提升设计成功率的重要能力。本文从

weixin_34150830的博客 464

SocraticLM: Exploring Socratic Personalized Teaching with Large Language Models

大型语言模型(LLM)被认为是推进智能教育的一项关键技术,因为它们展示了深入理解教学场景和为学生提供个性化指导的潜力。然而,当前个性化教学中基于LLM的应用主要遵循“问答”范式,学生被动地获得答案和解释。在本文中,我们提出了苏格拉底式教学模式(SocraticLM ),它实现了一种苏格拉底式的“发人深省”的教学范式,实现了真正的课堂教师的角色,让学生积极参与到真正掌握解决问题所需的思考过程中。

weixin_43961909的博客 2887

Caffe 中Eltwise层详解

Eltwise : element-wise eltwise layer是caffe提供的按元素操作层。它支持3种基本操作:  1. PROD:按元素乘积  2. SUM:按元素求和(默认)  3. MAX:保存元素大者 进行何种操作可以在layer里面通过定义EltwiseOp : x #x:=0,1,2 除此之外,该层还定义了 coeff 参数,该参数只对SUM操作起作用。  最后,caf...

Black eyes的博客 5793

46、搭建与配置FTP服务器全攻略

本文详细介绍了如何搭建与配置FTP服务器,以vsftpd为例,涵盖了FTP基础概念、安装步骤、服务控制、安全设置、用户权限管理、文件上传支持、互联网共享配置、客户端使用以及常见问题解决等内容。旨在帮助用户高效、安全地实现文件共享与管理。

time3的博客 88

caffe---之eltwise层

Eltwise : element-wise eltwise layer是caffe提供的按元素操作层。它支持3种基本操作: 1. PROD:按元素乘积 2. SUM:按元素求和(默认) 3. MAX:保存元素大者 进行何种操作可以在layer里面通过定义EltwiseOp : x #x:=0,1,2 除此之外,该层还定义了 coeff 参数,该参数只对SUM操作起作用。 最后,caffe还设...

zxyhhjs2017的博客 875

基于粒子群优化的PID控制在药液流量控制系统中的应用

本文提出了一种基于粒子群优化(PSO)的PID控制算法,用于药液流量控制系统。系统采用C37控制器和Codesys 2.3编程环境实现,通过传感器实时监测流量、压力和车速,并控制水泵占空比和电动球阀开度来精确调节药液流量。硬件配置包括FT-2000流量传感器、PT-3000压力传感器和MV-500电动球阀等。控制算法将PSO与PID结合,使用ITAE指标优化PID参数,在Codesys中实现了包含PSO优化循环、PID控制等功能的程序模块。该系统通过分层控制策略和智能优化算法,提高了药液流量控制的精度和响应

AI的内部世界的博客 250

【系统架构设计师-2025上半年真题】综合知识-参考答案及详解(75题完全回忆版)

【系统架构设计师-2025上半年真题】案例分析-参考答案及部分详解

数据知道的博客 1万+

Caffe 初学拾遗(二) 利用prototxt文件传递变量

利用prototxt向Caffe中定义的某些层传递参数: 1.  首先推荐一款源代码查看工具:Source Insight ,导入源码包以及调整字体大小可以参考Baidu。 2. 这里给出修改caffe.proto文件,传递参数的方案: 2.1 假定希望向卷基层传递一个参数 int32 x,先在.proto文件中添加: message ConvolutionParame

ColdCode's Hello World~ 1767

【PHP面试题29】什么是PHP-FPM?它与PHP和Nginx有什么关系

PHP面试专区。计划将全覆盖PHP开发领域所有的面试题,对标资深工程师/架构师序列,欢迎大家提前关注锁定。PHP-FPM(FastCGI Process Manager)是PHP的FastCGI进程管理器,它是PHP 5.3.3及更高版本的一部分。它通过为每个请求分配一个独立的进程来提高PHP脚本的执行效率和性能,并且可以与Web服务器(如Nginx、Apache等)进行通信。PHP-FPM是PHP的FastCGI进程管理器,它通过为每个请求分配一个独立的进程来提高PHP脚本的执行效率和性能。

黑夜开发者的博客 1479

caffe的prototxt文件

【参考】 data_layer 1、Data层 layer { name: "cifar" type: "Data" top: "data" top: "label" include { phase: TRAIN } transform_param { mean_file: "examples/cifar10/mean.binaryproto...

OneCoder的博客 2万+

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Caffe之prototxt解析

参考文章:Caffe学习笔记(三):cifar10_quick_train_test.prototxt配置文件分析               https://blog.youkuaiyun.com/c406495762/article/details/70255099caffe中prototxt中各个层的解析               https://blog.youkuaiyun.com/w113691/artic...

qccz123456的博客 4030

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

caffe crop层理解

转自:  http://www.cnblogs.com/kunyuanjushi/p/5937083.html 在Fully Convolutional Networks(FCN)中,会用到Crop 层,他的主要作用是进行裁切。下面我们举一个例子来说明如何使用Crop 层。     Caffe中的数据是以 blobs形式存在的,blob是四维数据,即 (Batch s

无奈的小心酸的博客 1995

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

Python:caffe中Python生成prototxt文件

Python:caffe中Python生成prototxt文件比如卷积的初始化参数:weight_filler=dict(type=’xavier’), 以及池化的参数:pool=P.Pooling.MAX 还有数据层的参数:spec.data,spec.label=L.ImageData(source=train_list,batch_size=batch_size,shuffle=True,n...

BigCowPeking 1180

Caffe入门:slice层

Slice Layer接收top blob的数据,并再指定维度做分割处理。可根据给定的维度将bottom切分成多个top,用于具有多个输入多任务的网络。slice层有三个参数,axis和slice_dim用于指定切分的维度是什么,默认为1,切分channel维度(一般是四个维度:【N,C,W,H】);还有另一个选择就是切分num,类似于Concat层,但是注意这两个参数只能指定一个,常用axis。...

那年聪聪 3225

Caffe框架-入门浅谈及碰到的坑

Caffe学习主要围绕:数据、deploy.prototxt文件、***.caffemodel文件、solver.prototxt文件、训练脚本文件 数据 数据层有多种格式,可参考:https://www.cnblogs.com/denny402/p/5070928.html 目前我所使用的是ImageData,因为caffe数据增强功能较少,因此自己修改caffe源码,增加数据增强功能,参...

持续关注并分享目标检测、数据生成、视频驱动、跨模态、分割、关键点等领域前沿技术 2491

caffe中参数设置的解析

lenet_solver.prototxt: net: "examples/mnist/lenet_train_test.prototxt" test_iter: 100 test_interval: 500 base_lr: 0.01 momentum: 0.9 type: SGD weight_decay: 0.0005 lr_policy: "inv" gamma: 0.0001 powe

竹馨shine的专栏 5775

caffe中lenet_train_test.prototxt配置文件注解

caffe框架下的lenet.prototxt定义了一个广义上的LeNet模型,对MNIST数据库进行训练实际使用的是lenet_train_test.prototxt模型。 lenet_train_test.prototxt模型定义了一个包含2个卷积层,2个池化层,2个全连接层,1个激活函数层的卷积神经网络模型,模型如下: name: "LeNet"

牧野的博客 1448

Caffe 中关于 LetNet-5 网络的定义文件 lenet.prototxt 解析

在 https://github.com/BVLC/caffe/blob/master/examples/mnist 是Caffe关于LetNet-5的相关文件, 这里面有几个后缀是 .prototxt 的文件,它是用 protocol buffer 这个工具生成的文件。百度百科对 protocol buffer 描述如下: protocol buffer(以下简称PB)是google 的一种

AI小作坊 的博客 2932

caffe 的layer的参数说明

最近在学习caffe做实验 今天就记录一下layer的参数及这些常用的参数的解释吧主要还是参考官方网站 http://caffe.berkeleyvision.org/tutorial/layers.html下面就介绍一下常用的layer的配置 以caffe中根目录下的models 中caffenet 其中主要有三个文件 deploy.prototxt solver.protot

Losteng的博客 1万+

python装饰器带参数函数二阶导数公式_MVision/caffe_简介_使用.md at master · Ewenwan/MVision · GitHub...

2. caffe 模型配置文件 prototxt 详解每个模型由多个 层 构成layer {{{{name: "{}" #层名字,可随意取名type: "{}" #层类型 数据层Data 卷积层Convolution 池化层Pooling 非线性变换、内积运算,以及数据加载、归一化和损失计算 等bottom: "{}"# 层入口 输入top: "{}"{{}}# 层出口 输出 可以有多个 bot...

weixin_39892460的博客 192

*_train_test.prototxt,*_deploy.prototxt,*_slover.prototxt文件编写时注意事项

原文:http://blog.youkuaiyun.com/sunshine_in_moon/article/details/49472901 本文只是自己学习一天的总结,如有不对的地方,欢迎指正! 欢迎大家转载,但请标明出处,谢谢! 1、*_train_test.prototxt文件 这是训练与测试网络配置文件 (1)在数据层中 参数include{                 

爱吃鱼的猫 701

用Python重写resnet配置文件.prototxt

写代码时的发现 小前言:理论跟实践相结合才是王道啊,阅读代码是有些理论不动,顺便查阅资料,然后根据自己的理解记录下来。 1.其中发现代码中Relu层和BatchNorm层,还有Scale使用了in_place = True操作,发现,只有当输入输出都是一样的情况下才可以这样操作。 参考博客caffe中的in-place操作 2.对resnet中加入的BatchNorm和Scale的理解 这是批量正...

小膜仙的博客 630
上一篇: AlphaGo Zero论文中文版:Mastering the game of Go without human knowledge
下一篇: R-CNN & Fast R-CNN & Faster R-CNN
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值