bool UpgradeLayerParameter(const LayerParameter& v0_layer_connection,
LayerParameter* layer_param) {
bool is_fully_compatible = true;
layer_param->Clear();
for (int i = 0; i < v0_layer_connection.bottom_size(); ++i) {
layer_param->add_bottom(v0_layer_connection.bottom(i));
}
for (int i = 0; i < v0_layer_connection.top_size(); ++i) {
layer_param->add_top(v0_layer_connection.top(i));
}
if (v0_layer_connection.has_layer()) {
const V0LayerParameter& v0_layer_param = v0_layer_connection.layer();
if (v0_layer_param.has_name()) {
layer_param->set_name(v0_layer_param.name());
}
const string& type = v0_layer_param.type();
if (v0_layer_param.has_type()) {
layer_param->set_type(UpgradeV0LayerType(type));
}
for (int i = 0; i < v0_layer_param.blobs_size(); ++i) {
layer_param->add_blobs()->CopyFrom(v0_layer_param.blobs(i));
}
for (int i = 0; i < v0_layer_param.blobs_lr_size(); ++i) {
layer_param->add_blobs_lr(v0_layer_param.blobs_lr(i));
}
for (int i = 0; i < v0_layer_param.weight_decay_size(); ++i) {
layer_param->add_weight_decay(v0_layer_param.weight_decay(i));
}
if (v0_layer_param.has_num_output()) {
if (type == "conv") {
layer_param->mutable_convolution_param()->set_num_output(
v0_layer_param.num_output());
} else if (type == "innerproduct") {
layer_param->mutable_inner_product_param()->set_num_output(
v0_layer_param.num_output());
} else {
LOG(ERROR) << "Unknown parameter num_output for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_biasterm()) {
if (type == "conv") {
layer_param->mutable_convolution_param()->set_bias_term(
v0_layer_param.biasterm());
} else if (type == "innerproduct") {
layer_param->mutable_inner_product_param()->set_bias_term(
v0_layer_param.biasterm());
} else {
LOG(ERROR) << "Unknown parameter biasterm for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_weight_filler()) {
if (type == "conv") {
layer_param->mutable_convolution_param()->
mutable_weight_filler()->CopyFrom(v0_layer_param.weight_filler());
} else if (type == "innerproduct") {
layer_param->mutable_inner_product_param()->
mutable_weight_filler()->CopyFrom(v0_layer_param.weight_filler());
} else {
LOG(ERROR) << "Unknown parameter weight_filler for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_bias_filler()) {
if (type == "conv") {
layer_param->mutable_convolution_param()->
mutable_bias_filler()->CopyFrom(v0_layer_param.bias_filler());
} else if (type == "innerproduct") {
layer_param->mutable_inner_product_param()->
mutable_bias_filler()->CopyFrom(v0_layer_param.bias_filler());
} else {
LOG(ERROR) << "Unknown parameter bias_filler for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_pad()) {
if (type == "conv") {
layer_param->mutable_convolution_param()->set_pad(v0_layer_param.pad());
} else if (type == "pool") {
layer_param->mutable_pooling_param()->set_pad(v0_layer_param.pad());
} else {
LOG(ERROR) << "Unknown parameter pad for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_kernelsize()) {
if (type == "conv") {
layer_param->mutable_convolution_param()->set_kernel_size(
v0_layer_param.kernelsize());
} else if (type == "pool") {
layer_param->mutable_pooling_param()->set_kernel_size(
v0_layer_param.kernelsize());
} else {
LOG(ERROR) << "Unknown parameter kernelsize for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_group()) {
if (type == "conv") {
layer_param->mutable_convolution_param()->set_group(
v0_layer_param.group());
} else {
LOG(ERROR) << "Unknown parameter group for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_stride()) {
if (type == "conv") {
layer_param->mutable_convolution_param()->set_stride(
v0_layer_param.stride());
} else if (type == "pool") {
layer_param->mutable_pooling_param()->set_stride(
v0_layer_param.stride());
} else {
LOG(ERROR) << "Unknown parameter stride for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_pool()) {
if (type == "pool") {
V0LayerParameter_PoolMethod pool = v0_layer_param.pool();
switch (pool) {
case V0LayerParameter_PoolMethod_MAX:
layer_param->mutable_pooling_param()->set_pool(
PoolingParameter_PoolMethod_MAX);
break;
case V0LayerParameter_PoolMethod_AVE:
layer_param->mutable_pooling_param()->set_pool(
PoolingParameter_PoolMethod_AVE);
break;
case V0LayerParameter_PoolMethod_STOCHASTIC:
layer_param->mutable_pooling_param()->set_pool(
PoolingParameter_PoolMethod_STOCHASTIC);
break;
default:
LOG(ERROR) << "Unknown pool method " << pool;
is_fully_compatible = false;
}
} else {
LOG(ERROR) << "Unknown parameter pool for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_dropout_ratio()) {
if (type == "dropout") {
layer_param->mutable_dropout_param()->set_dropout_ratio(
v0_layer_param.dropout_ratio());
} else {
LOG(ERROR) << "Unknown parameter dropout_ratio for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_local_size()) {
if (type == "lrn") {
layer_param->mutable_lrn_param()->set_local_size(
v0_layer_param.local_size());
} else {
LOG(ERROR) << "Unknown parameter local_size for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_alpha()) {
if (type == "lrn") {
layer_param->mutable_lrn_param()->set_alpha(v0_layer_param.alpha());
} else {
LOG(ERROR) << "Unknown parameter alpha for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_beta()) {
if (type == "lrn") {
layer_param->mutable_lrn_param()->set_beta(v0_layer_param.beta());
} else {
LOG(ERROR) << "Unknown parameter beta for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_source()) {
if (type == "data") {
layer_param->mutable_data_param()->set_source(v0_layer_param.source());
} else if (type == "hdf5_data") {
layer_param->mutable_hdf5_data_param()->set_source(
v0_layer_param.source());
} else if (type == "images") {
layer_param->mutable_image_data_param()->set_source(
v0_layer_param.source());
} else if (type == "window_data") {
layer_param->mutable_window_data_param()->set_source(
v0_layer_param.source());
} else if (type == "infogain_loss") {
layer_param->mutable_infogain_loss_param()->set_source(
v0_layer_param.source());
} else {
LOG(ERROR) << "Unknown parameter source for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_scale()) {
layer_param->mutable_transform_param()->
set_scale(v0_layer_param.scale());
}
if (v0_layer_param.has_meanfile()) {
layer_param->mutable_transform_param()->
set_mean_file(v0_layer_param.meanfile());
}
if (v0_layer_param.has_batchsize()) {
if (type == "data") {
layer_param->mutable_data_param()->set_batch_size(
v0_layer_param.batchsize());
} else if (type == "hdf5_data") {
layer_param->mutable_hdf5_data_param()->set_batch_size(
v0_layer_param.batchsize());
} else if (type == "images") {
layer_param->mutable_image_data_param()->set_batch_size(
v0_layer_param.batchsize());
} else if (type == "window_data") {
layer_param->mutable_window_data_param()->set_batch_size(
v0_layer_param.batchsize());
} else {
LOG(ERROR) << "Unknown parameter batchsize for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_cropsize()) {
layer_param->mutable_transform_param()->
set_crop_size(v0_layer_param.cropsize());
}
if (v0_layer_param.has_mirror()) {
layer_param->mutable_transform_param()->
set_mirror(v0_layer_param.mirror());
}
if (v0_layer_param.has_rand_skip()) {
if (type == "data") {
layer_param->mutable_data_param()->set_rand_skip(
v0_layer_param.rand_skip());
} else if (type == "images") {
layer_param->mutable_image_data_param()->set_rand_skip(
v0_layer_param.rand_skip());
} else {
LOG(ERROR) << "Unknown parameter rand_skip for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_shuffle_images()) {
if (type == "images") {
layer_param->mutable_image_data_param()->set_shuffle(
v0_layer_param.shuffle_images());
} else {
LOG(ERROR) << "Unknown parameter shuffle for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_new_height()) {
if (type == "images") {
layer_param->mutable_image_data_param()->set_new_height(
v0_layer_param.new_height());
} else {
LOG(ERROR) << "Unknown parameter new_height for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_new_width()) {
if (type == "images") {
layer_param->mutable_image_data_param()->set_new_width(
v0_layer_param.new_width());
} else {
LOG(ERROR) << "Unknown parameter new_width for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_concat_dim()) {
if (type == "concat") {
layer_param->mutable_concat_param()->set_concat_dim(
v0_layer_param.concat_dim());
} else {
LOG(ERROR) << "Unknown parameter concat_dim for layer type " << type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_det_fg_threshold()) {
if (type == "window_data") {
layer_param->mutable_window_data_param()->set_fg_threshold(
v0_layer_param.det_fg_threshold());
} else {
LOG(ERROR) << "Unknown parameter det_fg_threshold for layer type "
<< type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_det_bg_threshold()) {
if (type == "window_data") {
layer_param->mutable_window_data_param()->set_bg_threshold(
v0_layer_param.det_bg_threshold());
} else {
LOG(ERROR) << "Unknown parameter det_bg_threshold for layer type "
<< type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_det_fg_fraction()) {
if (type == "window_data") {
layer_param->mutable_window_data_param()->set_fg_fraction(
v0_layer_param.det_fg_fraction());
} else {
LOG(ERROR) << "Unknown parameter det_fg_fraction for layer type "
<< type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_det_context_pad()) {
if (type == "window_data") {
layer_param->mutable_window_data_param()->set_context_pad(
v0_layer_param.det_context_pad());
} else {
LOG(ERROR) << "Unknown parameter det_context_pad for layer type "
<< type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_det_crop_mode()) {
if (type == "window_data") {
layer_param->mutable_window_data_param()->set_crop_mode(
v0_layer_param.det_crop_mode());
} else {
LOG(ERROR) << "Unknown parameter det_crop_mode for layer type "
<< type;
is_fully_compatible = false;
}
}
if (v0_layer_param.has_hdf5_output_param()) {
if (type == "hdf5_output") {
layer_param->mutable_hdf5_output_param()->CopyFrom(
v0_layer_param.hdf5_output_param());
} else {
LOG(ERROR) << "Unknown parameter hdf5_output_param for layer type "
<< type;
is_fully_compatible = false;
}
}
}
return is_fully_compatible;
}
