repeated LayerParameter layer = 100; // ID 100 so layers are printed last.
// DEPRECATED: use 'layer' instead.
- // repeated LayerParameter layers = 2; // a bunch of layers.
+ repeated V1LayerParameter layers = 2;
}
// NOTE
// 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.
-
- // DEPRECATED: The layer parameters specified as a V0LayerParameter.
- // This should never be used by any code except to upgrade to the new
- // LayerParameter specification.
- optional V0LayerParameter layer = 1;
}
// Message that stores parameters used to apply transformation
optional string root_folder = 13 [default = ""];
}
+// DEPRECATED: use LayerParameter.
+message V1LayerParameter {
+ repeated string bottom = 2;
+ repeated string top = 3;
+ optional string name = 4;
+ repeated NetStateRule include = 32;
+ repeated NetStateRule exclude = 33;
+ enum LayerType {
+ NONE = 0;
+ ABSVAL = 35;
+ ACCURACY = 1;
+ ARGMAX = 30;
+ BNLL = 2;
+ CONCAT = 3;
+ CONTRASTIVE_LOSS = 37;
+ CONVOLUTION = 4;
+ DATA = 5;
+ 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;
+ }
+ optional LayerType type = 5;
+ repeated BlobProto blobs = 6;
+ repeated string param = 1001;
+ repeated DimCheckMode blob_share_mode = 1002;
+ enum DimCheckMode {
+ STRICT = 0;
+ PERMISSIVE = 1;
+ }
+ repeated float blobs_lr = 7;
+ repeated float weight_decay = 8;
+ repeated float loss_weight = 35;
+ optional AccuracyParameter accuracy_param = 27;
+ optional ArgMaxParameter argmax_param = 23;
+ optional ConcatParameter concat_param = 9;
+ optional ContrastiveLossParameter contrastive_loss_param = 40;
+ optional ConvolutionParameter convolution_param = 10;
+ optional DataParameter data_param = 11;
+ optional DropoutParameter dropout_param = 12;
+ optional DummyDataParameter dummy_data_param = 26;
+ optional EltwiseParameter eltwise_param = 24;
+ optional ExpParameter exp_param = 41;
+ optional HDF5DataParameter hdf5_data_param = 13;
+ optional HDF5OutputParameter hdf5_output_param = 14;
+ optional HingeLossParameter hinge_loss_param = 29;
+ optional ImageDataParameter image_data_param = 15;
+ optional InfogainLossParameter infogain_loss_param = 16;
+ optional InnerProductParameter inner_product_param = 17;
+ optional LRNParameter lrn_param = 18;
+ optional MemoryDataParameter memory_data_param = 22;
+ optional MVNParameter mvn_param = 34;
+ optional PoolingParameter pooling_param = 19;
+ optional PowerParameter power_param = 21;
+ optional ReLUParameter relu_param = 30;
+ optional SigmoidParameter sigmoid_param = 38;
+ optional SoftmaxParameter softmax_param = 39;
+ optional SliceParameter slice_param = 31;
+ optional TanHParameter tanh_param = 37;
+ optional ThresholdParameter threshold_param = 25;
+ optional WindowDataParameter window_data_param = 20;
+ optional TransformationParameter transform_param = 36;
+ optional V0LayerParameter layer = 1;
+}
+
// DEPRECATED: V0LayerParameter is the old way of specifying layer parameters
// in Caffe. We keep this message type around for legacy support.
message V0LayerParameter {
namespace caffe {
bool NetNeedsUpgrade(const NetParameter& net_param) {
- for (int i = 0; i < net_param.layer_size(); ++i) {
- if (net_param.layer(i).has_layer()) {
+ for (int i = 0; i < net_param.layers_size(); ++i) {
+ if (net_param.layers(i).has_layer()) {
return true;
}
}
if (v0_net_param.has_name()) {
net_param->set_name(v0_net_param.name());
}
- for (int i = 0; i < v0_net_param.layer_size(); ++i) {
- is_fully_compatible &= UpgradeLayerParameter(v0_net_param.layer(i),
- net_param->add_layer());
+ for (int i = 0; i < v0_net_param.layers_size(); ++i) {
+ is_fully_compatible &= UpgradeLayerParameter(v0_net_param.layers(i),
+ net_param->add_layers());
}
for (int i = 0; i < v0_net_param.input_size(); ++i) {
net_param->add_input(v0_net_param.input(i));
// Copy everything other than the layers from the original param.
param_upgraded_pad->Clear();
param_upgraded_pad->CopyFrom(param);
- param_upgraded_pad->clear_layer();
+ param_upgraded_pad->clear_layers();
// Figure out which layer each bottom blob comes from.
map<string, int> blob_name_to_last_top_idx;
for (int i = 0; i < param.input_size(); ++i) {
const string& blob_name = param.input(i);
blob_name_to_last_top_idx[blob_name] = -1;
}
- for (int i = 0; i < param.layer_size(); ++i) {
- const LayerParameter& layer_connection = param.layer(i);
+ for (int i = 0; i < param.layers_size(); ++i) {
+ const V1LayerParameter& layer_connection = param.layers(i);
const V0LayerParameter& layer_param = layer_connection.layer();
// Add the layer to the new net, unless it's a padding layer.
if (layer_param.type() != "padding") {
- param_upgraded_pad->add_layer()->CopyFrom(layer_connection);
+ param_upgraded_pad->add_layers()->CopyFrom(layer_connection);
}
for (int j = 0; j < layer_connection.bottom_size(); ++j) {
const string& blob_name = layer_connection.bottom(j);
if (top_idx == -1) {
continue;
}
- LayerParameter source_layer = param.layer(top_idx);
+ const V1LayerParameter& source_layer = param.layers(top_idx);
if (source_layer.layer().type() == "padding") {
// This layer has a padding layer as input -- check that it is a conv
// layer or a pooling layer and takes only one input. Also check that
<< "Padding Layer takes a single blob as input.";
CHECK_EQ(source_layer.top_size(), 1)
<< "Padding Layer produces a single blob as output.";
- int layer_index = param_upgraded_pad->layer_size() - 1;
- param_upgraded_pad->mutable_layer(layer_index)->mutable_layer()
+ int layer_index = param_upgraded_pad->layers_size() - 1;
+ param_upgraded_pad->mutable_layers(layer_index)->mutable_layer()
->set_pad(source_layer.layer().pad());
- param_upgraded_pad->mutable_layer(layer_index)
+ param_upgraded_pad->mutable_layers(layer_index)
->set_bottom(j, source_layer.bottom(0));
}
}
}
}
-bool UpgradeLayerParameter(const LayerParameter& v0_layer_connection,
- LayerParameter* layer_param) {
+bool UpgradeLayerParameter(const V1LayerParameter& v0_layer_connection,
+ V1LayerParameter* layer_param) {
bool is_fully_compatible = true;
layer_param->Clear();
for (int i = 0; i < v0_layer_connection.bottom_size(); ++i) {
return is_fully_compatible;
}
-const char* UpgradeV0LayerType(const string& type) {
+V1LayerParameter_LayerType UpgradeV0LayerType(const string& type) {
if (type == "accuracy") {
- return "Accuracy";
+ return V1LayerParameter_LayerType_ACCURACY;
} else if (type == "bnll") {
- return "BNLL";
+ return V1LayerParameter_LayerType_BNLL;
} else if (type == "concat") {
- return "Concat";
+ return V1LayerParameter_LayerType_CONCAT;
} else if (type == "conv") {
- return "Convolution";
+ return V1LayerParameter_LayerType_CONVOLUTION;
} else if (type == "data") {
- return "Data";
+ return V1LayerParameter_LayerType_DATA;
} else if (type == "dropout") {
- return "Dropout";
+ return V1LayerParameter_LayerType_DROPOUT;
} else if (type == "euclidean_loss") {
- return "EuclideanLoss";
+ return V1LayerParameter_LayerType_EUCLIDEAN_LOSS;
} else if (type == "flatten") {
- return "Flatten";
+ return V1LayerParameter_LayerType_FLATTEN;
} else if (type == "hdf5_data") {
- return "HDF5Data";
+ return V1LayerParameter_LayerType_HDF5_DATA;
} else if (type == "hdf5_output") {
- return "HDF5Output";
+ return V1LayerParameter_LayerType_HDF5_OUTPUT;
} else if (type == "im2col") {
- return "Im2Col";
+ return V1LayerParameter_LayerType_IM2COL;
} else if (type == "images") {
- return "ImageData";
+ return V1LayerParameter_LayerType_IMAGE_DATA;
} else if (type == "infogain_loss") {
- return "InfogainLoss";
+ return V1LayerParameter_LayerType_INFOGAIN_LOSS;
} else if (type == "innerproduct") {
- return "InnerProduct";
+ return V1LayerParameter_LayerType_INNER_PRODUCT;
} else if (type == "lrn") {
- return "LRN";
+ return V1LayerParameter_LayerType_LRN;
} else if (type == "multinomial_logistic_loss") {
- return "MultinomialLogisticLoss";
+ return V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS;
} else if (type == "pool") {
- return "Pooling";
+ return V1LayerParameter_LayerType_POOLING;
} else if (type == "relu") {
- return "ReLU";
+ return V1LayerParameter_LayerType_RELU;
} else if (type == "sigmoid") {
- return "Sigmoid";
+ return V1LayerParameter_LayerType_SIGMOID;
} else if (type == "softmax") {
- return "Softmax";
+ return V1LayerParameter_LayerType_SOFTMAX;
} else if (type == "softmax_loss") {
- return "SoftmaxWithLoss";
+ return V1LayerParameter_LayerType_SOFTMAX_LOSS;
} else if (type == "split") {
- return "Split";
+ return V1LayerParameter_LayerType_SPLIT;
} else if (type == "tanh") {
- return "TanH";
+ return V1LayerParameter_LayerType_TANH;
} else if (type == "window_data") {
- return "WindowData";
+ return V1LayerParameter_LayerType_WINDOW_DATA;
} else {
- LOG(FATAL) << "Unknown layer type: " << type;
- return "";
+ LOG(FATAL) << "Unknown layer name: " << type;
+ return V1LayerParameter_LayerType_NONE;
}
}
bool NetNeedsDataUpgrade(const NetParameter& net_param) {
- for (int i = 0; i < net_param.layer_size(); ++i) {
- if (net_param.layer(i).type() == "Data") {
- DataParameter layer_param = net_param.layer(i).data_param();
+ for (int i = 0; i < net_param.layers_size(); ++i) {
+ if (net_param.layers(i).type() == V1LayerParameter_LayerType_DATA) {
+ DataParameter layer_param = net_param.layers(i).data_param();
if (layer_param.has_scale()) { return true; }
if (layer_param.has_mean_file()) { return true; }
if (layer_param.has_crop_size()) { return true; }
if (layer_param.has_mirror()) { return true; }
}
- if (net_param.layer(i).type() == "ImageData") {
- ImageDataParameter layer_param = net_param.layer(i).image_data_param();
+ if (net_param.layers(i).type() == V1LayerParameter_LayerType_IMAGE_DATA) {
+ ImageDataParameter layer_param = net_param.layers(i).image_data_param();
if (layer_param.has_scale()) { return true; }
if (layer_param.has_mean_file()) { return true; }
if (layer_param.has_crop_size()) { return true; }
if (layer_param.has_mirror()) { return true; }
}
- if (net_param.layer(i).type() == "WindowData") {
- WindowDataParameter layer_param = net_param.layer(i).window_data_param();
+ if (net_param.layers(i).type() == V1LayerParameter_LayerType_WINDOW_DATA) {
+ WindowDataParameter layer_param = net_param.layers(i).window_data_param();
if (layer_param.has_scale()) { return true; }
if (layer_param.has_mean_file()) { return true; }
if (layer_param.has_crop_size()) { return true; }
return false;
}
-#define CONVERT_LAYER_TRANSFORM_PARAM(TYPE_NAME, PARAM_NAME) \
+#define CONVERT_LAYER_TRANSFORM_PARAM(TYPE, Name, param_name) \
do { \
- if (net_param->layer(i).type() == #TYPE_NAME) { \
- TYPE_NAME##Parameter* layer_param = \
- net_param->mutable_layer(i)->mutable_##PARAM_NAME##_param(); \
+ if (net_param->layers(i).type() == V1LayerParameter_LayerType_##TYPE) { \
+ Name##Parameter* layer_param = \
+ net_param->mutable_layers(i)->mutable_##param_name##_param(); \
TransformationParameter* transform_param = \
- net_param->mutable_layer(i)->mutable_transform_param(); \
+ net_param->mutable_layers(i)->mutable_transform_param(); \
if (layer_param->has_scale()) { \
transform_param->set_scale(layer_param->scale()); \
layer_param->clear_scale(); \
} while (0)
void UpgradeNetDataTransformation(NetParameter* net_param) {
- for (int i = 0; i < net_param->layer_size(); ++i) {
- CONVERT_LAYER_TRANSFORM_PARAM(Data, data);
- CONVERT_LAYER_TRANSFORM_PARAM(ImageData, image_data);
- CONVERT_LAYER_TRANSFORM_PARAM(WindowData, window_data);
+ for (int i = 0; i < net_param->layers_size(); ++i) {
+ CONVERT_LAYER_TRANSFORM_PARAM(DATA, Data, data);
+ CONVERT_LAYER_TRANSFORM_PARAM(IMAGE_DATA, ImageData, image_data);
+ CONVERT_LAYER_TRANSFORM_PARAM(WINDOW_DATA, WindowData, window_data);
}
}
for (int i = 0; i < param.input_dim_size(); ++i) {
pretty_param->add_input_dim(param.input_dim(i));
}
- for (int i = 0; i < param.layer_size(); ++i) {
+ for (int i = 0; i < param.layers_size(); ++i) {
pretty_param->add_layer()->CopyFrom(param.layer(i));
}
}